create-agdf 0.20.1 → 0.30.0

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}"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,89 @@
+// 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.
+
+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 companion's locales.json, 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] && (pack.languageNames ?? []).some(entry => 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 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 };
+}
+
+// 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));
+}

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

@@ -0,0 +1,90 @@
+// Feedback outside the pane (SDD-05 to SDD-07, AC-004 to AC-006): the shown run as the toast and the
+// status line see it, the transition detector, their texts and the generated chime. Judged on the
+// run-derived state, never on the turn overlay, so a turn neither flips the status line nor raises a
+// toast. Host-independent; the adapter shows the results.
+
+import { assignRun } from './assignment.mjs';
+import { gateTitle, label } from './localization.mjs';
+import { runState } from './state.mjs';
+
+const NOTICE_MOODS = new Set(['wartet', 'blockiert']);
+
+// What the status line and the detector observe: { kind: 'run', runId, state } with the run-derived
+// state, { kind: 'unreadable' } or { kind: 'idle' } (nothing read yet, no control, no shown run).
+// 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 !== '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 signature = ({ mood, reason }) => [mood, reason.key, reason.gate ?? '', reason.decision ?? ''].join('|');
+
+// previous: the last observation { runId, signature } or null. A notice is due only when the same
+// run's state changed and is now wartet or blockiert; the first observation of a run is a baseline.
+// An unreadable state keeps the last observation, so a read in between announces nothing twice.
+export function observeNotice(previous, observed) {
+  if (observed.kind === 'unreadable') return { observation: previous, notice: null };
+  if (observed.kind !== 'run') return { observation: null, notice: null };
+  const observation = { runId: observed.runId, signature: signature(observed.state) };
+  const changed = previous?.runId === observed.runId && previous.signature !== observation.signature;
+  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 }) {
+  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}`);
+  return t(`notices.${state.reason.key}`, params);
+}
+
+// The status line, e.g. "AGDF · QA · wartet"; a completed run names no gate.
+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')}`;
+  const { mood, reason } = observed.state;
+  return mood === 'fertig' || !reason.gate ? `AGDF · ${t(`statusStates.${mood}`)}` : `AGDF · ${reason.gate} · ${t(`statusStates.${mood}`)}`;
+}
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function base64(bytes) {
+  let out = '';
+  for (let i = 0; i < bytes.length; i += 3) {
+    const n = (bytes[i] << 16) | ((bytes[i + 1] ?? 0) << 8) | (bytes[i + 2] ?? 0);
+    out += ALPHABET[(n >> 18) & 63] + ALPHABET[(n >> 12) & 63]
+      + (i + 1 < bytes.length ? ALPHABET[(n >> 6) & 63] : '=') + (i + 2 < bytes.length ? ALPHABET[n & 63] : '=');
+  }
+  return out;
+}
+
+// A soft two-note chime (0.3 s) as 8 kHz, 8-bit unsigned mono PCM in a RIFF/WAVE container, so no
+// audio file ships in the plugin. Hosts without a player skip it (SDD-06).
+export const CHIME = Object.freeze({ rate: 8000, notes: Object.freeze([[880, 0.12], [1320, 0.18]]), gain: 0.35 });
+let chime = null;
+export function chimeClip() {
+  if (chime) return chime;
+  const samples = [];
+  for (const [frequency, seconds] of CHIME.notes) {
+    const count = Math.round(CHIME.rate * seconds);
+    for (let i = 0; i < count; i += 1) {
+      const envelope = Math.min(1, i / 80, (count - i) / 400);
+      samples.push(Math.round(128 + 60 * envelope * Math.sin((2 * Math.PI * frequency * i) / CHIME.rate)));
+    }
+  }
+  const bytes = new Uint8Array(44 + samples.length);
+  const view = new DataView(bytes.buffer);
+  const ascii = (offset, text) => { for (let i = 0; i < text.length; i += 1) bytes[offset + i] = text.charCodeAt(i); };
+  ascii(0, 'RIFF'); view.setUint32(4, 36 + samples.length, true); ascii(8, 'WAVE');
+  ascii(12, 'fmt '); view.setUint32(16, 16, true); view.setUint16(20, 1, true); view.setUint16(22, 1, true);
+  view.setUint32(24, CHIME.rate, true); view.setUint32(28, CHIME.rate, true); view.setUint16(32, 1, true); view.setUint16(34, 8, true);
+  ascii(36, 'data'); view.setUint32(40, samples.length, true);
+  bytes.set(samples, 44);
+  chime = Object.freeze({ base64: base64(bytes), mime: 'audio/wav' });
+  return chime;
+}

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

@@ -0,0 +1,36 @@
+// The persisted user choices (SDD-07; follow-up SDD-09): one JSON file in the AGDF plugin data
+// directory, which `claude plugin uninstall` removes; never `$.store`, which Claude keeps after
+// uninstall (T-001). Toasts default on and their sound off; a state file without these fields, as
+// the first companion version wrote it, reads with those defaults. Host-independent: the adapter
+// supplies the environment values and file access.
+
+export const STATE_FILE = 'companion-state.json';
+const PLUGIN_ID = 'agdf@agdf';
+const DEFAULT_STATE = Object.freeze({ enabled: false, still: false, notice: true, sound: false, selections: Object.freeze({}) });
+
+// Mirrors claudePluginDataRoot (packages/cli/lib/mcp-lifecycle/plugin-runtime.js): the plugin id with
+// every character outside [A-Za-z0-9_-] replaced by "-" below <config dir>/plugins/data.
+export function pluginDataDir({ configDir, userProfile, home }, pluginId = PLUGIN_ID) {
+  const base = configDir || (userProfile || home ? `${userProfile || home}/.claude` : '');
+  return base ? `${base.replace(/[\\/]+$/u, '')}/plugins/data/${pluginId.replace(/[^A-Za-z0-9_-]/gu, '-')}` : null;
+}
+
+// Invalid or foreign content reads as fresh, mutable defaults; selections map project roots to run ids.
+export function parseCompanionState(text) {
+  try {
+    const value = JSON.parse(text);
+    if (!value || value.schema_version !== 1) return defaultCompanionState();
+    const selections = {};
+    for (const [root, runId] of Object.entries(value.selections ?? {})) {
+      if (typeof root === 'string' && typeof runId === 'string' && /^[A-Za-z0-9._-]{1,200}$/u.test(runId)) selections[root] = runId;
+    }
+    return { enabled: value.enabled === true, still: value.still === true, notice: value.notice !== false, sound: value.sound === true, selections };
+  } catch {
+    return defaultCompanionState();
+  }
+}
+
+export const serializeCompanionState = ({ enabled, still, notice, sound, selections }) =>
+  `${JSON.stringify({ schema_version: 1, enabled: Boolean(enabled), still: Boolean(still), notice: notice !== false, sound: Boolean(sound), selections: { ...selections } }, null, 2)}\n`;
+
+export const defaultCompanionState = () => ({ ...DEFAULT_STATE, selections: {} });