create-agdf 0.20.2 → 0.30.0

package/generated/.opencode/skills/agdf-task-plan-review/SKILL.md

@@ -48,9 +48,10 @@ Then pick one catalog route; non-authorizing, downstream checks remain.
 
 ## Executable Dispatch
 
-Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `task-plan-review`, `presentation_language`, `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
+Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `task-plan-review`, `presentation_language` (optional override), `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
 If absent/failing: supplied schema-2 executable, child-only environment, immutable argv_prefix, declared arguments; `--skill task-plan-review`, language and working directory.
-For `--language`: Required presentation language for the latest natural-language user request as one well-formed BCP 47 tag. If the request explicitly asks for a response language, use that tag; otherwise use the dominant request language. Use en when mixed or ambiguous. A valid unsupported tag renders through the complete English pack. Missing or invalid input fails before governance evaluation.
+MCP: MCP reply-language override (BCP 47). Omit for a matching configured preference; otherwise supply the current request's language (explicit instruction, then dominant language, en if ambiguous). Invalid explicit tags fail; valid unsupported tags use the complete English pack. Core input remains complete.
+For `--language`: Required; apply the same current-request selection and locale validation.
 `target_source`: `explicit_target` if request names `primary_target`; `continued_target` if it unambiguously continues confirmed target; `current_repository` if request names this/current repo with one matching repo active. Otherwise omit the pair; cwd has no target authority.
 Quote shell values as data.
 For a result with `terminal: true`, the entire assistant response must consist only of host_action.text, copied verbatim. Add no question, explanation, heading, citation, link or other surrounding text; do not translate or reformat it; invoke no later tool and stop.

package/generated/.opencode/skills/agdf-tp-definition/SKILL.md

@@ -36,9 +36,10 @@ Then pick one catalog route; non-authorizing, downstream checks remain.
 
 ## Executable Dispatch
 
-Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `tp-definition`, `presentation_language`, `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
+Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `tp-definition`, `presentation_language` (optional override), `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
 If absent/failing: supplied schema-2 executable, child-only environment, immutable argv_prefix, declared arguments; `--skill tp-definition`, language and working directory.
-For `--language`: Required presentation language for the latest natural-language user request as one well-formed BCP 47 tag. If the request explicitly asks for a response language, use that tag; otherwise use the dominant request language. Use en when mixed or ambiguous. A valid unsupported tag renders through the complete English pack. Missing or invalid input fails before governance evaluation.
+MCP: MCP reply-language override (BCP 47). Omit for a matching configured preference; otherwise supply the current request's language (explicit instruction, then dominant language, en if ambiguous). Invalid explicit tags fail; valid unsupported tags use the complete English pack. Core input remains complete.
+For `--language`: Required; apply the same current-request selection and locale validation.
 `target_source`: `explicit_target` if request names `primary_target`; `continued_target` if it unambiguously continues confirmed target; `current_repository` if request names this/current repo with one matching repo active. Otherwise omit the pair; cwd has no target authority.
 Quote shell values as data.
 For a result with `terminal: true`, the entire assistant response must consist only of host_action.text, copied verbatim. Add no question, explanation, heading, citation, link or other surrounding text; do not translate or reformat it; invoke no later tool and stop.

package/generated/.opencode/skills/agdf-ur-definition/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: agdf-ur-definition
-description: "Use this skill for this scope: bound UR drafting, clarification or revision. Boundary: content only; preserves approved intent. The requested effect, not discovery, decides AGDF activation."
+description: "Use this skill for this scope: UR drafting in planning scope or a bound Run. Boundary: content only; no start or approval authority. The requested effect, not discovery, decides AGDF activation."
 ---
 
 # ur-definition
@@ -34,9 +34,15 @@ Then pick one catalog route; non-authorizing, downstream checks remain.
 
 ## Executable Dispatch
 
-Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `ur-definition`, `presentation_language`, `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
+Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `ur-definition`, `presentation_language` (optional override), `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
+For deliberate pre-Run planning, pass the confirmed `planning` scope instead of `run_id`.
+Use `plan-<future mutation UUID>` and null expected digest for capture, or the inspected
+plan identity/current digest for refinement. No delivery intake/continue/revision fields.
+Follow only `phase: planned_ur_definition`, shared template/contract and planning-scoped typed
+writers. Missing compatible Core stops before mutation; no CLI/shell writer or Run-assignment fallback.
 If absent/failing: supplied schema-2 executable, child-only environment, immutable argv_prefix, declared arguments; `--skill ur-definition`, language and working directory.
-For `--language`: Required presentation language for the latest natural-language user request as one well-formed BCP 47 tag. If the request explicitly asks for a response language, use that tag; otherwise use the dominant request language. Use en when mixed or ambiguous. A valid unsupported tag renders through the complete English pack. Missing or invalid input fails before governance evaluation.
+MCP: MCP reply-language override (BCP 47). Omit for a matching configured preference; otherwise supply the current request's language (explicit instruction, then dominant language, en if ambiguous). Invalid explicit tags fail; valid unsupported tags use the complete English pack. Core input remains complete.
+For `--language`: Required; apply the same current-request selection and locale validation.
 `target_source`: `explicit_target` if request names `primary_target`; `continued_target` if it unambiguously continues confirmed target; `current_repository` if request names this/current repo with one matching repo active. Otherwise omit the pair; cwd has no target authority.
 Quote shell values as data.
 For a result with `terminal: true`, the entire assistant response must consist only of host_action.text, copied verbatim. Add no question, explanation, heading, citation, link or other surrounding text; do not translate or reformat it; invoke no later tool and stop.
@@ -51,4 +57,6 @@ review timing in the UR; creation belongs to the later bound analytical step.
 Set the initial `Preview requirement` metadata according to the UR contract; a required
 interactive before-PRD preview uses `before_prd_interactive`, otherwise `none`.
 Write only the supplied unapproved UR, preserving uncertainty and explicit human approval.
-After canonical recording, redispatch gate-check; use its fresh presentation and wait.
+In Run mode, after canonical recording redispatch gate-check; use its fresh presentation and wait.
+In planning mode, report the saved draft, source and remaining questions without requesting a
+gate approval. Only a later explicit selected-source start request uses the Core handoff contract.

package/generated/.opencode/skills/agdf-ux-intent-definition/SKILL.md

@@ -40,9 +40,10 @@ Then pick one catalog route; non-authorizing, downstream checks remain.
 
 ## Executable Dispatch
 
-Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `ux-intent-definition`, `presentation_language`, `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
+Use listed MCP `agdf_dispatch` (load deferred; host prefix allowed): `skill_id` `ux-intent-definition`, `presentation_language` (optional override), `working_directory`, and only bound `target_source`/`primary_target` and `run_id`. Never search unlisted tools.
 If absent/failing: supplied schema-2 executable, child-only environment, immutable argv_prefix, declared arguments; `--skill ux-intent-definition`, language and working directory.
-For `--language`: Required presentation language for the latest natural-language user request as one well-formed BCP 47 tag. If the request explicitly asks for a response language, use that tag; otherwise use the dominant request language. Use en when mixed or ambiguous. A valid unsupported tag renders through the complete English pack. Missing or invalid input fails before governance evaluation.
+MCP: MCP reply-language override (BCP 47). Omit for a matching configured preference; otherwise supply the current request's language (explicit instruction, then dominant language, en if ambiguous). Invalid explicit tags fail; valid unsupported tags use the complete English pack. Core input remains complete.
+For `--language`: Required; apply the same current-request selection and locale validation.
 `target_source`: `explicit_target` if request names `primary_target`; `continued_target` if it unambiguously continues confirmed target; `current_repository` if request names this/current repo with one matching repo active. Otherwise omit the pair; cwd has no target authority.
 Quote shell values as data.
 For a result with `terminal: true`, the entire assistant response must consist only of host_action.text, copied verbatim. Add no question, explanation, heading, citation, link or other surrounding text; do not translate or reformat it; invoke no later tool and stop.
@@ -97,7 +98,7 @@ implementation. A requested change to the actual product still follows its exist
 #### Retain a run-bound preview
 
 For a preview used in this bound analysis, save a durable, reopenable copy under
-`.agdf/control/artefacts/<run_id>/previews/<short-name>-v<N>/index.html`, relative to the supplied
+`.agdf/control/runs/<run_id>/evidence/previews/<short-name>-v<N>/index.html`, relative to the supplied
 governance target. Derive the run from the valid assignment, not cwd, recency or another run.
 Resolve containment and reject symlink escapes before writing; never put preview content in
 `runs/<run_id>/RUN_STATE.md`. Use a new unused version for revisions and preserve reviewed versions.
@@ -175,7 +176,7 @@ Populate each field or use an explicit, justified `not_applicable`:
 
 For `blocked`, `blocking_reason`, `open_product_questions`, `affected_outputs`, `evidence`,
 `missing_evidence` and `required_next_step` are mandatory. When durable control state exists, write
-the result to `.agdf/control/artefacts/<run_id>/UX_INTENT_DEFINITION.md` without a Gate or approval field.
+the result to `.agdf/control/runs/<run_id>/documents/UX_INTENT_DEFINITION.md` without a Gate or approval field.
 
 ## Forbidden
 

package/generated/plugins/agdf/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.20.2",
+  "version": "0.30.0",
   "description": "AI Governance & Delivery Framework (AGDF) is a governance framework for agentic work. Its first implementation provides a control layer for governed AI-assisted software delivery. It combines workflow skills, explicit gates, control templates and machine-readable repository checks to keep work aligned with approved scope and make evidence a prerequisite for consequential gate transitions. Supported workflows include brownfield analysis, task-plan review, QA decisions, durable run state and auditable delivery closeout. AGDF is an independent open-source project, not a security sandbox, compliance certification or autonomous release system.",
   "keywords": [
     "agentic",
@@ -16,5 +16,6 @@
     "name": "Arndt Gold",
     "url": "https://agdf.iself.eu"
   },
-  "mcpServers": "./mcp/claude.mcp.json"
+  "mcpServers": "./mcp/claude.mcp.json",
+  "hooks": "./companion/hooks.json"
 }

package/generated/plugins/agdf/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.20.2",
+  "version": "0.30.0",
   "description": "Control layer for governed AI-assisted delivery.",
   "author": {
     "name": "Arndt Gold",

package/generated/plugins/agdf/companion/assignment.mjs

@@ -0,0 +1,65 @@
+// Run assignment per session (SDD-06, AC-004; chat-run navigation SDD-01 to SDD-04): the chat's run
+// (named in a main-loop turn or changed in this session, the later wins) unless the user browses,
+// else the remembered selection for this project, else none. Display only; it binds no AGDF delivery.
+
+// A run state without `updated_at` sorts last and never counts as changed in this session.
+const changedAt = run => (run.updatedAt ? Date.parse(run.updatedAt) : -Infinity);
+const newestFirst = (left, right) => changedAt(right) - changedAt(left) || left.id.localeCompare(right.id);
+
+// Only an active run is open. A superseded or abandoned run is closed like a completed one, but it
+// is never assigned: it has no fertig state to show.
+const ASSIGNABLE = new Set(['active', 'completed']);
+export const openRuns = runs => runs.filter(run => run.lifecycle === 'active').sort(newestFirst);
+
+// A run id is made of these characters; a mention counts only as a whole token. A dot ends a mention
+// unless an id character follows it, so a sentence may end with a run id (chat-run navigation SDD-01).
+const ID_CHAR = /[a-z0-9_-]/iu;
+const MENTION_WINDOW = 65_536;
+const bounded = (text, at, end) => !(at > 0 && (ID_CHAR.test(text[at - 1]) || text[at - 1] === '.'))
+  && !(end < text.length && (ID_CHAR.test(text[end]) || text[end] === '.' && ID_CHAR.test(text[end + 1] ?? '')));
+
+// The id of `ids` that a text names last as a whole token, or null; a long text is read from its end,
+// with the character before that window still bounding a mention (CR-F08).
+export function namedRun(text, ids) {
+  if (typeof text !== 'string' || !text) return null;
+  const from = Math.max(0, text.length - MENTION_WINDOW);
+  let named = null;
+  let namedEnd = -1;
+  for (const id of ids) {
+    if (!id) continue;
+    for (let at = text.indexOf(id, from); at >= 0; at = text.indexOf(id, at + 1)) {
+      const end = at + id.length;
+      if (end > namedEnd && bounded(text, at, end)) { named = id; namedEnd = end; }
+    }
+  }
+  return named;
+}
+
+// runs: parsed runs of the project; sessionStartedAt: host time (ms) at session.start;
+// selection: remembered run id or null; mention: { runId, at } of the last open run a main-loop turn
+// named, or null; isBrowsing: the user browsed away from the chat's run since the last main-loop turn.
+// Returns { run, origin, open, dropSelection, chatRunId }.
+// The chat's run is the later of the mention and the newest change in this session (chat-run
+// navigation SDD-02, SDD-03); it is shown unless the user browses to a remembered selection. A run
+// completed during this session stays assigned, so its fertig state remains visible.
+export function assignRun({ runs, sessionStartedAt, selection = null, mention = null, isBrowsing = false }) {
+  const open = openRuns(runs);
+  const changed = runs.filter(run => ASSIGNABLE.has(run.lifecycle) && changedAt(run) >= sessionStartedAt).sort(newestFirst);
+  const selected = selection ? open.find(run => run.id === selection) ?? null : null;
+  const dropSelection = Boolean(selection) && !selected;
+  const named = mention ? open.find(run => run.id === mention.runId) ?? null : null;
+  const chat = named && (!changed.length || mention.at >= changedAt(changed[0])) ? { run: named, origin: 'named' }
+    : changed.length ? { run: changed[0], origin: 'session' } : null;
+  const chatRunId = chat?.run.id ?? null;
+  if (chat && !(isBrowsing && selected)) return { run: chat.run, origin: chat.origin, open, dropSelection, chatRunId };
+  if (selected) return { run: selected, origin: 'selected', open, dropSelection, chatRunId };
+  return { run: null, origin: 'none', open, dropSelection, chatRunId };
+}
+
+// Steps through the open runs from the shown one (offset -1 or 1) for an explicit selection.
+export function stepSelection(open, currentId, offset) {
+  if (!open.length) return null;
+  const at = open.findIndex(run => run.id === currentId);
+  const from = at < 0 ? (offset > 0 ? -1 : 0) : at;
+  return open[(from + offset + open.length) % open.length].id;
+}

package/generated/plugins/agdf/companion/companion.json

@@ -0,0 +1,4 @@
+{
+  "schema_version": 1,
+  "hooks": "./companion/hooks.json"
+}

package/generated/plugins/agdf/companion/core.mjs

@@ -0,0 +1,16 @@
+import { RUN_MODES, RUN_ID_PATTERN, REVISION_ID_PATTERN } from '../runtime/create-agdf/runtime/core/lib/control-state/run-identity.js';
+// Bounded stored-fact projection only. No filesystem reads, seal qualification or authorization.
+import { parseControlState, recordRows, scalarFields, hasPersistedDerivedState } from '../runtime/create-agdf/runtime/core/lib/control-state/run-state-document.js';
+import { modeSliceDecision } from '../runtime/create-agdf/runtime/core/lib/control-evaluation/run-state-policy.js';
+import { createGatePolicy } from '../runtime/create-agdf/runtime/core/lib/control-evaluation/gate-policy-pure.js';
+const policy = createGatePolicy(content => ({ receipts: recordRows(content, 'Source Revisions') }));
+export function projectStoredRun(content) {
+  const fields = scalarFields(content), meta = Object.fromEntries(fields.values);
+  if (fields.duplicates.length || meta.control_state_version !== '4' || !RUN_MODES.includes(meta.mode) || !RUN_ID_PATTERN.test(meta.run_id ?? '') || !REVISION_ID_PATTERN.test(meta.revision_id ?? '') || hasPersistedDerivedState(content)) throw Error('format');
+  const facts = parseControlState(content);
+  const decisions = new Map();
+  for (const row of recordRows(content, 'Run Operations')) if (row.kind === 'presentation_decision.record' && row.effect.revision === Number(meta.revision))
+    decisions.set(row.effect.record.gate, { available: true, decided: true, action: row.effect.record.action });
+  const state = { ...facts, content, meta, presentation_decisions: decisions };
+  return { meta, facts, route: modeSliceDecision(state), control: policy.transitionDecisionForRunState(state) };
+}

package/generated/plugins/agdf/companion/figure.mjs

@@ -0,0 +1,137 @@
+// The companion figure (SDD-09, AC-010): an SVG document per mood. Accessories are drawn only inside
+// ACCESSORY_REGION, which lies outside FIGURE_BOX (the figure's extent including its motion), so no
+// accessory can cover the figure. The still pose emits no animation element at all.
+
+export const VIEW = Object.freeze({ width: 200, height: 140 });
+// Body, ears, feet and shadow span x 34..126, y 26..134; motion adds up to 7 px sideways and 10 px upwards.
+export const FIGURE_BOX = Object.freeze({ x: 20, y: 8, width: 120, height: 132 });
+export const ACCESSORY_REGION = Object.freeze({ x: 148, y: 8, width: 48, height: 48 });
+// Each accessory's extent in region coordinates, including its strokes and motion.
+export const ACCESSORY_BOUNDS = Object.freeze({
+  laeuft: { x: 8, y: 20, width: 32, height: 8 },
+  baut: { x: 1, y: 16, width: 45, height: 31 },
+  wartet: { x: 8, y: 8, width: 32, height: 32 },
+  blockiert: { x: 6, y: 6, width: 36, height: 36 },
+  fertig: { x: 1, y: 1, width: 46, height: 46 },
+  neutral: null,
+});
+// The build accessory in region coordinates: a hammer swinging around the end of its handle between
+// the two angles (degrees, clockwise positive), and three bricks; strokes are at most 1.5 px wide.
+export const HAMMER = Object.freeze({ pivot: Object.freeze({ x: 36, y: 44 }), swing: Object.freeze([-55, 5]),
+  head: Object.freeze({ x: -6, y: -26, width: 12, height: 6 }), handle: Object.freeze({ x: -1.5, y: -20, width: 3, height: 20 }) });
+export const BRICKS = Object.freeze([{ x: 2, y: 38 }, { x: 17, y: 38 }, { x: 9.5, y: 30 }].map(Object.freeze));
+export const BRICK_SIZE = Object.freeze({ width: 14, height: 7 });
+
+const BODY = Object.freeze({
+  laeuft: { fill: '#4F7FD9', stroke: '#2D4E8F' },
+  baut: { fill: '#3E8FB0', stroke: '#235A70' },
+  wartet: { fill: '#E0A030', stroke: '#9A6A12' },
+  blockiert: { fill: '#D9534F', stroke: '#8F2D2A' },
+  fertig: { fill: '#3FA66A', stroke: '#23663F' },
+  neutral: { fill: '#9AA3B2', stroke: '#5C6575' },
+});
+const INK = '#1F2430';
+
+const escape = text => String(text).replace(/[&<>"]/gu, char => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[char]);
+const loop = (isMoving, animation) => (isMoving ? animation : '');
+
+function eyes(mood, isMoving) {
+  if (mood === 'blockiert') {
+    const cross = x => `<path d="M${x - 6} 66 l12 12 M${x + 6} 66 l-12 12" stroke="${INK}" stroke-width="3.5" stroke-linecap="round"/>`;
+    return cross(64) + cross(96);
+  }
+  if (mood === 'fertig') {
+    const arc = x => `<path d="M${x - 7} 74 q7 -9 14 0" fill="none" stroke="${INK}" stroke-width="3.5" stroke-linecap="round"/>`;
+    return arc(64) + arc(96);
+  }
+  const blink = loop(isMoving, '<animate attributeName="ry" values="9;9;1;9" keyTimes="0;0.9;0.95;1" dur="3.6s" repeatCount="indefinite"/>');
+  const look = mood === 'laeuft'
+    ? loop(isMoving, '<animateTransform attributeName="transform" type="translate" values="-3 0;3 0;-3 0" dur="1.6s" repeatCount="indefinite"/>')
+    : '';
+  // A figure that builds looks down at its work on the right.
+  const [dx, dy] = mood === 'baut' ? [3, 2] : [0, 0];
+  const eye = x => `<ellipse cx="${x}" cy="72" rx="9" ry="9" fill="#FFFFFF">${blink}</ellipse><g>${look}<circle cx="${x + dx}" cy="${73 + dy}" r="4" fill="${INK}"/></g>`;
+  return eye(64) + eye(96);
+}
+
+const MOUTH = Object.freeze({
+  laeuft: `<ellipse cx="80" cy="96" rx="4" ry="5" fill="${INK}"/>`,
+  baut: `<path d="M74 97 q6 4 12 0" fill="none" stroke="${INK}" stroke-width="3" stroke-linecap="round"/>`,
+  wartet: `<path d="M72 97 h16" stroke="${INK}" stroke-width="3" stroke-linecap="round"/>`,
+  blockiert: `<path d="M70 101 q10 -9 20 0" fill="none" stroke="${INK}" stroke-width="3" stroke-linecap="round"/>`,
+  fertig: `<path d="M68 93 q12 12 24 0" fill="none" stroke="${INK}" stroke-width="3" stroke-linecap="round"/>`,
+  neutral: `<path d="M73 97 h14" stroke="${INK}" stroke-width="3" stroke-linecap="round"/>`,
+});
+
+const MOTION = Object.freeze({
+  laeuft: '<animateTransform attributeName="transform" type="translate" values="0 0;0 -7;0 0" dur="0.7s" repeatCount="indefinite"/>',
+  // A slow bob in time with the hammer.
+  baut: '<animateTransform attributeName="transform" type="translate" values="0 0;0 -3;0 0" keyTimes="0;0.35;1" dur="0.9s" repeatCount="indefinite"/>',
+  wartet: '<animateTransform attributeName="transform" type="rotate" values="-4 80 124;4 80 124;-4 80 124" dur="2.6s" repeatCount="indefinite"/>',
+  blockiert: '<animateTransform attributeName="transform" type="translate" values="0 0;-4 0;4 0;-4 0;4 0;0 0;0 0" keyTimes="0;0.04;0.08;0.12;0.16;0.2;1" dur="2.2s" repeatCount="indefinite"/>',
+  fertig: '<animateTransform attributeName="transform" type="translate" values="0 0;0 0;0 -10;0 0" keyTimes="0;0.6;0.8;1" dur="2s" repeatCount="indefinite"/>',
+  neutral: '',
+});
+
+// Drawn in region coordinates (0..48); ACCESSORY_BOUNDS states each extent.
+function accessory(mood, isMoving) {
+  if (mood === 'laeuft') {
+    const dot = (x, begin) => `<circle cx="${x}" cy="24" r="4" fill="#4F7FD9">${loop(isMoving, `<animate attributeName="opacity" values="0.2;1;0.2" dur="1.2s" begin="${begin}" repeatCount="indefinite"/>`)}</circle>`;
+    return dot(12, '0s') + dot(24, '0.2s') + dot(36, '0.4s');
+  }
+  if (mood === 'baut') {
+    // One brick appears per hammer stroke; the still pose shows all three and the raised hammer.
+    const brick = ({ x, y }, begin) => `<rect x="${x}" y="${y}" width="${BRICK_SIZE.width}" height="${BRICK_SIZE.height}" rx="1" fill="#C8643C" stroke="#7A3A1E" stroke-width="1.5" opacity="${isMoving ? 0 : 1}">`
+      + `${loop(isMoving, `<animate attributeName="opacity" values="0;1;1;0" keyTimes="0;0.1;0.9;1" dur="2.7s" begin="${begin}" repeatCount="indefinite"/>`)}</rect>`;
+    const { pivot: { x: px, y: py }, swing: [strike, raised], head, handle } = HAMMER;
+    const swing = loop(isMoving, `<animateTransform attributeName="transform" type="rotate" values="${raised} ${px} ${py};${strike} ${px} ${py};${raised} ${px} ${py}" keyTimes="0;0.35;1" dur="0.9s" repeatCount="indefinite"/>`);
+    return BRICKS.map((position, index) => brick(position, `${index * 0.9}s`)).join('')
+      + `<g transform="rotate(${raised} ${px} ${py})">${swing}`
+      + `<rect x="${px + handle.x}" y="${py + handle.y}" width="${handle.width}" height="${handle.height}" rx="1" fill="#A0703C" stroke="#5C3A1A" stroke-width="1"/>`
+      + `<rect x="${px + head.x}" y="${py + head.y}" width="${head.width}" height="${head.height}" rx="1" fill="#8A93A3" stroke="#374151" stroke-width="1.5"/></g>`;
+  }
+  if (mood === 'wartet') {
+    const turn = loop(isMoving, '<animateTransform attributeName="transform" type="rotate" values="0 24 24;0 24 24;180 24 24" keyTimes="0;0.7;1" dur="2.4s" repeatCount="indefinite"/>');
+    return `<g>${turn}<path d="M16 12 h16 l-8 12 l8 12 h-16 l8 -12 z" fill="#FFF3D6" stroke="#9A6A12" stroke-width="2.5" stroke-linejoin="round"/></g>`;
+  }
+  if (mood === 'blockiert') {
+    return '<g transform="translate(24 24)"><polygon points="-7,-17 7,-17 17,-7 17,7 7,17 -7,17 -17,7 -17,-7" fill="#D9534F" stroke="#8F2D2A" stroke-width="2"/>'
+      + '<rect x="-2" y="-10" width="4" height="12" rx="1.5" fill="#FFFFFF"/><circle cx="0" cy="7" r="2.4" fill="#FFFFFF"/></g>';
+  }
+  if (mood === 'fertig') {
+    const sparkle = (x, y, begin) => `<path d="M${x} ${y - 7} L${x + 2} ${y - 2} L${x + 7} ${y} L${x + 2} ${y + 2} L${x} ${y + 7} L${x - 2} ${y + 2} L${x - 7} ${y} L${x - 2} ${y - 2} Z" fill="#F2C94C">`
+      + `${loop(isMoving, `<animate attributeName="opacity" values="0;1;0" dur="1.8s" begin="${begin}" repeatCount="indefinite"/>`)}</path>`;
+    return sparkle(8, 8, '0s') + sparkle(40, 8, '0.6s') + sparkle(40, 40, '1.2s')
+      + '<g transform="translate(22 28)"><circle r="12" fill="#FFFFFF" stroke="#23663F" stroke-width="2.5"/>'
+      + '<path d="M-6 0 l4 5 l8 -10" fill="none" stroke="#23663F" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/></g>';
+  }
+  return '';
+}
+
+// mood: one of the five moods or 'neutral' (no run assigned, status unreadable).
+export function figureSvg(mood, { still = false, title = '' } = {}) {
+  const isMoving = !still;
+  const { fill, stroke } = BODY[mood];
+  const { x, y } = ACCESSORY_REGION;
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${VIEW.width} ${VIEW.height}" width="${VIEW.width}" height="${VIEW.height}">`
+    + `<title>${escape(title)}</title>`
+    + '<ellipse cx="80" cy="128" rx="40" ry="6" fill="#000000" opacity="0.12"/>'
+    + `<g>${loop(isMoving, MOTION[mood])}`
+    + `<ellipse cx="62" cy="122" rx="11" ry="6" fill="${stroke}"/><ellipse cx="98" cy="122" rx="11" ry="6" fill="${stroke}"/>`
+    + `<path d="M34 84 q0 -46 46 -46 q46 0 46 46 q0 36 -46 36 q-46 0 -46 -36 z" fill="${fill}" stroke="${stroke}" stroke-width="3"/>`
+    + `<path d="M52 40 l-8 -14 l18 8 z M108 40 l8 -14 l-18 8 z" fill="${fill}" stroke="${stroke}" stroke-width="3" stroke-linejoin="round"/>`
+    + '<ellipse cx="80" cy="100" rx="26" ry="17" fill="#FFFFFF" opacity="0.28"/>'
+    + eyes(mood, isMoving) + MOUTH[mood] + '</g>'
+    + `<g transform="translate(${x} ${y})">${accessory(mood, isMoving)}</g>`
+    + '</svg>';
+}
+
+// The terminal has no Svg: a short face stands for the figure there.
+export const FIGURE_TEXT = Object.freeze({
+  laeuft: '(o_o) …',
+  baut: '(o_o) ⚒',
+  wartet: '(-_-) ⧗',
+  blockiert: '(x_x) !',
+  fertig: '(^_^) ✓',
+  neutral: '(·_·)',
+});

package/generated/plugins/agdf/companion/gate-bar.mjs

@@ -0,0 +1,54 @@
+// Single-line gate bar (SDD-02, AC-001, AC-003): ✓ done, ● current, ○ open, without separators. It
+// follows the status card's path for the run's route and adds the build phase as `CD+Tests` between
+// TP and QA on structured paths. Below the width the full bar needs, a condensed form keeps every
+// mark and still names the current gate.
+
+import { BUILD_GATES, isStructured } from './run-state.mjs';
+
+const GLYPH = Object.freeze({ done: '✓', current: '●', open: '○' });
+const STRUCTURED = Object.freeze(['UR', 'PRD', 'SD', 'TP', 'QA', 'UAT', 'OR']);
+// The status card's paths (`BREADCRUMB_PATH_TEMPLATES`, gate-check.js); parity-tested.
+export const PATHS = Object.freeze({
+  structured_delivery: STRUCTURED,
+  structured_slice: STRUCTURED,
+  verified_change: Object.freeze(['UR', 'Verified Change', 'OR']),
+  quick_task: Object.freeze(['UR', 'Compact Delivery']),
+  block: Object.freeze(['UR', 'Block']),
+  undecided: Object.freeze(['UR']),
+});
+export const BUILD_MARK = 'CD+Tests';
+const USER_GATES = new Set(['UR', 'PRD', 'SD', 'TP', 'QA', 'UAT']);
+const AFTER_BUILD = new Set(['QA', 'UAT', 'OR']);
+const COMPACT = Object.freeze({ 'Verified Change': 'verified_change', 'Compact Delivery': 'quick_task', Block: 'block' });
+
+// One path entry's mark as `buildBreadcrumbPath` derives it; a completed run at OR has its closeout.
+function cardMark(gate, run) {
+  if (USER_GATES.has(gate)) return run.approved.includes(gate) ? 'done' : gate === run.gate ? 'current' : 'open';
+  if (gate === 'OR' && run.gate === 'OR' && run.lifecycle === 'completed') return 'done';
+  if (gate === run.gate) return 'current';
+  if ((gate === 'Verified Change' || gate === 'Compact Delivery') && run.gate === 'OR') return 'done';
+  return Object.hasOwn(COMPACT, gate) && COMPACT[gate] === run.route ? 'current' : 'open';
+}
+
+export function gateMarks(run) {
+  const path = Object.hasOwn(PATHS, run.route) ? PATHS[run.route] : PATHS.undecided;
+  const marks = path.map(gate => ({ gate, mark: cardMark(gate, run) }));
+  if (!isStructured(run.route)) return marks;
+  const build = BUILD_GATES.includes(run.gate) ? 'current' : AFTER_BUILD.has(run.gate) || run.lifecycle === 'completed' ? 'done' : 'open';
+  marks.splice(path.indexOf('QA'), 0, { gate: BUILD_MARK, mark: build });
+  return marks;
+}
+
+export const fullGateBar = marks => marks.map(({ gate, mark }) => `${GLYPH[mark]}${gate}`).join(' ');
+
+export function condensedGateBar(marks) {
+  const current = marks.find(({ mark }) => mark === 'current');
+  const glyphs = marks.map(({ mark }) => GLYPH[mark]).join('');
+  return current ? `${glyphs} ${current.gate}` : glyphs;
+}
+
+// The glyphs and gate names are single-width; columns is the pane's bodyColumns.
+export function gateBar(marks, columns = Infinity) {
+  const full = fullGateBar(marks);
+  return full.length <= columns ? full : condensedGateBar(marks);
+}

package/generated/plugins/agdf/companion/hooks.json

@@ -0,0 +1,3 @@
+{
+  "modules": ["./register.mjs"]
+}

package/generated/plugins/agdf/companion/locales.json

@@ -0,0 +1,200 @@
+{
+  "schemaVersion": 1,
+  "fallbackLocale": "en",
+  "locales": {
+    "en": {
+      "title": "AGDF Companion",
+      "languageNames": ["English", "Englisch"],
+      "states": {
+        "laeuft": "working",
+        "baut": "building",
+        "wartet": "waiting for approval",
+        "blockiert": "blocked",
+        "fertig": "done",
+        "neutral": "idle"
+      },
+      "statusStates": {
+        "laeuft": "working",
+        "baut": "building",
+        "wartet": "waiting",
+        "blockiert": "blocked",
+        "fertig": "done",
+        "neutral": "idle",
+        "unreadable": "unreadable"
+      },
+      "reasons": {
+        "turnActive": "Claude is working on this turn",
+        "done": "Run completed",
+        "blocked": "{gate}: {decision}",
+        "waitingApproval": "Approval pending: {gate}",
+        "waitingDecision": "Decision pending: {gate}",
+        "working": "Next: {gate}",
+        "building": "In progress: {gate}"
+      },
+      "notices": {
+        "waitingApproval": "{run} is waiting for approval: {gate}",
+        "waitingDecision": "{run} is waiting for a decision: {gate}",
+        "blocked": "{run} is blocked: {gate} – {decision}"
+      },
+      "decisions": {
+        "revise": "revision needed",
+        "block": "blocked",
+        "blocked": "blocked",
+        "decline": "declined"
+      },
+      "unreadable": {
+        "missing": "run state file missing or not readable",
+        "too_large": "run state file too large",
+        "format": "unknown run state format",
+        "unknownState": "run state matches no known state",
+        "failed": "control folder could not be read"
+      },
+      "messages": {
+        "reading": "Reading run state …",
+        "noControl": "No AGDF control folder in “{folder}”.",
+        "noControlHint": "Checked project folder: {path}",
+        "noOpenRuns": "No open runs in this project.",
+        "noRunAssigned": "No run assigned",
+        "noRunAssignedHint": "No run changed in this session. Choose an open run to show it here.",
+        "unreadable": "Run state not readable: {reason}",
+        "stale": "Read failed at {time}; showing the state from {readAt}."
+      },
+      "origin": {
+        "session": "Changed in this session",
+        "selected": "Selected by you",
+        "named": "Named in the chat"
+      },
+      "fields": {
+        "nextStep": "Next step",
+        "objective": "Objective",
+        "lastRead": "As of {time}",
+        "openRuns": "{count} open runs",
+        "moreRuns": "+ {count} more",
+        "position": "{position} of {count} open runs"
+      },
+      "actions": {
+        "retry": "Read again",
+        "stillOn": "Stop motion",
+        "stillOff": "Start motion",
+        "noticeOff": "Notices off",
+        "noticeOn": "Notices on",
+        "soundOn": "Sound on",
+        "soundOff": "Sound off",
+        "expand": "More",
+        "collapse": "Less",
+        "previous": "Previous run",
+        "next": "Next run",
+        "about": "About",
+        "closeAbout": "Close",
+        "backToChat": "Back to chat run"
+      },
+      "about": {
+        "text": "Shows the state of your AGDF runs beside the chat. Read-only: approvals stay in the chat.",
+        "version": "AGDF plugin {version}"
+      },
+      "command": {
+        "description": "Switch the AGDF Companion on or off",
+        "enabled": "AGDF Companion switched on.",
+        "disabled": "AGDF Companion switched off.",
+        "waiting": "AGDF Companion is switched on and waits for space: {reason}"
+      }
+    },
+    "de": {
+      "title": "AGDF Companion",
+      "languageNames": ["German", "Deutsch"],
+      "states": {
+        "laeuft": "läuft",
+        "baut": "baut",
+        "wartet": "wartet auf Freigabe",
+        "blockiert": "blockiert",
+        "fertig": "fertig",
+        "neutral": "bereit"
+      },
+      "statusStates": {
+        "laeuft": "läuft",
+        "baut": "baut",
+        "wartet": "wartet",
+        "blockiert": "blockiert",
+        "fertig": "fertig",
+        "neutral": "bereit",
+        "unreadable": "nicht lesbar"
+      },
+      "reasons": {
+        "turnActive": "Claude arbeitet gerade an diesem Turn",
+        "done": "Run abgeschlossen",
+        "blocked": "{gate}: {decision}",
+        "waitingApproval": "Freigabe ausstehend: {gate}",
+        "waitingDecision": "Entscheidung ausstehend: {gate}",
+        "working": "Als Nächstes: {gate}",
+        "building": "In Arbeit: {gate}"
+      },
+      "notices": {
+        "waitingApproval": "{run} wartet auf Freigabe: {gate}",
+        "waitingDecision": "{run} wartet auf Entscheidung: {gate}",
+        "blocked": "{run} ist blockiert: {gate} – {decision}"
+      },
+      "decisions": {
+        "revise": "Überarbeitung nötig",
+        "block": "blockiert",
+        "blocked": "blockiert",
+        "decline": "abgelehnt"
+      },
+      "unreadable": {
+        "missing": "Run-Datei fehlt oder ist nicht lesbar",
+        "too_large": "Run-Datei ist zu groß",
+        "format": "unbekanntes Format der Run-Datei",
+        "unknownState": "Run-Zustand passt zu keiner bekannten Regel",
+        "failed": "Kontrollordner konnte nicht gelesen werden"
+      },
+      "messages": {
+        "reading": "Run-Status wird gelesen …",
+        "noControl": "Kein AGDF-Kontrollordner in „{folder}“.",
+        "noControlHint": "Geprüfter Projektordner: {path}",
+        "noOpenRuns": "Keine offenen Runs in diesem Projekt.",
+        "noRunAssigned": "Kein Run zugeordnet",
+        "noRunAssignedHint": "In dieser Sitzung hat sich kein Run geändert. Wähle einen offenen Run, um ihn hier zu zeigen.",
+        "unreadable": "Run-Status nicht lesbar: {reason}",
+        "stale": "Lesen um {time} fehlgeschlagen; angezeigt wird der Stand von {readAt}."
+      },
+      "origin": {
+        "session": "In dieser Sitzung geändert",
+        "selected": "Von dir ausgewählt",
+        "named": "Im Chat genannt"
+      },
+      "fields": {
+        "nextStep": "Nächster Schritt",
+        "objective": "Ziel",
+        "lastRead": "Stand {time}",
+        "openRuns": "{count} offene Runs",
+        "moreRuns": "+ {count} weitere",
+        "position": "{position} von {count} offenen Runs"
+      },
+      "actions": {
+        "retry": "Neu lesen",
+        "stillOn": "Bewegung aus",
+        "stillOff": "Bewegung an",
+        "noticeOff": "Meldung aus",
+        "noticeOn": "Meldung an",
+        "soundOn": "Ton an",
+        "soundOff": "Ton aus",
+        "expand": "Mehr",
+        "collapse": "Weniger",
+        "previous": "Vorheriger Run",
+        "next": "Nächster Run",
+        "about": "About",
+        "closeAbout": "Schließen",
+        "backToChat": "Zurück zum Chat-Run"
+      },
+      "about": {
+        "text": "Zeigt den Zustand deiner AGDF-Runs neben dem Chat. Nur lesend: Freigaben bleiben im Chat.",
+        "version": "AGDF-Plugin {version}"
+      },
+      "command": {
+        "description": "AGDF Companion ein- oder ausschalten",
+        "enabled": "AGDF Companion eingeschaltet.",
+        "disabled": "AGDF Companion ausgeschaltet.",
+        "waiting": "AGDF Companion ist eingeschaltet und wartet auf Platz: {reason}"
+      }
+    }
+  }
+}