create-agdf 0.30.0 → 0.31.0

package/generated/.opencode/contracts/request-activation.md

@@ -243,10 +243,13 @@ The requested effect, not discovery, decides AGDF activation.
 ### Delivery intent transport
 
 A delivery request without a confirmed run binding first dispatches gate-check with intake true
-and no run_id. Its resolve_delivery_run continuation supplies canonical UR scope evidence for the
+and neither run_id nor intake_mode; null or invented IDs are not substitutes. Its resolve_delivery_run continuation supplies canonical UR scope evidence for the
 coding agent's assignment. One unequivocal same-scope continuation uses resume, its run_id and
-expected_revision_id; a clear independent scope uses new and an unused `run-<original-operation-uuid>` ID even when unrelated
-runs exist. Single-run count, recency, shared files and ambient AGDF_RUN_ID prove no scope match.
+expected_revision_id. A clear independent scope follows the supplied new-Run operation even when
+unrelated Runs exist: MCP uses agdf_run/run.create, then its returned Run/revision and resume call.
+Never interpret intake_mode:new as MCP Run creation or invent an unused Run ID. The CLI fallback's
+prospective ID is derived only from its original run-create operation UUID.
+Single-run count, recency, shared files and ambient AGDF_RUN_ID prove no scope match.
 Overlapping plausible scopes require one question about the work, not a technical Run-ID choice.
 Incomplete inventory is a technical failure, never evidence for a new scope. Read-only requests omit intake and
 continue_delivery. On a bound run, continue_delivery requests the next canonical internal

package/generated/.opencode/contracts/sd-definition.md

@@ -33,6 +33,22 @@ PRD criterion exactly once to realization, authoritative owner, stable SDD IDs o
 and compatibility/risk. Never duplicate acceptance, invent scope/users or claim implementation.
 Retain actual sources/draft and a reasoned derivation review; structure alone is not semantic proof.
 
+Architecture Decisions use `SDD-...: decision; rationale: reason; consequence: trade-off`.
+Each bullet has one concrete decision statement, exactly one nonempty `rationale:` field and
+exactly one nonempty `consequence:` field (`trade-off:` is its alias, not an additional field).
+The readiness check distinguishes absent decision/rationale/consequence fields from unresolved
+author prompts and identifies the exact offending token and field. Quoted CLI syntax such as
+`done <id>` stays literal. An inline, parseable JSON object/array introduced immediately by
+`schema`, `JSON schema`, `schema example` or `JSON example` may use full quoted string values
+`"<uuid>"`, `"<string>"`, `"<non-empty string>"`, `"<number>"`, `"<integer>"`,
+`"<positive number>"`, `"<non-negative number>"`, `"<positive integer>"`,
+`"<non-negative integer>"`, `"<boolean>"`, `"<null>"`, `"<object>"` or `"<array>"`.
+This exception applies only to the decision clause, not type placeholders in JSON keys, arbitrary
+inline code, malformed JSON, or the rationale/consequence. Regular JSON keys such as `"todo"`
+are literal schema property names; angle-bracket prompts in keys remain unresolved.
+Unknown prompts such as `<choose encoding>`,
+`<why>`, `TBD` and `TODO` remain blockers; type notation cannot settle a material design choice.
+
 A decision that selects or changes a framework, library, external API, protocol, service or major
 version not already evidenced in the repository needs current authoritative sources through the
 host's available tools: official documentation/specification, release notes or migration guide of
@@ -60,8 +76,38 @@ A product-scope/acceptance conflict stays unresolved and returns to the earliest
 UR/PRD revision owner. Do not edit approved sources, invent a transition after downstream linking
 or manufacture answers; use supported revision/recovery and fresh source approval where required.
 
+### Realize brand-informed criteria
+
+For applicable design work, read the adopted PRD criteria together with the exact project brand
+source references retained by UX/PRD: path, version or content digest and relevant passages. Keep
+that source identity in the existing Ownership And Source Of Truth and Constraints And Compatibility
+sections and confirm the consumed version matches it. A framework example or another project's
+brand file cannot replace the selected source; brand context cannot silently expand approved
+product intent or acceptance.
+
+SD owns the concrete realization: design tokens, typography, layout, information hierarchy and
+controls. Record the relevant choices, reuse, rationale and trade-offs with the existing SDD IDs
+and map each approved criterion once through Acceptance Traceability. Preserve the approved
+perception and information priorities rather than inventing a parallel brand specification.
+
+In Test And Evidence Strategy, identify representative states, observable checks and the evidence
+needed to judge those criteria. Plan evidence for quality.md's UX Intent Fidelity matrix under the
+same PRD criterion IDs; its existing review owner produces that matrix at the appropriate stage.
+Add no second matrix, gate or automatic fidelity claim. A preview or source-file match is not
+implementation evidence or independent human acceptance. Non-applicable work requires no new brand
+file. Missing material design facts remain before_sd decisions below;
+product conflicts return to the existing PRD/UR revision owner.
+
 ## Explicit revision and recording
 
+A returned bound authoring continuation for an incomplete own unapproved draft already
+selects its correction route. Consume its authoring-inputs/material_call/recording_calls
+forms directly and use the supplied update_draft value. Do not dispatch this author again
+or add another intake for that same snapshot. The *_action revise route below is only for
+NEW editing intent on an already READY draft, and uses skill_id gate-check, never an author
+skill ID or a host skill alias. After saving, follow the returned continuation once.
+
+
 Before recording, use the continuation's resolved language and summary fields with
 gate-artifact-preparation's Language and approval summary preparation. A translated summary
 must be part of the draft before presentation, not deferred until a renderer failure.

package/generated/.opencode/contracts/tp-definition.md

@@ -69,6 +69,14 @@ not independent proof of human provenance. Table headings may use levels two thr
 
 ## Recording and revision
 
+A returned bound authoring continuation for an incomplete own unapproved draft already
+selects its correction route. Consume its authoring-inputs/material_call/recording_calls
+forms directly and use the supplied update_draft value. Do not dispatch this author again
+or add another intake for that same snapshot. The *_action revise route below is only for
+NEW editing intent on an already READY draft, and uses skill_id gate-check, never an author
+skill ID or a host skill alias. After saving, follow the returned continuation once.
+
+
 A ready draft without new editing intent is presented unchanged. Explicit ready-draft revision uses
 gate-check intake true, intake_mode resume, exact run_id/expected_revision_id and tp_action revise
 (CLI --tp-action revise), exclusive of other source actions and continue_delivery. Approved changes

package/generated/.opencode/contracts/ur-definition.md

@@ -42,7 +42,7 @@ For `phase: ur_definition`, use only the returned governance_target, run_id, rev
 template_path is the absolute, version-matched template owned by the installed plugin runtime.
 Repository copies under `.agdf/control/templates/` are derived scaffold references and never
 override this authoring source. Read the template without rewriting it; persist only artifact_path.
-A direct invocation first dispatches ur-definition; without a bound run follow the existing
+An already returned bound `ur_definition` continuation satisfies entry: consume its authoring inputs and writer forms directly. Do not repeat author dispatch or intake for that same snapshot. A direct invocation without such a continuation first dispatches ur-definition; without a bound run follow the existing
 resolve_delivery_run assignment, then gate-check intake/resume with its expected_revision_id.
 Never use AGDF_RUN_ID, cwd, discovery or a previous approval as authority. Missing, stale,
 foreign, invalid or approved bindings require fresh control routing; do not write.
@@ -104,7 +104,7 @@ follows its current-request language contract and does not change the artefact l
 
 Before recording a complete draft, when `approval_summary_required` is true, include exactly
 one `## <approval_summary_heading>` section using the supplied heading verbatim. Write a
-complete summary in the resolved presentation language covering problem, goal, affected users,
+complete summary in the resolved presentation language. Read `approval_summary_format.required_fields` from authoring-inputs: those exact list field declarations need concrete authored values; prose or a heading alone is not a named field. Cover problem, goal, affected users,
 scope, non-goals, acceptance signals, source ownership, risks/unknowns and next step.
 Do not truncate decision-relevant content or use ellipses. The existing approval renderer's
 limits and validation apply. This summary is editorial; the UR remains authoritative.
@@ -116,9 +116,13 @@ is required merely to complete an unapproved incomplete draft.
 
 A new draft is recorded through existing run-step --step ur --title <short title>, using
 --dir <governance_target> --run <run_id> --revision <revision_id>.
-For an already registered unapproved draft, require explicit user revision intent. Resume
-through gate-check with intake true, intake_mode resume, run_id, expected_revision_id and
-ur_action revise (CLI --ur-action revise). Ordinary intake of a ready draft still presents it.
+When this bound continuation returns a registered, incomplete unapproved draft, correct its
+readiness gaps directly through the supplied `ur_draft.replace` form. The existing authoring
+route already covers completing that same need; do not open another intake or dispatch.
+A deliberate change to an already READY registered draft outside that continuation still
+requires explicit user revision intent: enter via gate-check with intake true, intake_mode
+resume, run_id, expected_revision_id and ur_action revise (CLI --ur-action revise).
+Ordinary intake of a ready draft still presents it. Never substitute a field named revision.
 Stage the replacement and use ur_draft.replace with the current binding. The writer
 publishes the document and typed evidence atomically. Never edit bound bytes, reseal
 an unknown change or alter an approved UR or its approval.

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

@@ -63,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.
@@ -78,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.
@@ -137,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.

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

@@ -1,6 +1,6 @@
 {
   "name": "agdf",
-  "version": "0.30.0",
+  "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",

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

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

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

@@ -13,7 +13,7 @@ export const ACCESSORY_BOUNDS = Object.freeze({
   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,
+  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.
@@ -28,7 +28,7 @@ const BODY = Object.freeze({
   wartet: { fill: '#E0A030', stroke: '#9A6A12' },
   blockiert: { fill: '#D9534F', stroke: '#8F2D2A' },
   fertig: { fill: '#3FA66A', stroke: '#23663F' },
-  neutral: { fill: '#9AA3B2', stroke: '#5C6575' },
+  bereit: { fill: '#9AA3B2', stroke: '#5C6575' },
 });
 const INK = '#1F2430';
 
@@ -60,7 +60,7 @@ const MOUTH = Object.freeze({
   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"/>`,
+  bereit: `<path d="M73 97 h14" stroke="${INK}" stroke-width="3" stroke-linecap="round"/>`,
 });
 
 const MOTION = Object.freeze({
@@ -70,7 +70,7 @@ const MOTION = Object.freeze({
   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: '',
+  bereit: '',
 });
 
 // Drawn in region coordinates (0..48); ACCESSORY_BOUNDS states each extent.
@@ -108,7 +108,7 @@ function accessory(mood, isMoving) {
   return '';
 }
 
-// mood: one of the five moods or 'neutral' (no run assigned, status unreadable).
+// 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];
@@ -133,5 +133,5 @@ export const FIGURE_TEXT = Object.freeze({
   wartet: '(-_-) ⧗',
   blockiert: '(x_x) !',
   fertig: '(^_^) ✓',
-  neutral: '(·_·)',
+  bereit: '(·_·)',
 });

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

@@ -1,41 +1,23 @@
 // 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.
+// 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: '○' });
-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']);
+// 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']);
-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 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(path.indexOf('QA'), 0, { gate: BUILD_MARK, mark: build });
+  marks.splice(qa, 0, { gate: BUILD_MARK, mark: build });
   return marks;
 }
 

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

@@ -1,8 +1,7 @@
-// Localization (SDD-05, AC-005) with the existing AGDF data: the chat language from config.json,
-// gate titles and next-step values from meta/agdf-interaction-locales.json (the registry), and the
-// companion's own labels from companion/locales.json. Mirrors resolveConfiguredChatLanguage
-// (packages/core/lib/resources/context.js) and localizedOperationalValue
-// (packages/core/lib/interaction-presentation.js); parity tests keep them equal.
+// 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;
 
@@ -25,7 +24,7 @@ export function resolveLocale(registry, requested) {
 }
 
 // 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 companion's locales.json, compared without case;
+// 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() : '';
@@ -34,7 +33,7 @@ export function settingLocale(registry, labels, value) {
   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] && (pack.languageNames ?? []).some(entry => entry.toLowerCase() === name));
+    .find(([locale, pack]) => registry.locales[locale] && Object.values(pack.languageNames ?? {}).some(entry => String(entry).toLowerCase() === name));
   return match?.[0] ?? null;
 }
 
@@ -53,31 +52,10 @@ export function gateTitle(registry, locale, gate) {
   return registry.locales[locale]?.gateTitles?.[gate] ?? registry.locales[registry.fallbackLocale]?.gateTitles?.[gate] ?? gate;
 }
 
-// The localized status-card value for a next-step source text, or the source text itself
-// ({ text, isLocalized }); an empty or "none" value becomes the pack's "none".
-export function localizeNextStep(registry, locale, value) {
-  const source = String(value ?? '').trim();
-  const pack = registry.locales[locale];
-  const fallback = registry.locales[registry.fallbackLocale];
-  if (!source || source === 'none') return { text: pack.primary.none, isLocalized: true };
-  if (locale === registry.fallbackLocale) return { text: source, isLocalized: true };
-  const groups = [
-    [fallback.operationalValues, pack.operationalValues],
-    [fallback.primary.actions, pack.primary.actions],
-    [fallback.primary.afterApproval, pack.primary.afterApproval],
-  ];
-  for (const [sources, targets] of groups) {
-    for (const [key, text] of Object.entries(sources ?? {})) {
-      if (text === source) {
-        const localized = String(targets?.[key] ?? '').trim();
-        return localized ? { text: localized, isLocalized: true } : { text: source, isLocalized: false };
-      }
-    }
-  }
-  if (fallback.primary.quality === source && String(pack.primary.quality ?? '').trim()) {
-    return { text: pack.primary.quality.trim(), isLocalized: true };
-  }
-  return { text: source, isLocalized: false };
+// 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

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

@@ -14,12 +14,13 @@ const NOTICE_MOODS = new Set(['wartet', 'blockiert']);
 // mention: the chat's named run (chat-run navigation SDD-06); browsing never changes what is observed.
 export function observedRun({ snapshot, sessionStartedAt, selection = null, mention = null }) {
   if (!snapshot) return { kind: 'idle' };
-  if (snapshot.status === 'failed') return { kind: 'unreadable' };
+  if (snapshot.status === 'failed' || snapshot.status === 'unavailable') return { kind: 'unreadable' };
   if (snapshot.status !== 'ok') return { kind: 'idle' };
   const { run } = assignRun({ runs: snapshot.runs, sessionStartedAt, selection, mention });
   if (!run) return selection && snapshot.unreadable.some(item => item.id === selection) ? { kind: 'unreadable' } : { kind: 'idle' };
-  const state = runState(run);
-  return state.mood === null ? { kind: 'unreadable' } : { kind: 'run', runId: run.id, state };
+  const figure = runState(run);
+  // The blocking text arrives localized in the run view; the signature keeps the code.
+  return { kind: 'run', runId: run.id, state: { ...figure, reason: { ...figure.reason, decisionText: run.blockingText || undefined } } };
 }
 
 const signature = ({ mood, reason }) => [mood, reason.key, reason.gate ?? '', reason.decision ?? ''].join('|');
@@ -35,11 +36,12 @@ export function observeNotice(previous, observed) {
   return { observation, notice: changed && NOTICE_MOODS.has(observed.state.mood) ? observed.state : null };
 }
 
-// The toast for a notice, e.g. "<run> wartet auf Freigabe: Qualitätssicherung".
-export function noticeText(runId, state, { registry, labels, locale }) {
+// The toast for a notice, e.g. "Wartet auf Freigabe: Qualitätssicherung". A notice always concerns
+// the run the status line follows, so it names no run (owner request of 2026-11-06, T-013).
+export function noticeText(state, { registry, labels, locale }) {
   const t = (path, params) => label(labels, locale, path, params);
-  const params = { run: runId, gate: gateTitle(registry, locale, state.reason.gate) };
-  if (state.reason.decision) params.decision = t(`decisions.${state.reason.decision}`);
+  const params = { gate: gateTitle(registry, locale, state.reason.gate) };
+  if (state.reason.decision) params.decision = state.reason.decisionText ?? state.reason.decision;
   return t(`notices.${state.reason.key}`, params);
 }
 
@@ -47,7 +49,7 @@ export function noticeText(runId, state, { registry, labels, locale }) {
 export function statusText(observed, { labels, locale }) {
   const t = path => label(labels, locale, path);
   if (observed.kind === 'unreadable') return `AGDF · ${t('statusStates.unreadable')}`;
-  if (observed.kind !== 'run') return `AGDF · ${t('statusStates.neutral')}`;
+  if (observed.kind !== 'run') return `AGDF · ${t('statusStates.bereit')}`;
   const { mood, reason } = observed.state;
   return mood === 'fertig' || !reason.gate ? `AGDF · ${t(`statusStates.${mood}`)}` : `AGDF · ${reason.gate} · ${t(`statusStates.${mood}`)}`;
 }