plan plans, go goes — live SVG dashboard, guided first hour, reliable local-model planning

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code

[Shashankss1205]

What this is

One PR carrying today's end-to-end product work. Full suite: 1,984 passed, ruff clean; verified against real local models (qwen3:8b, llama3.1 — 6/6 goal_met on the reliability bar) and a real delegated Claude run.

The verbs now mean what they say

• grapharc plan proposes, the gate admits, the plan is saved to plan.json — and nothing executes (stopped: planned, exit 0). Looking at it and typing gois the approval.
• grapharc go executes the newest saved plan (go <run-dir> for a specific one), replaying the stored proposal through the full loop so admission judges it again — an edited plan.json is a new proposal, never a pre-approved one. go "a goal" / plan --go = one shot.
• Registry chain shared by both: flag/config → ./registry.py (yours wins) → built-in kinds; --default forces the built-ins.
• No silent scripts in real commands: a model is required; --scripted is the explicit, labeled free rehearsal.

Live view (no CDN, packaged frontend)

Designed SVG dashboard: per-node status/tokens/cost/duration, the goal in the header, violet proposed nodes with a copyable grapharc approve banner while parked, amber running / green done, replay scrubber, planning panel. Server-side deterministic layout (cycle-safe), structured GraphSnapshot in every SSE frame, shared status resolver across Mermaid/Slack/SVG. Slack links point at the operator's own run page first.

Local-model planning made reliable

• <think>-block-safe JSON extraction (a draft inside reasoning can never beat the visible answer; think-tags inside JSON strings survive), every fence tried, trailing-comma repair only on already-failed candidates.
• Slim non-recursive proposal schema for backends that disclaim structured output (Ollama's grammar decoder chokes on the recursive strict Subgraph schema).
• Parse-failure retries show the model its own reply plus a diamond worked example — 8B models now fan independent work out in parallel instead of chaining it (verified: a 3-part goal plans collect_context → investigate_repo ∥ investigate_help ∥ investigate_docs → summarize).
• A deterministic 404 on the model name aborts round 1 instead of burning every retry.
• New knobs: --model-arg KEY=VALUE, --workspace, --max-planning-failures.
• Safety fix: the generated-policy cache is keyed by registry — a stale incident policy can no longer silently unlock apply_change (proof test included).

First hour

Bare grapharc orients (exit 0); grapharc help works; start explains every term in plain words; init scaffolds a commented registry.py whose first free run demonstrates refuse-then-admit and whose gather does real work. Traces default under .grapharc/runs/; serve --live-root writes a discovery marker; plan/go always print a probed watch : URL.

Also

Public site under docs/site/ (animated governed-run hero, Pages workflow — needs the one-time Settings → Pages → Source: "GitHub Actions" toggle), README repositioned around the admission gate with an honest comparison table, CHANGELOG entries in house style.

🤖 Generated with Claude Code