savant-code 0.0.17 → 0.0.19

package/dev/test-prompts/archive/fid-007-ability-confirmation.md

@@ -0,0 +1,248 @@
+# Savant-Code — FID-2026-0718-007 Ability Confirmation Test
+
+**Purpose:** Confirm that the Scout file-finding rewrite, MCP proxy timeout, and agent roster alignment changes work correctly in a live CLI session.
+
+**Mode:** Interactive live execution. You MUST call every test listed below. Report PASS/FAIL for each with evidence. Do not skip any item.
+
+**Environment:** The test is running inside the Savant CLI. ECHO Protocol is active. All changes from FID-006 (agent roster) and FID-007 (Scout + MCP timeout) are deployed.
+
+---
+
+## SECTION A: SCOUT FILE-FINDING (FID-007 Fix 1)
+
+These tests verify that Scout uses `glob` + `list_directory` directly instead of delegating to Detective.
+
+### A.1 Scout Basic File Finding
+
+| # | Test | Expected |
+|---|------|----------|
+| 1 | Spawn `scout` with prompt: "Find files related to tool gating" | Returns file paths containing "tool" or "gating" in their names (e.g., `tool-executor.ts`, `gating-rules.ts`). Should NOT return files that merely contain the word "gating" in their content. |
+| 2 | Spawn `scout` with prompt: "Find agent definition files" | Returns paths like `agents/*/` files, `agent-definition.ts`, etc. |
+| 3 | Spawn `scout` with prompt: "Find MCP client files" | Returns `common/src/mcp/client.ts`, `packages/agent-runtime/src/mcp.ts`, `common/src/types/mcp.ts`, etc. |
+| 4 | Spawn `scout` with prompt: "Find configuration files" | Returns `package.json`, `tsconfig.json`, `protocol.config.yaml`, `.prettierrc`, etc. |
+
+### A.2 Scout Multi-Keyword Extraction
+
+| # | Test | Expected |
+|---|------|----------|
+| 5 | Spawn `scout` with prompt: "find auth service files" | Should extract keywords `auth`, `service`. Glob for `**/*auth*` and `**/*service*`. Returns files matching either pattern. |
+| 6 | Spawn `scout` with prompt: "show me the database schema files" | Should extract keywords `database`, `schema`. Stop words (`show`, `me`, `the`, `files`) stripped. |
+| 7 | Spawn `scout` with prompt: "I need to look at the error handling code" | Should extract keywords `error`, `handling`, `code`. Stop words (`I`, `need`, `to`, `look`, `at`, `the`) stripped. |
+
+### A.3 Scout Edge Cases
+
+| # | Test | Expected |
+|---|------|----------|
+| 8 | Spawn `scout` with prompt: "files" (single stop word) | Should fall back gracefully — either glob for `**/*file*` or report "no specific keywords found". Should NOT crash. |
+| 9 | Spawn `scout` with prompt: "Find [test] files with * special chars" | Should strip `[`, `]`, `*` from keywords. Extracts `test`, `files`, `special`, `chars`. Should NOT produce broken glob patterns. |
+| 10 | Spawn `scout` with empty prompt (no prompt) | Should handle gracefully — either glob for `*` or report no search terms. Should NOT crash. |
+
+### A.4 Scout Does NOT Delegate to Detective
+
+| # | Test | Expected |
+|---|------|----------|
+| 11 | Spawn `scout` and observe the tool calls made | Should see `glob` tool calls, NOT `spawn_agents` with `agent_type: 'detective'`. Scout should never spawn Detective. |
+| 12 | Verify Scout's spawnableAgents is empty | Scout should have no spawnable agents. It uses its own tools directly. |
+
+### A.5 Scout Tool Set
+
+| # | Test | Expected |
+|---|------|----------|
+| 13 | Verify Scout has `glob` tool | Scout can call glob directly |
+| 14 | Verify Scout has `list_directory` tool | Scout can call list_directory directly |
+| 15 | Verify Scout has `read_files` tool | Scout can read files to examine results |
+| 16 | Verify Scout has `read_subtree` tool | Scout can explore directory subtrees |
+| 17 | Verify Scout does NOT have `write_file` | Scout is read-only — cannot write files |
+| 18 | Verify Scout does NOT have `str_replace` | Scout is read-only — cannot edit files |
+
+---
+
+## SECTION B: MCP PROXY TIMEOUT (FID-007 Fix 2)
+
+These tests verify that MCP server connections and tool calls have proper timeout handling.
+
+### B.1 Timeout Infrastructure
+
+| # | Test | Expected |
+|---|------|----------|
+| 19 | Read `common/src/types/mcp.ts` and verify `timeout` field exists | Both `mcpConfigStdioSchema` and `mcpConfigRemoteSchema` have optional `timeout: z.number().positive().optional()` |
+| 20 | Read `common/src/mcp/client.ts` and verify `withTimeout` function exists | Function uses `Promise.race` + `setTimeout` with `.finally(() => clearTimeout(timer))` |
+| 21 | Read `common/src/mcp/client.ts` and verify `MAX_TIMEOUT_MS` constant | Value is `300_000` (5 minutes) |
+| 22 | Read `common/src/mcp/client.ts` and verify `DEFAULT_CONNECT_TIMEOUT_MS` | Value is `30_000` (30 seconds) |
+| 23 | Read `common/src/mcp/client.ts` and verify `DEFAULT_TOOL_TIMEOUT_MS` | Value is `60_000` (60 seconds) |
+
+### B.2 Connect Timeout
+
+| # | Test | Expected |
+|---|------|----------|
+| 24 | Read `getMCPClient()` and verify `client.connect(transport)` is wrapped with `withTimeout` | `await withTimeout(client.connect(transport), connectTimeoutMs, ...)` present |
+| 25 | Read `getMCPClient()` and verify `transport.close()` is called in catch block | Prevents orphaned child processes on timeout |
+| 26 | Read `getMCPClient()` and verify timeout is clamped via `clampTimeout()` | User-configured timeout clamped to MAX_TIMEOUT_MS |
+
+### B.3 Tool Call Timeout
+
+| # | Test | Expected |
+|---|------|----------|
+| 27 | Read `callMCPTool()` and verify `client.callTool(...args)` is wrapped with `withTimeout` | `await withTimeout(client.callTool(...args), timeoutMs, ...)` present |
+| 28 | Read `callMCPTool()` and verify timeout value comes from `clientTimeouts` map | `clientTimeouts[clientId] ?? DEFAULT_TOOL_TIMEOUT_MS` |
+
+### B.4 List Tools Timeout
+
+| # | Test | Expected |
+|---|------|----------|
+| 29 | Read `listMCPTools()` and verify `client.listTools(...)` is wrapped with `withTimeout` | `withTimeout(client.listTools(...), timeoutMs, ...)` present |
+| 30 | Read `listMCPTools()` and verify cache clears on rejection | `.catch((error) => { delete listToolsCache[clientId]; throw error })` present |
+
+### B.5 Client Timeout Map
+
+| # | Test | Expected |
+|---|------|----------|
+| 31 | Read `clientTimeouts` declaration | `const clientTimeouts: Record<string, number> = {}` present |
+| 32 | Verify `clientTimeouts[key]` is set on successful connect | Set after `runningClients[key] = client` |
+
+### B.6 Timeout Clamp Function
+
+| # | Test | Expected |
+|---|------|----------|
+| 33 | Read `clampTimeout()` function | Returns `Math.min(Math.max(Math.round(value), 1), MAX_TIMEOUT_MS)` |
+| 34 | Verify `clampTimeout(undefined, 30000)` returns 30000 | Default value used when input is undefined |
+| 35 | Verify `clampTimeout(999999999, 30000)` returns 300000 | Clamped to MAX_TIMEOUT_MS |
+
+---
+
+## SECTION C: AGENT ROSTER ALIGNMENT (FID-006)
+
+These tests verify the 9-agent Savant architecture is correctly deployed.
+
+### C.1 Agent Spawnability
+
+| # | Test | Expected |
+|---|------|----------|
+| 36 | Spawn `detective` with a code search task | Returns evidence with file paths. Detective has `code_search`, `list_directory`, `glob`, `read_files`, `read_subtree`, `set_output`. |
+| 37 | Spawn `thinker` with a reasoning problem | Returns sequential thinking output. Thinker has `sequentialthinking` tool. |
+| 38 | Spawn `verifier` with a read-only review task | Returns review. Verifier has NO tools (reads only via message history). |
+| 39 | Spawn `recorder` with a FID listing task | Returns FID data. Recorder has `code_search`, `read_files`, `write_file`, `set_output`, `transition_phase`. |
+| 40 | Spawn `scribe` with a summary task | Returns summary. Scribe has `read_files`, `write_file`, `glob`, `code_search`, `set_output`. |
+| 41 | Spawn `forge` with a write task (during GREEN phase) | Writes code. Forge has `write_file`, `str_replace`, `set_output`. |
+| 42 | Spawn `scout` with a file-finding task | Returns file paths via glob. Scout has `glob`, `list_directory`, `read_files`, `read_subtree`, `set_output`. |
+| 43 | Spawn `researcher-web` with a web search task | Returns search results OR network error. |
+| 44 | Spawn `researcher-docs` with a doc lookup task | Returns docs OR backend error. |
+
+### C.2 Orchestrator Tool Restrictions
+
+| # | Test | Expected |
+|---|------|----------|
+| 45 | Verify Orchestrator does NOT have `write_file` | Not in toolNames |
+| 46 | Verify Orchestrator does NOT have `str_replace` | Not in toolNames |
+| 47 | Verify Orchestrator does NOT have `apply_patch` | Not in toolNames |
+| 48 | Verify Orchestrator DOES have `spawn_agents` | In toolNames |
+| 49 | Verify Orchestrator DOES have `transition_phase` | In toolNames |
+| 50 | Verify Orchestrator DOES have `read_files` | In toolNames |
+| 51 | Verify Orchestrator DOES have `set_output` | In toolNames |
+
+### C.3 Separation of Duties
+
+| # | Test | Expected |
+|---|------|----------|
+| 52 | Verify Detective does NOT have `write_file` | Read-only agent |
+| 53 | Verify Verifier does NOT have any tools | Pure reader |
+| 54 | Verify Forge DOES have `write_file` and `str_replace` | Code writer |
+| 55 | Verify Scout does NOT have `write_file` | Read-only agent |
+| 56 | Verify Thinker does NOT have `write_file` | Reasoning only |
+
+### C.4 FSM Phase Inheritance (FID-004)
+
+| # | Test | Expected |
+|---|------|----------|
+| 57 | Transition to GREEN phase | Phase is "green" |
+| 58 | Spawn a subagent in GREEN phase | Subagent's `fsmPhase` is "green" (inherited from parent) |
+| 59 | Verify subagent can use write tools in inherited GREEN phase | Write succeeds without "only available during GREEN phase" error |
+| 60 | Transition to AUDIT phase | Phase is "audit" |
+| 61 | Spawn a subagent in AUDIT phase | Subagent's `fsmPhase` is "audit" (inherited) |
+| 62 | Verify subagent can use bash in inherited AUDIT phase | Bash succeeds |
+
+---
+
+## SECTION D: INTEGRATION SMOKE TESTS
+
+End-to-end tests that exercise multiple changes together.
+
+### D.1 Scout Finds → Orchestrator Reads
+
+| # | Test | Expected |
+|---|------|----------|
+| 63 | Spawn Scout to find "MCP timeout files" | Returns `common/src/mcp/client.ts`, `common/src/types/mcp.ts`, etc. |
+| 64 | Use `read_files` on Scout's results | File contents returned successfully |
+| 65 | Verify the returned files contain `withTimeout` | The MCP timeout changes are present in the files |
+
+### D.2 Full Agent Pipeline
+
+| # | Test | Expected |
+|---|------|----------|
+| 66 | Spawn Scout to find "FSM enforcement files" | Returns relevant paths |
+| 67 | Spawn Detective on those paths to search for `fsmPhase` | Returns code evidence |
+| 68 | Spawn Thinker to analyze the evidence | Returns analysis |
+| 69 | Spawn Verifier to review the analysis | Returns review (read-only) |
+| 70 | All 4 agents complete without error | Pipeline works end-to-end |
+
+### D.3 MCP Config Schema
+
+| # | Test | Expected |
+|---|------|----------|
+| 71 | Read `common/src/types/mcp.ts` | Verify `timeout` field present in both schemas |
+| 72 | Verify `z.strictObject` still works with optional `timeout` | Existing configs without timeout parse correctly |
+| 73 | Verify a config with `timeout: 5000` parses correctly | Positive number accepted |
+
+---
+
+## REPORTING FORMAT
+
+For each test item, report:
+
+```
+[T] SECTION — PASS/FAIL — Evidence
+```
+
+Where:
+- `T` = test number (001-073)
+- `PASS` = behavior matches expected
+- `FAIL` = behavior differs from expected (capture exact error)
+- `Evidence` = first 150 chars of response or exact error message
+
+### Summary Table
+
+| Section | Total | Pass | Fail | Skip |
+|---------|-------|------|------|------|
+| A: Scout File-Finding | 18 | | | |
+| B: MCP Proxy Timeout | 17 | | | |
+| C: Agent Roster Alignment | 27 | | | |
+| D: Integration Smoke Tests | 11 | | | |
+| **TOTAL** | **73** | | | |
+
+---
+
+## CRITICAL RULES
+
+1. **Do not skip any test.** Every item must be attempted.
+2. **Capture exact errors.** Do not paraphrase error messages.
+3. **Test Scout's glob behavior explicitly.** Verify it searches file NAMES, not contents.
+4. **Test timeout infrastructure exists.** Read the source files and verify the code is present.
+5. **Test agent tool isolation.** Verify each agent has exactly the tools specified.
+6. **Test FSM inheritance.** Verify subagents inherit parent phase.
+7. **Clean up after yourself.** Delete any test files created.
+8. **Report honestly.** A PASS with a concern is different from a FAIL.
+
+---
+
+## EXPECTED OUTCOME
+
+If all changes from FID-006 and FID-007 are correctly deployed:
+- Scout uses glob directly (no Detective delegation)
+- MCP client has timeout protection on connect, callTool, and listTools
+- All 9 Savant agents are spawnable with correct tool sets
+- Orchestrator has no write tools (strict separation of duties)
+- Subagents inherit FSM phase from parent
+
+Any FAIL in Sections A or B indicates the FID changes were not properly deployed.
+Any FAIL in Section C indicates the agent roster alignment has regressed.
+Any FAIL in Section D indicates integration issues between components.

package/dev/test-prompts/archive/fid-2026-0801-006-thinker-tool-call-boundary.md

@@ -0,0 +1,86 @@
+# FID-2026-0801-006 — Thinker Tool-Call Boundary Regression Test
+
+**Purpose:** Manually verify that Savant-Code executes a real Thinker spawn and does not display legacy XML-shaped tool calls as ordinary assistant text.
+
+**Run mode:** Load Savant-Code normally and paste the **Test Prompt** below as a single user message. Do not run this through a unit-test harness or tmux. Observe the live transcript and tool/agent events.
+
+**Scope:** This test covers the Thinker spawn and tool-call stream boundary. It does not test Markdown visual styling, reasoning visibility, or general response quality.
+
+---
+
+## Test Prompt
+
+```text
+This is a focused behavioral regression test for the Thinker tool-call boundary.
+
+Do not answer the question directly. You must use the `think_deeply` tool to spawn the Thinker agent and ask it this exact narrow question:
+
+“What are exactly three properties of a safe AI-agent tool-call parser? Explain each property in one sentence.”
+
+The Thinker must reason using its actual `sequentialthinking` tool. Do not simulate the Thinker, do not summarize an answer before the child runs, and do not write or modify any files.
+
+After the Thinker child returns, provide a concise test report with these fields:
+
+- THINKER_SPAWNED: PASS or FAIL — based only on a visible structured child-agent start/activity event, not on assistant text claiming a child ran. If no structured event is visible, report INCONCLUSIVE.
+- SEQUENTIALTHINKING_EXECUTED: PASS or FAIL — based only on a visible structured `sequentialthinking` tool-call/result event inside the Thinker child, not on narrated text or XML-looking prose. If no structured event is visible, report INCONCLUSIVE.
+- CANONICAL_TOOL_CALL_HANDLED: PASS or FAIL — the tool call is handled by the runtime and is not displayed as raw XML markup.
+- RAW_LEGACY_XML_VISIBLE: YES or NO — check specifically for `<tool_call>`, `<function=sequentialthinking>`, `<parameter=`, or `</tool_call>` appearing as ordinary assistant text.
+- UNAVAILABLE_TOOL_CASCADE: YES or NO — check for repeated errors such as “Tool X is not currently available” caused by the Thinker attempting parent-only tools.
+- THINKER_TOOL_SCOPE: PASS or FAIL — the Thinker uses its permitted `sequentialthinking` capability and does not attempt `spawn_agents`, `write_file`, `str_replace`, `skill`, `suggest_followups`, or other parent-only tools.
+- CHILD_RESULT: PASS or FAIL — the Thinker returns exactly three numbered parser properties (`1.`, `2.`, `3.`), with exactly one sentence explaining each and no fourth property or extra property item.
+- FID_2026_0801_006_BEHAVIORAL_RESULT: PASS or FAIL — PASS only if all required conditions above pass.
+
+Important: Do not claim PASS merely because the transcript contains XML-looking text. Raw `<tool_call>` / `<function=...>` text is evidence of failure, not evidence that the Thinker or `sequentialthinking` executed.
+```
+
+---
+
+## Pass Criteria
+
+Mark the test **PASS** only when all of the following are true:
+
+1. A visible structured Thinker child-start/activity event appears; assistant text claiming that a child ran does not count.
+2. A visible structured `sequentialthinking` tool-call and result event appears inside the Thinker child; narrated text or raw XML does not count.
+3. The parent/runtime handles the tool call through the supported protocol; no raw legacy XML envelope is rendered as assistant prose.
+4. No repeated unavailable-tool cascade appears.
+5. The Thinker does not attempt parent-only tools.
+6. The final child result contains exactly three numbered properties (`1.`, `2.`, `3.`), each explained in exactly one sentence, with no additional property item.
+
+## Failure Signatures
+
+Treat any of these as a failure:
+
+- The response contains literal `<tool_call>`, `<function=sequentialthinking>`, `<parameter=...>`, or `</tool_call>` markup as visible assistant text.
+- The parent says it used `think_deeply`, but no actual child-start event appears.
+- `sequentialthinking` appears only as narrated text or XML rather than an executed tool event/result.
+- The Thinker attempts `spawn_agents`, `write_file`, `str_replace`, `skill`, `suggest_followups`, or another tool outside its allowed scope.
+- Multiple “Tool X is not currently available” errors appear.
+- The parent answers the question without spawning the Thinker.
+- The child result is missing, duplicated, or does not contain exactly three properties.
+
+## Results Report
+
+Record the observed result below after running the prompt:
+
+```text
+Date:
+Model/provider:
+CLI version/commit:
+
+THINKER_SPAWNED:
+SEQUENTIALTHINKING_EXECUTED:
+CANONICAL_TOOL_CALL_HANDLED:
+RAW_LEGACY_XML_VISIBLE:
+UNAVAILABLE_TOOL_CASCADE:
+THINKER_TOOL_SCOPE:
+CHILD_RESULT:
+FID_2026_0801_006_BEHAVIORAL_RESULT:
+
+Evidence notes:
+- Child-start event:
+- sequentialthinking result:
+- Any raw markup or error text:
+- Final child answer:
+```
+
+**Evidence rule:** `THINKER_SPAWNED` and `SEQUENTIALTHINKING_EXECUTED` require visible structured runtime/tool events. If the UI does not expose enough information to distinguish those events from ordinary text, record the relevant field—and the overall test—as **INCONCLUSIVE**, not PASS.

package/dev/test-prompts/archive/fid-2026-0801-007-child-tool-set-fallback-cli.md

@@ -0,0 +1,101 @@
+# FID-2026-0801-007 — Child Tool-Set Fallback CLI Regression Test
+
+**Purpose:** Verify in the live Savant-Code CLI that a Thinker child receives its own `sequentialthinking` tool even when that tool is absent from the parent/orchestrator tool set.
+
+**Run mode:** Start Savant-Code normally and paste the **Test Prompt** below as one user message. Run it through the CLI you intend to release. Do not treat a unit-test result or assistant claim as live CLI evidence.
+
+**Scope:** This test covers Thinker spawning, child-tool provisioning, tool execution, parent-tool isolation, and the visible stream boundary. It does not test Markdown visual styling or general response quality.
+
+---
+
+## Test Prompt
+
+```text
+This is a focused live regression test for FID-2026-0801-007.
+
+Do not answer the question yourself and do not simulate any child-agent output.
+You MUST use the `think_deeply` capability to spawn a real Thinker child.
+
+Give the Thinker this exact task:
+
+“What are exactly three properties of a safe AI-agent tool-permission boundary? Return exactly three numbered items, `1.`, `2.`, and `3.`, with exactly one sentence explaining each item.”
+
+The Thinker MUST use its actual `sequentialthinking` tool before returning its answer. Ask it to make at least two sequential-thinking steps. Do not write, edit, delete, or create any files. Do not call `sequentialthinking` directly from the parent; it must execute inside the real Thinker child.
+
+After the Thinker returns, provide a concise regression report using exactly these fields:
+
+- THINKER_SPAWNED: PASS, FAIL, or INCONCLUSIVE — PASS requires a visible structured child-agent start/activity event; assistant text claiming that Thinker ran does not count.
+- THINKER_CHILD_TOOL_EXECUTED: PASS, FAIL, or INCONCLUSIVE — PASS requires a visible structured `sequentialthinking` tool-call and result event inside the Thinker child; narrated text, a tool name in prose, or XML-looking text does not count.
+- SEQUENTIALTHINKING_CALL_COUNT: a number if visible, otherwise UNKNOWN.
+- PROMPT_INHERITANCE_PRESERVED: INFORMATIONAL — mark UNKNOWN unless the CLI explicitly exposes the inherited system prompt or cache/context events; this field does not gate the overall result, because normal CLI sessions may hide this implementation detail.
+- PARENT_TOOL_LEAKAGE: YES or NO — mark YES if the Thinker attempts `spawn_agents`, `write_file`, `str_replace`, `skill`, `suggest_followups`, `think_deeply`, or another parent-only tool.
+- UNAVAILABLE_TOOL_ERROR: YES or NO — mark YES for any error such as “Tool `sequentialthinking` is not currently available” or repeated unavailable-tool errors during the Thinker run.
+- RAW_LEGACY_XML_VISIBLE: YES or NO — mark YES if ordinary assistant text visibly contains `<tool_call>`, `<function=sequentialthinking>`, `<parameter=`, or `</tool_call>`.
+- CHILD_RESULT: PASS, FAIL, or INCONCLUSIVE — PASS requires exactly three numbered items (`1.`, `2.`, `3.`), exactly one sentence per item, and no fourth property item.
+- FID_2026_0801_007_BEHAVIORAL_RESULT: PASS, FAIL, or INCONCLUSIVE.
+
+Do not claim PASS merely because the final answer sounds correct. PASS requires visible structured runtime evidence that the real Thinker child executed `sequentialthinking` successfully.
+```
+
+## Pass Criteria
+
+Mark `FID_2026_0801_007_BEHAVIORAL_RESULT: PASS` only when all of these are true:
+
+1. A visible structured Thinker child-start/activity event appears.
+2. A visible structured `sequentialthinking` call and result appear inside that child.
+3. The Thinker completes without a `sequentialthinking` unavailable-tool error.
+4. The Thinker does not attempt parent-only tools.
+5. No repeated unavailable-tool cascade appears.
+6. No raw legacy XML tool-call markup is rendered as ordinary assistant text.
+7. The child returns exactly three numbered properties, one sentence each.
+8. The CLI exposes enough structured evidence to distinguish execution from narration.
+9. `PROMPT_INHERITANCE_PRESERVED` is informational only and does not gate the result when system prompts or cache events are hidden.
+
+If the CLI does not expose child/tool events clearly enough to verify items 1–3, report the relevant fields and the overall result as **INCONCLUSIVE**, not PASS.
+
+## Failure Signatures
+
+Treat the run as **FAIL** if any of the following occurs:
+
+- The parent answers directly without a real Thinker child-start event.
+- The Thinker child starts but receives an unavailable-tool error for `sequentialthinking`.
+- The transcript shows repeated errors such as `Tool X is not currently available`.
+- The Thinker attempts `spawn_agents`, `write_file`, `str_replace`, `skill`, `suggest_followups`, `think_deeply`, or another parent-only tool.
+- `sequentialthinking` appears only as ordinary prose or legacy XML rather than a structured tool event/result.
+- Literal `<tool_call>`, `<function=sequentialthinking>`, `<parameter=...>`, or `</tool_call>` appears as ordinary assistant text.
+- The child result is missing, contains fewer or more than three properties, or has an extra numbered property.
+
+## Results Report
+
+Record the live result below after running the prompt:
+
+```text
+Date:
+Model/provider:
+CLI version/commit:
+Operating system:
+
+THINKER_SPAWNED:
+THINKER_CHILD_TOOL_EXECUTED:
+SEQUENTIALTHINKING_CALL_COUNT:
+PROMPT_INHERITANCE_PRESERVED: UNKNOWN (informational unless explicitly observable)
+PARENT_TOOL_LEAKAGE:
+UNAVAILABLE_TOOL_ERROR:
+RAW_LEGACY_XML_VISIBLE:
+CHILD_RESULT:
+FID_2026_0801_007_BEHAVIORAL_RESULT:
+
+Evidence notes:
+- Thinker child-start event:
+- First sequentialthinking call/result:
+- Second sequentialthinking call/result:
+- Any unavailable-tool error:
+- Any parent-only tool attempt:
+- Any raw legacy XML:
+- Final child answer:
+
+If the result is FAIL or INCONCLUSIVE, preserve the relevant transcript excerpt
+and explain which evidence was missing or which failure signature appeared.
+```
+
+**Evidence rule:** Structured child/tool events are required for PASS. Assistant claims, final answers, raw XML-shaped text, or a tool name mentioned in prose are not execution evidence.

package/dev/test-prompts/archive/fid-2026-0801-008-provider-tool-call-accumulation-cli.md

@@ -0,0 +1,111 @@
+# FID-2026-0801-008 — Provider Tool-Call Accumulation CLI Regression Test
+
+**Purpose:** Verify in the live Savant-Code CLI that a Thinker child's `sequentialthinking` tool calls now execute end-to-end with **complete, valid arguments**. FID-2026-0801-008 fixed the OpenAI-compatible provider streaming accumulation so a tool call no longer "completes" on a `{}` placeholder or truncated fragment and drops the real arguments. A passing run proves the streamed `thought`/`thoughtNumber`/`totalThoughts`/`nextThoughtNeeded` payload survives the provider and reaches the executor.
+
+**Run mode:** Start Savant-Code normally and paste the **Test Prompt** below as one user message. Run it through the CLI you intend to release. Do not treat a unit-test result or assistant claim as live CLI evidence.
+
+**Scope:** This test covers Thinker spawning, provider streaming accumulation, `sequentialthinking` argument integrity, tool execution, parent-tool isolation, and the visible stream boundary. It does not test Markdown visual styling or general response quality.
+
+---
+
+## Test Prompt
+
+```text
+This is a focused live regression test for FID-2026-0801-008.
+
+Do not answer the question yourself and do not simulate any child-agent output.
+You MUST use the `think_deeply` capability to spawn a real Thinker child.
+
+Give the Thinker this exact task:
+
+“What are exactly three properties of a safe AI-agent tool-permission boundary? Return exactly three numbered items, `1.`, `2.`, and `3.`, with exactly one sentence explaining each item.”
+
+The Thinker MUST use its actual `sequentialthinking` tool before returning its answer. Ask it to make at least two sequential-thinking steps with proper parameters (thought, thoughtNumber, totalThoughts, nextThoughtNeeded). Do not write, edit, delete, or create any files. Do not call `sequentialthinking` directly from the parent; it must execute inside the real Thinker child.
+
+After the Thinker returns, provide a concise regression report using exactly these fields:
+
+- THINKER_SPAWNED: PASS, FAIL, or INCONCLUSIVE — PASS requires a visible structured child-agent start/activity event; assistant text claiming that Thinker ran does not count.
+- THINKER_CHILD_TOOL_EXECUTED: PASS, FAIL, or INCONCLUSIVE — PASS requires a visible structured `sequentialthinking` tool-call AND a tool-result event inside the Thinker child; narrated text, a tool name in prose, or XML-looking text does not count.
+- SEQUENTIALTHINKING_CALL_COUNT: a number if visible, otherwise UNKNOWN.
+- INVALID_PARAMETERS_ERROR: YES or NO — mark YES if any error contains “Invalid parameters for sequentialthinking”.
+- EMPTY_ARGUMENTS_ERROR: YES or NO — mark YES if any error shows `received undefined` for `thought`, `thoughtNumber`, `totalThoughts`, or `nextThoughtNeeded` (the `{}` empty-arguments signature).
+- TRUNCATED_STRING_ERROR: YES or NO — mark YES if any error contains “Unterminated string”, “JSON Parse error”, or “expected the tool arguments to be an object, but received a string”.
+- TOOL_RESULT_RECEIVED: PASS, FAIL, or INCONCLUSIVE — PASS requires a visible structured `sequentialthinking` result event carrying the thought payload (e.g. a thought number/content echoed back), proving the full arguments object was received, not just that a call was attempted.
+- PARENT_TOOL_LEAKAGE: YES or NO — mark YES if the Thinker attempts `spawn_agents`, `write_file`, `str_replace`, `skill`, `suggest_followups`, `think_deeply`, or another parent-only tool.
+- UNAVAILABLE_TOOL_ERROR: YES or NO — mark YES for any error such as “Tool `sequentialthinking` is not currently available” or repeated unavailable-tool errors during the Thinker run.
+- RAW_LEGACY_XML_VISIBLE: YES or NO — mark YES if ordinary assistant text visibly contains `<tool_call>`, `<function=sequentialthinking>`, `<parameter=`, or `</tool_call>`.
+- CHILD_RESULT: PASS, FAIL, or INCONCLUSIVE — PASS requires exactly three numbered items (`1.`, `2.`, `3.`), exactly one sentence per item, and no fourth property item.
+- FID_2026_0801_008_BEHAVIORAL_RESULT: PASS, FAIL, or INCONCLUSIVE.
+
+Do not claim PASS merely because the final answer sounds correct. PASS requires visible structured runtime evidence that the real Thinker child executed `sequentialthinking` with valid arguments and received a structured result.
+```
+
+## Pass Criteria
+
+Mark `FID_2026_0801_008_BEHAVIORAL_RESULT: PASS` only when all of these are true:
+
+1. A visible structured Thinker child-start/activity event appears.
+2. A visible structured `sequentialthinking` tool-call appears inside that child.
+3. A visible structured `sequentialthinking` **result event** appears inside that child (the tool actually executed with complete arguments — the FID-008 regression target).
+4. `INVALID_PARAMETERS_ERROR` is NO — no “Invalid parameters for sequentialthinking” errors.
+5. `EMPTY_ARGUMENTS_ERROR` is NO — no `received undefined` schema rejections for the four required fields (no `{}` placeholder reaching the executor).
+6. `TRUNCATED_STRING_ERROR` is NO — no “Unterminated string” / “JSON Parse error” signatures (no truncated streamed arguments reaching the executor).
+7. `SEQUENTIALTHINKING_CALL_COUNT` is at least 2 **when visible** — the prompt requires multiple steps; if the CLI hides per-call counters, treat the count as informational and do not gate the result on it (mirrors the FID-007 treatment of `PROMPT_INHERITANCE_PRESERVED`). The real gate stays on visible structured call + result events.
+8. The Thinker does not attempt parent-only tools and no unavailable-tool cascade appears.
+9. No raw legacy XML tool-call markup is rendered as ordinary assistant text.
+10. The child returns exactly three numbered properties, one sentence each.
+11. The CLI exposes enough structured evidence to distinguish execution from narration.
+
+If the CLI does not expose child/tool events clearly enough to verify items 1–3, report the relevant fields and the overall result as **INCONCLUSIVE**, not PASS.
+
+## Failure Signatures
+
+Treat the run as **FAIL** if any of the following occurs:
+
+- The parent answers directly without a real Thinker child-start event.
+- The Thinker child starts but its `sequentialthinking` calls fail with “Invalid parameters for sequentialthinking” (the FID-008 pre-fix signature).
+- Any error shows `received undefined` for `thought`, `thoughtNumber`, `totalThoughts`, or `nextThoughtNeeded` (empty `{}` arguments survived the provider).
+- Any error contains “Unterminated string”, “JSON Parse error”, or “expected the tool arguments to be an object, but received a string” (truncated streamed arguments survived the provider).
+- A `sequentialthinking` call is visible but **no structured result event** follows (arguments were dropped and the call never executed).
+- The Thinker attempts `spawn_agents`, `write_file`, `str_replace`, `skill`, `suggest_followups`, `think_deeply`, or another parent-only tool.
+- `sequentialthinking` appears only as ordinary prose or legacy XML rather than a structured tool event/result.
+- Literal `<tool_call>`, `<function=sequentialthinking>`, `<parameter=...>`, or `</tool_call>` appears as ordinary assistant text.
+- The child result is missing, contains fewer or more than three properties, or has an extra numbered property.
+
+## Results Report
+
+Record the live result below after running the prompt:
+
+```text
+Date:
+Model/provider:
+CLI version/commit:
+Operating system:
+
+THINKER_SPAWNED:
+THINKER_CHILD_TOOL_EXECUTED:
+SEQUENTIALTHINKING_CALL_COUNT:
+INVALID_PARAMETERS_ERROR:
+EMPTY_ARGUMENTS_ERROR:
+TRUNCATED_STRING_ERROR:
+TOOL_RESULT_RECEIVED:
+PARENT_TOOL_LEAKAGE:
+UNAVAILABLE_TOOL_ERROR:
+RAW_LEGACY_XML_VISIBLE:
+CHILD_RESULT:
+FID_2026_0801_008_BEHAVIORAL_RESULT:
+
+Evidence notes:
+- Thinker child-start event:
+- First sequentialthinking call/result (arguments + returned thought payload):
+- Second sequentialthinking call/result (arguments + returned thought payload):
+- Any invalid-parameters / empty-arguments / unterminated-string error:
+- Any parent-only tool attempt:
+- Any raw legacy XML:
+- Final child answer:
+
+If the result is FAIL or INCONCLUSIVE, preserve the relevant transcript excerpt
+and explain which evidence was missing or which failure signature appeared.
+```
+
+**Evidence rule:** Structured child/tool events are required for PASS. Assistant claims, final answers, raw XML-shaped text, or a tool name mentioned in prose are not execution evidence. Specifically, `TOOL_RESULT_RECEIVED: PASS` requires a structured result event carrying the thought payload — proof that the complete arguments object survived the streaming accumulation fix.