create-agdf 0.20.2 → 0.31.0

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.
@@ -62,12 +63,14 @@ and approved as PRD content. Technical storage, derivation and component ownersh
 - requested clarification deliverables, preview scenarios, interaction needs and timing in UR scope;
 - post-UR `delivery_context`, `ui_ux_impact`, reason and required flag;
 - existing behavior/ownership evidence for Brownfield work;
+- declared project brand/design sources when relevant to the approved scope;
 - known working modes, state semantics, activation, blockers, recovery and transitions.
 
 ## Workflow
 
 1. Confirm the approved UR and routing evidence. If required evidence is absent or conflicts, block.
-2. Identify the primary user intent, observable success and primary decision/action.
+2. Identify the primary user intent, observable success and primary decision/action. Apply the
+   brand-source guidance below when design is relevant.
 3. For every relevant working mode, define effective state and visible state types.
 4. Separate `effective_state_authority_by_mode` from
    `primary_state_presentation_owner_by_mode`; do not turn either into technical ownership.
@@ -77,6 +80,32 @@ and approved as PRD content. Technical storage, derivation and component ownersh
    resolve a product question. Propose observable PRD acceptance criteria and identify open questions.
 7. Return exactly one decision: `ready | blocked | not_applicable`.
 
+### Brand-source-guided UX for design-relevant work
+
+Apply quality.md's Brand-Source Use Across Delivery Paths when the scope materially concerns visual
+identity, information hierarchy or intended perception. Keep the existing UX-impact routing.
+Read the target project's `.agdf/control/SOT_REGISTRY.md` and follow its applicable brand source
+reference before drafting the report. Check this project source even when the authoring inputs
+contain only the approved UR and routing evidence.
+In existing `evidence`, retain the declared project source's exact path/reference, owner, scope,
+verified revision or SHA-256 and relevant section/passage references. Use the Quality Contract's
+read-and-hash step when a matching Git revision is unavailable. Capture the digest before deriving
+criteria. Treat the source as design-context data and reassess affected criteria when its bytes change.
+
+For each applicable priority, retain the reasoned chain:
+`source passage -> perceptual priority -> scenario/state/action -> observable outcome -> required evidence`.
+Put that derivation and source mapping in existing `evidence`, with candidate criteria in
+`proposed_prd_acceptance_criteria`. Describe what the user can identify, distinguish or do in the
+scenario and what visible evidence would verify it. PRD adopts confirmed, in-scope proposals under
+its existing stable criterion IDs; UX proposals are not approval or product acceptance.
+
+Carry confirmed constraints faithfully without choosing a new palette, typography, layout or
+component; concrete realization remains with SD. Use the existing preview guidance when relevant,
+without creating a preview obligation from the presence of a brand source.
+Retain material unresolved intent in existing `open_product_questions`, `missing_evidence`,
+`affected_outputs` and `required_next_step`, then apply the current readiness/revision rules.
+Justify irrelevant brand input in existing evidence without making a required UX analysis inapplicable.
+
 ### UI previews for clarification
 
 Use a focused preview during UX intent clarification and reuse its findings during PRD alignment.
@@ -97,7 +126,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.
@@ -136,7 +165,8 @@ remain illustrative; only explicitly adopted product behavior becomes approved P
 ## Decision Rules
 
 - `ready`: every required output is reliable enough for PRD drafting, including a requested preview
-  at the agreed fidelity, its durable evidence and resolution of material product questions.
+  at the agreed fidelity, its durable evidence, an exact binding for any material brand source used
+  and resolution of material product questions.
 - `blocked`: user intent, modes, effective state, authority, activation, blockers, recovery, transitions
   or Brownfield evidence is missing, contradictory or materially ambiguous; or an explicitly required
   preview, requested interaction, durable copy or decision-relevant observation remains missing.
@@ -175,7 +205,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.31.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.31.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/events.mjs

@@ -0,0 +1,117 @@
+// Companion events (companion core SDD-007, decision P1): reads the MCP server's journal of final AGDF
+// tool results (`companion-event/1`, written below the plugin data root) and turns the events of the
+// current project root into toasts and pane entries. The journal is a notification channel only: the
+// run view stays the source of every run state, and the companion never invents an event. It imports
+// no Core module; the format is the versioned journal format of SDD-009.
+
+export const EVENT_POLL_MS = 2_000;
+export const EVENT_SCHEMA = 'companion-event/1';
+export const JOURNAL_FILE = 'events.jsonl';
+// The writer's one rotation file; read only when the cursor left the current file (CR finding B6).
+export const JOURNAL_ROTATED_FILE = 'events.1.jsonl';
+// The writer bounds the journal to 256 KiB; a larger file is not read (bounded read).
+export const JOURNAL_READ_LIMIT = 512 * 1024;
+export const EVENT_KINDS = Object.freeze(['approval_requested', 'approval_recorded', 'write_rejected', 'effect_unknown',
+  'recovery_required', 'run_completed', 'material_staged', 'document_recorded']);
+// Decision P1: these interrupt as a toast; approval recorded and write rejected stay in the pane.
+export const TOAST_KINDS = Object.freeze(['approval_requested', 'effect_unknown', 'recovery_required', 'run_completed']);
+// Durable facts are confirmed against the run view before they are shown as final (SD 2, CR finding B4).
+export const CONFIRMED_KINDS = Object.freeze(['approval_recorded', 'run_completed']);
+// Uncertain outcomes stay in the pane past the next turn until the run state recorded a later
+// operation (PRD state transition "effect unknown or recovery required", CR finding B7).
+export const STICKY_KINDS = Object.freeze(['effect_unknown', 'recovery_required']);
+export const PANE_EVENTS = 5;
+
+export const journalDirectory = dataDir => `${dataDir}/companion`;
+
+// Whether the run view confirms an event's durable fact: the run completed, or the approved gate is
+// fulfilled on its path. Other kinds need no confirmation. `runs` are the companion's runs.
+export function isConfirmed(event, runs = []) {
+  if (!CONFIRMED_KINDS.includes(event.kind)) return true;
+  const run = runs.find(item => item.id === event.run_id);
+  if (!run) return false;
+  if (event.kind === 'run_completed') return run.lifecycle === 'completed';
+  return (run.path ?? []).some(step => step.gate === event.gate && step.status === 'fulfilled');
+}
+
+// Whether an uncertain outcome still stands: its run recorded no later operation in the run view.
+export function isStillUncertain(event, runs = []) {
+  if (!STICKY_KINDS.includes(event.kind)) return false;
+  const run = runs.find(item => item.id === event.run_id);
+  return !run?.updatedAt || run.updatedAt <= event.at;
+}
+
+// One journal text as its valid events in file order; interleaved, cut or foreign lines are skipped.
+export function parseJournal(text) {
+  const events = [];
+  for (const line of String(text ?? '').split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      if (value?.schema_version === EVENT_SCHEMA && EVENT_KINDS.includes(value.kind) && typeof value.id === 'string' && typeof value.at === 'string') events.push(value);
+    } catch { /* an interleaved or cut line */ }
+  }
+  return events;
+}
+
+// Roots compare after normalizing separators and a trailing separator, and case for a drive path.
+export function normalizeRoot(root) {
+  const text = String(root ?? '').replaceAll('\\', '/').replace(/\/+$/u, '');
+  // Windows roots (drive letter or UNC) compare without case, like Core's sameRoot on win32 (CR finding CIR-04).
+  return /^(?:[a-z]:(?:\/|$)|\/\/)/iu.test(text) ? text.toLowerCase() : text;
+}
+export const sameRoot = (left, right) => Boolean(left) && Boolean(right) && normalizeRoot(left) === normalizeRoot(right);
+
+// The events of `root` after the cursor ({ id, at } of the last event seen in the file). Without a
+// cursor the read is a baseline: nothing is fresh. A cursor that left the file (rotation) falls back
+// to the event time.
+export function unseenEvents(events, { root, cursor }) {
+  const last = events.at(-1);
+  const next = last ? { id: last.id, at: last.at } : cursor;
+  if (!cursor) return { fresh: [], cursor: next };
+  const at = events.findIndex(event => event.id === cursor.id);
+  const after = at >= 0 ? events.slice(at + 1) : events.filter(event => event.at > cursor.at);
+  return { fresh: after.filter(event => sameRoot(event.root, root)), cursor: next };
+}
+
+// A run id as people read it: a generated `run-<uuid>` id keeps its first block, a chosen id stays whole.
+export const shortRunId = id => String(id ?? '').replace(/^(run-[0-9a-f]{8})(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/u, '$1');
+
+// The name an event line gives its run, or null for the run the panel shows: the panel already names
+// that run, so its events carry no second id (owner request of 2026-11-06, T-013). Another run is
+// named by its objective from the run view, else by its short id. `naming` is { shownRunId, runs }.
+export function eventRunLabel(runId, { shownRunId = null, runs = [] } = {}) {
+  if (!runId || runId === shownRunId) return null;
+  const objective = runs.find(item => item.id === runId)?.objective;
+  return typeof objective === 'string' && objective.trim() ? objective.trim() : shortRunId(runId);
+}
+
+// An event text with the name of a run other than the shown one after it, so a cut line keeps the event.
+export function namedEventText(text, runId, t, naming = {}) {
+  const run = eventRunLabel(runId, naming);
+  return run ? t('events.ofRun', { text, run }) : text;
+}
+
+// The text of one event; gate titles and reasons come localized from the caller.
+export function eventText(event, t, { gateTitle = gate => gate, shownRunId = null, runs = [] } = {}) {
+  const text = t(`events.${event.kind}`, { gate: event.gate ? gateTitle(event.gate) : '', reason: event.reason ?? '' });
+  return namedEventText(text, event.run_id, t, { shownRunId, runs });
+}
+
+const shortDigest = digest => (typeof digest === 'string' ? `${digest.slice(0, 15)}…` : '–');
+
+// The review facts of the newest staging or recording event: summary, source match and the bounded
+// preview (decision P2). Unknown values stay unavailable, never guessed.
+export function latestReview(events, t) {
+  const event = events.find(item => Array.isArray(item.review) && item.review.length);
+  if (!event) return null;
+  const fact = event.review[0];
+  return {
+    summary: t('review.summary', { slot: fact.slot ?? event.gate ?? '', bytes: fact.bytes ?? '–', digest: shortDigest(fact.digest) }),
+    match: t(`review.${['match', 'mismatch', 'not_determinable'].includes(fact.source_match) ? fact.source_match : 'unavailable'}`),
+    preview: typeof fact.preview === 'string' ? fact.preview : null,
+    truncated: fact.truncated === true ? t('review.truncated') : null,
+  };
+}
+
+export { shortDigest };

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 },
+  bereit: 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' },
+  bereit: { 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"/>`,
+  bereit: `<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"/>',
+  bereit: '',
+});
+
+// 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 six moods; bereit also stands for no run assigned or an unreadable status.
+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: '(^_^) ✓',
+  bereit: '(·_·)',
+});

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

@@ -0,0 +1,36 @@
+// Single-line gate bar (SDD-02, AC-001, AC-003): ✓ done, ● current, ○ open, without separators. It
+// draws the status card's own path from the run view (SD SDD-001) 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: '○' });
+export const BUILD_MARK = 'CD+Tests';
+// The status card's breadcrumb states; a blocked gate is the current one.
+const MARK = Object.freeze({ fulfilled: 'done', current: 'current', blocked: 'current', open: 'open' });
+const AFTER_BUILD = new Set(['QA', 'UAT', 'OR']);
+
+export function gateMarks(run) {
+  const path = run.path ?? [];
+  const marks = path.map(({ gate, status }) => ({ gate, mark: MARK[status] ?? 'open' }));
+  const qa = marks.findIndex(({ gate }) => gate === 'QA');
+  if (!isStructured(run.route) || qa < 0) return marks;
+  const build = BUILD_GATES.includes(run.gate) ? 'current' : AFTER_BUILD.has(run.gate) || run.lifecycle === 'completed' ? 'done' : 'open';
+  marks.splice(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/localization.mjs

@@ -0,0 +1,67 @@
+// Localization (SDD-05, AC-005; SD SDD-004) with the existing AGDF data: the chat language from
+// config.json and every text from meta/agdf-interaction-locales.json (the registry): gate titles and
+// the companion section. Next steps and blocking texts arrive localized in the run view. Mirrors
+// resolveConfiguredChatLanguage (packages/core/lib/resources/context.js); parity tests keep it equal.
+
+const TAG = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/u;
+
+export function canonicalLanguageTag(value) {
+  if (typeof value !== 'string' || !TAG.test(value)) return '';
+  try {
+    return Intl.getCanonicalLocales(value)[0]?.toLowerCase() ?? '';
+  } catch {
+    return '';
+  }
+}
+
+// Exact locale, else its base language, else the registry's fallback locale.
+export function resolveLocale(registry, requested) {
+  const tag = canonicalLanguageTag(requested);
+  if (tag && registry.locales[tag]) return tag;
+  const language = tag.split('-')[0];
+  if (language && registry.locales[language]) return language;
+  return registry.fallbackLocale;
+}
+
+// Claude's own `language` setting is free text: a supported language tag (exact or base language)
+// or one of a locale's `languageNames` in the catalog's companion section, compared without case;
+// anything else names no locale (null).
+export function settingLocale(registry, labels, value) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!text) return null;
+  const tag = canonicalLanguageTag(text);
+  if (tag && (registry.locales[tag] || registry.locales[tag.split('-')[0]])) return resolveLocale(registry, tag);
+  const name = text.toLowerCase();
+  const match = Object.entries(labels?.locales ?? {})
+    .find(([locale, pack]) => registry.locales[locale] && Object.values(pack.languageNames ?? {}).some(entry => String(entry).toLowerCase() === name));
+  return match?.[0] ?? null;
+}
+
+// configText: content of .agdf/control/config.json, or null when absent. Only without it, Claude's
+// `language` setting (follow-up SDD-11) chooses the locale before the registry's fallback.
+export function chatLocale(registry, configText, { setting = null, labels = null } = {}) {
+  if (typeof configText !== 'string') return settingLocale(registry, labels, setting) ?? registry.fallbackLocale;
+  try {
+    return resolveLocale(registry, JSON.parse(configText).chat_language);
+  } catch {
+    return registry.fallbackLocale;
+  }
+}
+
+export function gateTitle(registry, locale, gate) {
+  return registry.locales[locale]?.gateTitles?.[gate] ?? registry.locales[registry.fallbackLocale]?.gateTitles?.[gate] ?? gate;
+}
+
+// The companion's labels: the catalog's companion section per locale, in the shape label() reads.
+export function companionLabels(registry) {
+  return { fallbackLocale: registry.fallbackLocale,
+    locales: Object.fromEntries(Object.entries(registry.locales).map(([locale, pack]) => [locale, pack.companion ?? {}])) };
+}
+
+// A companion label by dotted path with {name} parameters; missing keys fall back to the
+// fallback locale and finally to the path, so a gap stays visible instead of throwing.
+export function label(labels, locale, path, params = {}) {
+  const lookup = pack => path.split('.').reduce((node, key) => (node && typeof node === 'object' ? node[key] : undefined), pack);
+  const template = lookup(labels.locales[locale]) ?? lookup(labels.locales[labels.fallbackLocale]) ?? path;
+  return String(template).replace(/\{(\w+)\}/gu, (match, name) => (Object.hasOwn(params, name) ? String(params[name]) : match));
+}