* fix(#711): wire autonomous convergence flag * Update wise-ibex-tumble.md --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
This commit is contained in:
Jeremy McSpadden
5
.changeset/wise-ibex-tumble.md
Normal file
5
.changeset/wise-ibex-tumble.md
Normal file
@@ -0,0 +1,5 @@
|
||||
---
|
||||
type: Fixed
|
||||
pr: 729
|
||||
---
|
||||
**`/gsd-autonomous --converge` now routes phase planning through plan-review convergence** instead of silently ignoring the flag. (#711)
|
||||
@@ -1,7 +1,7 @@
|
||||
---
|
||||
name: gsd:autonomous
|
||||
description: Run all remaining phases autonomously — discuss→plan→execute per phase
|
||||
argument-hint: "[--from N] [--to N] [--only N] [--interactive]"
|
||||
argument-hint: "[--from N] [--to N] [--only N] [--interactive] [--converge]"
|
||||
effort: xhigh
|
||||
allowed-tools:
|
||||
- Read
|
||||
@@ -37,6 +37,10 @@ Optional flags:
|
||||
- `--to N` — stop after phase N completes (halt instead of advancing to next phase).
|
||||
- `--only N` — execute only phase N (single-phase mode).
|
||||
- `--interactive` — run discuss inline with questions (not auto-answered), then dispatch plan→execute as background agents. Keeps the main context lean while preserving user input on decisions.
|
||||
- `--converge` — run each phase's planning step through `gsd-plan-review-convergence` instead of plain `gsd-plan-phase`. Requires `workflow.plan_review_convergence=true`.
|
||||
- `--cross-ai` — compatibility alias for `--converge`.
|
||||
|
||||
When `--converge` or `--cross-ai` is set, reviewer selector flags supported by `gsd-plan-review-convergence` may be passed through: `--codex`, `--gemini`, `--claude`, `--opencode`, `--ollama`, `--lm-studio`, `--llama-cpp`, `--all`, and `--max-cycles N`.
|
||||
|
||||
Project context, phase list, and state are resolved inside the workflow using init commands (`gsd-tools query init.milestone-op`, `gsd-tools query roadmap.analyze`). No upfront context loading needed.
|
||||
</context>
|
||||
|
||||
@@ -724,6 +724,9 @@ Run all remaining phases autonomously.
|
||||
| `--to N` | Stop after completing a specific phase number |
|
||||
| `--only N` | Restrict execution to phase N; lifecycle step is skipped |
|
||||
| `--interactive` | Lean context with user input |
|
||||
| `--converge` | Route each planning step through `/gsd-plan-review-convergence`; requires `workflow.plan_review_convergence=true` |
|
||||
| `--cross-ai` | Alias for `--converge` |
|
||||
| Reviewer flags | With `--converge`, pass through `--codex`, `--gemini`, `--claude`, `--opencode`, `--ollama`, `--lm-studio`, `--llama-cpp`, `--all`, and `--max-cycles N` |
|
||||
| `--text` | Replace `AskUserQuestion` prompts with plain numbered lists |
|
||||
|
||||
```bash
|
||||
@@ -732,6 +735,8 @@ Run all remaining phases autonomously.
|
||||
/gsd-autonomous --to 5 # Run up to and including phase 5
|
||||
/gsd-autonomous --from 3 --to 5 # Run phases 3 through 5
|
||||
/gsd-autonomous --only 4 # Run only phase 4
|
||||
/gsd-autonomous --only 4 --converge # Run one phase with plan convergence
|
||||
/gsd-autonomous --converge --all --max-cycles 5
|
||||
/gsd-autonomous --text # Run with text-mode prompts
|
||||
```
|
||||
|
||||
|
||||
@@ -54,6 +54,22 @@ If the phase is already complete, autonomous mode exits immediately with a messa
|
||||
|
||||
---
|
||||
|
||||
## Run with plan convergence
|
||||
|
||||
Use `--converge` when you want each phase to run the plan-review convergence loop before execution:
|
||||
|
||||
```bash
|
||||
gsd config-set workflow.plan_review_convergence true
|
||||
/gsd-autonomous --only 4 --converge
|
||||
/gsd-autonomous --from 3 --to 5 --converge --all --max-cycles 5
|
||||
```
|
||||
|
||||
`--cross-ai` is accepted as an alias for `--converge`. Reviewer flags supported by `/gsd-plan-review-convergence` pass through unchanged, including `--codex`, `--gemini`, `--claude`, `--opencode`, `--ollama`, `--lm-studio`, `--llama-cpp`, `--all`, and `--max-cycles N`.
|
||||
|
||||
If `workflow.plan_review_convergence` is not enabled, autonomous mode stops before planning and prints the enable command instead of silently falling back to regular planning.
|
||||
|
||||
---
|
||||
|
||||
## Run with interactive discuss
|
||||
|
||||
By default, autonomous mode answers discuss questions automatically using smart discuss (batch table proposals). If you want to answer design questions yourself while keeping plan and execute out of the main context:
|
||||
@@ -78,7 +94,7 @@ To run autonomously on a runtime that does not support the `AskUserQuestion` too
|
||||
/gsd-autonomous --from 3 --text
|
||||
```
|
||||
|
||||
All interactive prompts become plain numbered lists; type the choice number to respond.
|
||||
All interactive prompts become plain numbered lists; type the choice number to respond. When combined with `--converge`, `--text` is also forwarded to the convergence loop via `CONVERGENCE_ARGS` so reviewer prompts inside plan-review convergence use the same plain-text mode.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<purpose>
|
||||
|
||||
Drive milestone phases autonomously — all remaining phases, a range via `--from N`/`--to N`, or a single phase via `--only N`. For each incomplete phase: discuss → plan → execute using Skill() flat invocations. Pauses only for explicit user decisions (grey area acceptance, blockers, validation requests). Re-reads ROADMAP.md after each phase to catch dynamically inserted phases.
|
||||
Drive milestone phases autonomously — all remaining phases, a range via `--from N`/`--to N`, or a single phase via `--only N`. For each incomplete phase: discuss → plan → execute using Skill() flat invocations. When `--converge` or `--cross-ai` is set, route the planning step through plan-review convergence before execution. Pauses only for explicit user decisions (grey area acceptance, blockers, validation requests). Re-reads ROADMAP.md after each phase to catch dynamically inserted phases.
|
||||
|
||||
</purpose>
|
||||
|
||||
@@ -16,7 +16,7 @@ Read all files referenced by the invoking prompt's execution_context before star
|
||||
|
||||
## 1. Initialize
|
||||
|
||||
Parse `$ARGUMENTS` for `--from N`, `--to N`, `--only N`, and `--interactive` flags:
|
||||
Parse `$ARGUMENTS` for `--from N`, `--to N`, `--only N`, `--interactive`, `--converge`/`--cross-ai`, reviewer selector flags, and `--max-cycles N`:
|
||||
|
||||
```bash
|
||||
FROM_PHASE=""
|
||||
@@ -39,12 +39,32 @@ INTERACTIVE=""
|
||||
if echo "$ARGUMENTS" | grep -q '\-\-interactive'; then
|
||||
INTERACTIVE="true"
|
||||
fi
|
||||
|
||||
PLAN_STRATEGY="local"
|
||||
if echo "$ARGUMENTS" | grep -qE '(^|[[:space:]])\-\-(converge|cross-ai)([[:space:]]|$)'; then
|
||||
PLAN_STRATEGY="converge"
|
||||
fi
|
||||
|
||||
CONVERGENCE_ARGS=""
|
||||
for REVIEW_FLAG in --codex --gemini --claude --opencode --ollama --lm-studio --llama-cpp --all --text; do
|
||||
if echo "$ARGUMENTS" | grep -qE "(^|[[:space:]])${REVIEW_FLAG}([[:space:]]|$)"; then
|
||||
CONVERGENCE_ARGS="${CONVERGENCE_ARGS} ${REVIEW_FLAG}"
|
||||
fi
|
||||
done
|
||||
|
||||
MAX_CYCLES_ARG=""
|
||||
if echo "$ARGUMENTS" | grep -qE '\-\-max-cycles\s+[0-9]+'; then
|
||||
MAX_CYCLES_ARG=$(echo "$ARGUMENTS" | grep -oE '\-\-max-cycles\s+[0-9]+' | awk '{print $2}')
|
||||
CONVERGENCE_ARGS="${CONVERGENCE_ARGS} --max-cycles ${MAX_CYCLES_ARG}"
|
||||
fi
|
||||
```
|
||||
|
||||
When `--only` is set, also set `FROM_PHASE` to the same value so existing filter logic applies.
|
||||
|
||||
When `--interactive` is set, discuss runs inline with questions (not auto-answered). On runtimes where a backgrounded agent can spawn subagents, plan and execute are dispatched as background agents — keeping the main context lean (only discuss conversations accumulate) and enabling overlap. On Claude Code, where a backgrounded agent cannot nest subagents, plan and execute run inline to preserve worktree isolation and independent verification, so they run sequentially and their work accumulates in the main context. Either way, user input is preserved on all design decisions.
|
||||
|
||||
When `PLAN_STRATEGY=converge`, the planning step MUST invoke the plan-review convergence workflow instead of `gsd-plan-phase`. `--cross-ai` is an alias for `--converge`. Forward `CONVERGENCE_ARGS` exactly as parsed so reviewer flags and `--max-cycles N` retain the same meaning as they have on `/gsd:plan-review-convergence`.
|
||||
|
||||
Bootstrap via milestone-level init:
|
||||
|
||||
```bash
|
||||
@@ -53,6 +73,25 @@ INIT=$(gsd_run query init.milestone-op)
|
||||
if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
|
||||
```
|
||||
|
||||
If `PLAN_STRATEGY` is `converge`, fail fast unless the existing convergence feature gate is enabled:
|
||||
|
||||
```bash
|
||||
if [ "$PLAN_STRATEGY" = "converge" ]; then
|
||||
CONVERGENCE_ENABLED=$(gsd_run query config-get workflow.plan_review_convergence 2>/dev/null || echo "false")
|
||||
if [ "$CONVERGENCE_ENABLED" != "true" ]; then
|
||||
printf '%s\n' \
|
||||
'gsd-autonomous --converge is disabled (workflow.plan_review_convergence=false).' \
|
||||
'' \
|
||||
'Enable plan convergence with:' \
|
||||
'' \
|
||||
' gsd config-set workflow.plan_review_convergence true' \
|
||||
'' \
|
||||
'Then re-run the autonomous command with --converge.'
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
```
|
||||
|
||||
Parse JSON for: `milestone_version`, `milestone_name`, `phase_count`, `completed_phases`, `roadmap_exists`, `state_exists`, `commit_docs`.
|
||||
|
||||
**If `roadmap_exists` is false:** Error — "No ROADMAP.md found. Run `/gsd:new-milestone` first."
|
||||
@@ -73,6 +112,7 @@ If `ONLY_PHASE` is set, display: `Single phase mode: Phase ${ONLY_PHASE}`
|
||||
Else if `FROM_PHASE` is set, display: `Starting from phase ${FROM_PHASE}`
|
||||
If `TO_PHASE` is set, display: `Stopping after phase ${TO_PHASE}`
|
||||
If `INTERACTIVE` is set, display: `Mode: Interactive (discuss inline, plan+execute in background)`
|
||||
If `PLAN_STRATEGY` is `converge`, display: `Planning: Plan-review convergence enabled`
|
||||
|
||||
</step>
|
||||
|
||||
@@ -330,25 +370,51 @@ RUNTIME=$(gsd_run query config-get runtime --default claude 2>/dev/null || echo
|
||||
|
||||
- **On Claude Code (`RUNTIME` is `claude`):** Run plan **inline** (do NOT background) so the plan-checker runs. The next phase's discuss does not overlap planning here — correctness over overlap.
|
||||
|
||||
```
|
||||
Skill(skill="gsd-plan-phase", args="${PHASE_NUM}")
|
||||
```
|
||||
- If `PLAN_STRATEGY=converge`:
|
||||
|
||||
```
|
||||
Skill(skill="gsd-plan-review-convergence", args="${PHASE_NUM} ${CONVERGENCE_ARGS}")
|
||||
```
|
||||
|
||||
- Otherwise (local planning):
|
||||
|
||||
```
|
||||
Skill(skill="gsd-plan-phase", args="${PHASE_NUM}")
|
||||
```
|
||||
|
||||
- **On other runtimes:** Dispatch plan as a background agent to keep the main context lean. While plan runs, the workflow can immediately start discussing the next phase (see step 4).
|
||||
|
||||
Print: `◆ Spawning background planner for phase ${PHASE_NUM}... (runs in a subagent — no output until it returns, ~1–5 min; expected, not a freeze)`
|
||||
- If `PLAN_STRATEGY=converge`, print: `◆ Spawning background plan-convergence loop for phase ${PHASE_NUM}... (runs in a subagent — no output until it returns, ~1–5 min; expected, not a freeze)`
|
||||
|
||||
```
|
||||
Agent(
|
||||
description="Plan phase ${PHASE_NUM}: ${PHASE_NAME}",
|
||||
run_in_background=true,
|
||||
prompt="Run plan-phase for phase ${PHASE_NUM}: Skill(skill=\"gsd-plan-phase\", args=\"${PHASE_NUM}\")"
|
||||
)
|
||||
```
|
||||
```
|
||||
Agent(
|
||||
description="Plan convergence phase ${PHASE_NUM}: ${PHASE_NAME}",
|
||||
run_in_background=true,
|
||||
prompt="Run plan convergence for phase ${PHASE_NUM}: Skill(skill=\"gsd-plan-review-convergence\", args=\"${PHASE_NUM} ${CONVERGENCE_ARGS}\")"
|
||||
)
|
||||
```
|
||||
|
||||
- Otherwise, print: `◆ Spawning background planner for phase ${PHASE_NUM}... (runs in a subagent — no output until it returns, ~1–5 min; expected, not a freeze)`
|
||||
|
||||
```
|
||||
Agent(
|
||||
description="Plan phase ${PHASE_NUM}: ${PHASE_NAME}",
|
||||
run_in_background=true,
|
||||
prompt="Run plan-phase for phase ${PHASE_NUM}: Skill(skill=\"gsd-plan-phase\", args=\"${PHASE_NUM}\")"
|
||||
)
|
||||
```
|
||||
|
||||
Store the agent task_id. After discuss for the next phase completes (or if no next phase), wait for the plan agent to finish before proceeding to execute.
|
||||
|
||||
**If `INTERACTIVE` is NOT set (default):** Run plan inline as before.
|
||||
**If `INTERACTIVE` is NOT set (default):** Run plan inline.
|
||||
|
||||
If `PLAN_STRATEGY=converge`, run the convergence loop:
|
||||
|
||||
```
|
||||
Skill(skill="gsd-plan-review-convergence", args="${PHASE_NUM} ${CONVERGENCE_ARGS}")
|
||||
```
|
||||
|
||||
If `PLAN_STRATEGY=local`, run the regular planner:
|
||||
|
||||
```
|
||||
Skill(skill="gsd-plan-phase", args="${PHASE_NUM}")
|
||||
@@ -818,4 +884,9 @@ When any phase operation fails or a blocker is detected, present 3 options via A
|
||||
- [ ] `--interactive` main context only accumulates discuss conversations on runtimes with background dispatch (on Claude Code, inline plan/execute also accumulate)
|
||||
- [ ] `--interactive` waits for background agents before post-execution routing
|
||||
- [ ] `--interactive` compatible with `--only`, `--from`, and `--to` flags
|
||||
- [ ] `--converge` routes planning through `gsd-plan-review-convergence`
|
||||
- [ ] `--cross-ai` is accepted as an alias for `--converge`
|
||||
- [ ] `--converge` fails fast with enable instructions when `workflow.plan_review_convergence=false`
|
||||
- [ ] `--converge` forwards reviewer selector flags and `--max-cycles N`
|
||||
- [ ] Default autonomous planning remains `gsd-plan-phase` when convergence is not requested
|
||||
</success_criteria>
|
||||
|
||||
@@ -583,7 +583,7 @@ The commands above cover the most common day-to-day flows. Every command listed
|
||||
- **`/gsd:mvp-phase <phase-number>`** — Plan a phase as a vertical MVP slice (user story + SPIDR splitting) before handing off to plan-phase. Same end-state as `/gsd:plan-phase --mvp`, with a guided MVP-shaping intro.
|
||||
- **`/gsd:ultraplan-phase [phase]`** — [BETA] Offload plan phase to Claude Code's ultraplan cloud; review in browser and import back.
|
||||
- **`/gsd:plan-review-convergence <phase> [--codex] [--gemini] [--claude] [--opencode] [--ollama] [--lm-studio] [--llama-cpp] [--all] [--text] [--ws <name>] [--max-cycles N]`** — Cross-AI plan convergence loop — replan with review feedback until no HIGH concerns remain. Supports both cloud reviewers (Codex/Gemini/Claude/OpenCode) and local model runtimes (Ollama, LM Studio, llama.cpp).
|
||||
- **`/gsd:autonomous [--from N] [--to N] [--only N] [--interactive]`** — Run all remaining phases autonomously: discuss → plan → execute per phase.
|
||||
- **`/gsd:autonomous [--from N] [--to N] [--only N] [--interactive] [--converge]`** — Run all remaining phases autonomously: discuss → plan → execute per phase. `--converge` routes planning through plan-review convergence; `--cross-ai` is an alias.
|
||||
|
||||
### Quality, Review & Verification
|
||||
|
||||
|
||||
111
tests/autonomous-converge.test.cjs
Normal file
111
tests/autonomous-converge.test.cjs
Normal file
@@ -0,0 +1,111 @@
|
||||
// allow-test-rule: source-text-is-the-product
|
||||
// The autonomous command and workflow markdown are runtime-loaded contracts.
|
||||
// Checking their text verifies the shipped slash-command behavior.
|
||||
|
||||
'use strict';
|
||||
|
||||
const { describe, test } = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
|
||||
const REPO_ROOT = path.join(__dirname, '..');
|
||||
const COMMAND_PATH = path.join(REPO_ROOT, 'commands', 'gsd', 'autonomous.md');
|
||||
const WORKFLOW_PATH = path.join(REPO_ROOT, 'gsd-core', 'workflows', 'autonomous.md');
|
||||
const COMMANDS_DOC_PATH = path.join(REPO_ROOT, 'docs', 'COMMANDS.md');
|
||||
const HOW_TO_PATH = path.join(REPO_ROOT, 'docs', 'how-to', 'run-phases-autonomously.md');
|
||||
|
||||
function read(filePath) {
|
||||
return fs.readFileSync(filePath, 'utf8');
|
||||
}
|
||||
|
||||
describe('autonomous --converge flag (#711)', () => {
|
||||
test('command advertises --converge and documents --cross-ai as alias', () => {
|
||||
const command = read(COMMAND_PATH);
|
||||
|
||||
assert.match(
|
||||
command,
|
||||
/^argument-hint:.*--converge/m,
|
||||
'autonomous command should advertise --converge in argument-hint',
|
||||
);
|
||||
assert.match(command, /--cross-ai/, 'autonomous command should document --cross-ai alias');
|
||||
assert.match(
|
||||
command,
|
||||
/workflow\.plan_review_convergence=true/,
|
||||
'autonomous command should mention the existing convergence feature gate',
|
||||
);
|
||||
});
|
||||
|
||||
test('workflow parses converge aliases into a plan strategy', () => {
|
||||
const workflow = read(WORKFLOW_PATH);
|
||||
|
||||
assert.match(workflow, /PLAN_STRATEGY="local"/, 'workflow should default to local planning');
|
||||
assert.match(workflow, /PLAN_STRATEGY="converge"/, 'workflow should opt into converge planning');
|
||||
assert.match(workflow, /converge\|cross-ai/, 'workflow should accept --converge and --cross-ai');
|
||||
});
|
||||
|
||||
test('workflow fails fast when convergence is requested but disabled', () => {
|
||||
const workflow = read(WORKFLOW_PATH);
|
||||
|
||||
assert.match(
|
||||
workflow,
|
||||
/config-get workflow\.plan_review_convergence/,
|
||||
'workflow should check workflow.plan_review_convergence before planning',
|
||||
);
|
||||
assert.match(
|
||||
workflow,
|
||||
/gsd config-set workflow\.plan_review_convergence true/,
|
||||
'workflow should print the enable command instead of silently downgrading',
|
||||
);
|
||||
});
|
||||
|
||||
test('workflow routes planning through plan-review-convergence when enabled', () => {
|
||||
const workflow = read(WORKFLOW_PATH);
|
||||
|
||||
assert.match(
|
||||
workflow,
|
||||
/Skill\(skill="gsd-plan-review-convergence", args="\$\{PHASE_NUM\} \$\{CONVERGENCE_ARGS\}"\)/,
|
||||
'non-interactive converge mode should call gsd-plan-review-convergence',
|
||||
);
|
||||
assert.match(
|
||||
workflow,
|
||||
/Run plan convergence for phase \$\{PHASE_NUM\}: Skill\(skill=\\"gsd-plan-review-convergence\\"/,
|
||||
'interactive converge mode should dispatch plan convergence in the background agent',
|
||||
);
|
||||
assert.match(
|
||||
workflow,
|
||||
/Skill\(skill="gsd-plan-phase", args="\$\{PHASE_NUM\}"\)/,
|
||||
'local planning path should remain available for default autonomous runs',
|
||||
);
|
||||
});
|
||||
|
||||
test('workflow forwards reviewer flags and max cycles to convergence', () => {
|
||||
const workflow = read(WORKFLOW_PATH);
|
||||
const reviewerFlags = [
|
||||
'--codex',
|
||||
'--gemini',
|
||||
'--claude',
|
||||
'--opencode',
|
||||
'--ollama',
|
||||
'--lm-studio',
|
||||
'--llama-cpp',
|
||||
'--all',
|
||||
'--text',
|
||||
];
|
||||
|
||||
assert.match(workflow, /CONVERGENCE_ARGS/, 'workflow should build convergence pass-through args');
|
||||
for (const flag of reviewerFlags) {
|
||||
assert.ok(workflow.includes(flag), `workflow should pass through ${flag}`);
|
||||
}
|
||||
assert.match(workflow, /--max-cycles/, 'workflow should pass through --max-cycles N');
|
||||
});
|
||||
|
||||
test('docs show autonomous convergence usage', () => {
|
||||
const commandsDoc = read(COMMANDS_DOC_PATH);
|
||||
const howTo = read(HOW_TO_PATH);
|
||||
|
||||
assert.match(commandsDoc, /--converge/, 'COMMANDS.md should document --converge');
|
||||
assert.match(commandsDoc, /--cross-ai/, 'COMMANDS.md should document --cross-ai alias');
|
||||
assert.match(howTo, /\/gsd-autonomous --only 4 --converge/, 'how-to should show single-phase converge usage');
|
||||
});
|
||||
});
|
||||
@@ -26,8 +26,10 @@ const PROJECT_ROOT = path.join(__dirname, '..');
|
||||
|
||||
// ─── Size threshold ──────────────────────────────────────────────────────────
|
||||
|
||||
// 38K chars ≈ 9,500 tokens — stays below 10K with margin
|
||||
const AUTONOMOUS_SIZE_LIMIT = 38 * 1024;
|
||||
// 40K chars ≈ 10,000 tokens — stays at the 10K ceiling; raised from 38K after
|
||||
// the #729+#853 merge added runtime-gated converge routing to the interactive
|
||||
// planning arm (both Claude-inline and other-runtime-background), adding ~1.2K chars.
|
||||
const AUTONOMOUS_SIZE_LIMIT = 40 * 1024;
|
||||
|
||||
// ─── File paths ──────────────────────────────────────────────────────────────
|
||||
|
||||
@@ -41,7 +43,7 @@ describe('autonomous.md size constraints (#2196)', () => {
|
||||
assert.ok(fs.existsSync(AUTONOMOUS_PATH), `Missing: ${AUTONOMOUS_PATH}`);
|
||||
});
|
||||
|
||||
test('autonomous.md is under 38K chars (below Claude Code 10K-token Read limit)', () => {
|
||||
test('autonomous.md is under 40K chars (at or below Claude Code 10K-token Read limit)', () => {
|
||||
const raw = fs.readFileSync(AUTONOMOUS_PATH, 'utf-8');
|
||||
const content = raw.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
|
||||
assert.ok(
|
||||
|
||||
@@ -770,7 +770,7 @@ describe('installRuntimeArtifacts (copilot integration)', () => {
|
||||
'description preserved (round-trips through #2876 yamlQuote)',
|
||||
);
|
||||
// argument-hint round-trips
|
||||
assert.equal(fm['argument-hint'], '[--from N] [--to N] [--only N] [--interactive]', 'argument-hint round-trips');
|
||||
assert.equal(fm['argument-hint'], '[--from N] [--to N] [--only N] [--interactive] [--converge]', 'argument-hint round-trips');
|
||||
// allowed-tools comma-separated
|
||||
assert.ok(skillContent.includes('allowed-tools: Read, Write, Bash, Glob, Grep, AskUserQuestion, Agent'),
|
||||
'allowed-tools is comma-separated');
|
||||
|
||||
Reference in New Issue
Block a user