create-agdf 0.8.0 → 0.8.2

package/bin/create-agdf.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, posix, relative, resolve } from "node:path";
@@ -25,12 +25,24 @@ import {
   parseControlState,
   verifyLegacyProjection,
 } from "../lib/control-state/index.js";
+import {
+  buildArtefactRefs,
+  buildRunCandidates,
+  canonicalizeLanguageTag,
+  formatArtefactRefs,
+  gateTitle,
+  localePack,
+  resolveHumanRunTitle,
+  resolvePresentationLocale,
+} from "../lib/interaction-presentation.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(__dirname, "..");
 const generatedRoot = join(packageRoot, "generated");
 const pluginDefinitionPath = join(generatedRoot, "plugins", "agdf", "meta", "agdf-plugin.definition.json");
 const pluginDefinition = JSON.parse(readFileSync(pluginDefinitionPath, "utf8"));
+const interactionLocalesPath = join(generatedRoot, "plugins", "agdf", "meta", "agdf-interaction-locales.json");
+const interactionLocales = JSON.parse(readFileSync(interactionLocalesPath, "utf8"));
 const pluginInstallCommand = "npx --yes @agdf/cli@latest claude";
 const testNpmCliPath = process.env.NODE_ENV === "test" ? process.env.AGDF_TEST_NPM_CLI_PATH || "" : "";
 const npmCommand = testNpmCliPath
@@ -221,9 +233,9 @@ Backward-compatible create-agdf usage:
 Options:
   --dir <path>   Write files into a specific directory. With opencode, use this as the OpenCode config directory.
   --force        Overwrite existing generated files
-  --language <de|en>
+  --language <tag>
                  Set AGDF chat and artefact language. Defaults to detected system locale.
-  --lang <de|en> Alias for --language
+  --lang <tag>   Alias for --language
   --json         Print machine-readable command output as JSON
   --status-card  Print compact gate-check status-card output for interactive use
   --run <run_id> Select one canonical run
@@ -246,11 +258,17 @@ Options:
 }
 
 function normalizeLanguage(value) {
-  const normalized = String(value ?? "").trim().toLowerCase().replace("_", "-");
+  return canonicalizeLanguageTag(value);
+}
+
+function configuredLanguage(value) {
+  const normalized = normalizeLanguage(value);
   if (!normalized) return "";
-  if (normalized.startsWith("de")) return "de";
-  if (normalized.startsWith("en")) return "en";
-  return "";
+  const language = normalized.split("-")[0];
+  if (interactionLocales.locales[normalized] || interactionLocales.locales[language]) {
+    return resolvePresentationLocale(interactionLocales, normalized);
+  }
+  return normalized;
 }
 
 function detectSystemLocale() {
@@ -264,7 +282,7 @@ function detectSystemLocale() {
 }
 
 function resolveLanguagePreference(explicitLanguage) {
-  const explicit = normalizeLanguage(explicitLanguage);
+  const explicit = configuredLanguage(explicitLanguage);
   if (explicit) {
     return {
       artifact_language: explicit,
@@ -276,7 +294,7 @@ function resolveLanguagePreference(explicitLanguage) {
   }
 
   const detectedLocale = detectSystemLocale();
-  const detected = normalizeLanguage(detectedLocale) || "en";
+  const detected = configuredLanguage(detectedLocale) || interactionLocales.fallbackLocale;
   return {
     artifact_language: detected,
     chat_language: detected,
@@ -288,12 +306,12 @@ function resolveLanguagePreference(explicitLanguage) {
 
 function resolveConfiguredChatLanguage(targetDir) {
   const configPath = join(targetDir, ".agdf", "control", "config.json");
-  if (!existsSync(configPath)) return "en";
+  if (!existsSync(configPath)) return interactionLocales.fallbackLocale;
   try {
     const config = JSON.parse(readFileSync(configPath, "utf8"));
-    return normalizeLanguage(config.chat_language) || "en";
+    return resolvePresentationLocale(interactionLocales, config.chat_language);
   } catch {
-    return "en";
+    return interactionLocales.fallbackLocale;
   }
 }
 
@@ -414,9 +432,9 @@ function parseArgs(argv) {
         console.error(`Missing value for ${arg}`);
         process.exit(1);
       }
-      const normalized = normalizeLanguage(next);
+      const normalized = configuredLanguage(next);
       if (!normalized) {
-        console.error("Unsupported language. Use --language de or --language en.");
+        console.error("Invalid language tag. Use a BCP 47 tag such as de, en or fr-CA.");
         process.exit(1);
       }
       language = normalized;
@@ -1899,6 +1917,7 @@ function readRunState(targetDir, selection = {}) {
   let runPath = join(".agdf", "control", "AGDF_RUN.md");
   const canonicalRoot = join(targetDir, ".agdf", "control", "runs");
   let resolutionError;
+  let candidateRuns = [];
   if (existsSync(canonicalRoot)) {
     try {
       const selected = resolveRuns(targetDir, {
@@ -1910,6 +1929,21 @@ function readRunState(targetDir, selection = {}) {
         : selected.run.path;
     } catch (error) {
       resolutionError = error.message;
+      if (resolutionError.startsWith("AGDF_ACTIVE_RUN_AMBIGUOUS")) {
+        const active = resolveRuns(targetDir, { allActive: true }).runs.map((run) => {
+          const controlState = parseControlState(run.content, {
+            userGates: userGateOrder,
+            internalSteps: [...internalStepArtefacts],
+          });
+          return {
+            ...run,
+            control_state: controlState,
+            current_artefact_heading: readArtefactHeading(targetDir, controlState.artefacts.get(controlState.current_gate)),
+            ur_heading: readArtefactHeading(targetDir, controlState.artefacts.get("UR")),
+          };
+        });
+        candidateRuns = buildRunCandidates(active);
+      }
     }
   }
   if (resolutionError || !existsSync(join(targetDir, runPath))) {
@@ -1929,6 +1963,7 @@ function readRunState(targetDir, selection = {}) {
       quality_outlook: "",
       source_scope: {},
       memory: {},
+      candidate_runs: candidateRuns,
       resolution_error: resolutionError,
     };
   }
@@ -2246,6 +2281,48 @@ function buildStatusCard({
   };
 }
 
+function resolvedArtefactFile(targetDir, rawPath) {
+  const normalizedPath = String(rawPath ?? "").replace(/^`|`$/g, "").trim();
+  if (!normalizedPath || isAbsolute(normalizedPath) || normalizedPath.includes("<") || normalizedPath.includes(">")) return "";
+  const absolutePath = resolve(targetDir, normalizedPath);
+  if (relative(targetDir, absolutePath).startsWith("..") || !existsSync(absolutePath)) return "";
+  try {
+    const realPath = realpathSync(absolutePath);
+    return relative(realpathSync(targetDir), realPath).startsWith("..") || !statSync(realPath).isFile() ? "" : realPath;
+  } catch {
+    return "";
+  }
+}
+
+function readArtefactHeading(targetDir, artefact) {
+  const artefactPath = resolvedArtefactFile(targetDir, artefact?.path);
+  if (!artefactPath) return "";
+  try {
+    return readFileSync(artefactPath, "utf8").match(/^#\s+(.+)$/m)?.[1]?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+
+function buildHumanPresentation(targetDir, runState, currentGate, presentationLocale) {
+  const currentArtefactHeading = readArtefactHeading(targetDir, runState.artefacts.get(currentGate));
+  const urHeading = readArtefactHeading(targetDir, runState.artefacts.get("UR"));
+  return {
+    runTitle: resolveHumanRunTitle({
+      currentArtefactHeading,
+      urHeading,
+      runContent: runState.content,
+      runId: extractField(runState.content ?? "", "run_id") || "unknown",
+    }),
+    gateTitle: gateTitle(interactionLocales, presentationLocale, currentGate),
+    artefactRefs: buildArtefactRefs(runState.artefacts, interactionLocales, presentationLocale, {
+      pathExists(path) {
+        return Boolean(resolvedArtefactFile(targetDir, path));
+      },
+    }),
+  };
+}
+
 function durableArtefactBlock(gate, nextGate) {
   const label = gate === "QA" ? "QA report" : `${gate} artefact`;
   const stablePath = gate === "QA" ? ".agdf/control/artefacts/<key>/QA_REPORT.md" : `.agdf/control/artefacts/<key>/${gate}.md`;
@@ -2274,6 +2351,10 @@ function isGateSatisfied(runState, gate) {
   return isDurableGateArtefactSatisfied(runState, gate);
 }
 
+function qaRevisionRequired(runState) {
+  return gateArtefactStatus(runState, "QA").status === "revise";
+}
+
 function transitionDecisionForRunState(runState, verifiedChange = null) {
   if (gateApprovalStatus(runState, "UR") === "approved" && !isGateSatisfied(runState, "UR")) return durableArtefactBlock("UR", "PRD");
 
@@ -2474,6 +2555,18 @@ function transitionDecisionForRunState(runState, verifiedChange = null) {
     };
   }
 
+  if (qaRevisionRequired(runState)) {
+    return {
+      status: "open",
+      current_gate: "QA",
+      blocking_reason: "qa_revise_required",
+      missing_approval: "none",
+      allowed: ["revise the implementation against the QA findings", "refresh CD+Tests and mandatory reviews", "rerun QA with refreshed evidence"],
+      forbidden: ["request QA approval", "request UAT approval", "release", "claim delivery readiness"],
+      next_allowed_action: "Resolve the QA revise findings, refresh CD+Tests and reviews, then rerun QA. Do not request Approval: QA from a revise report.",
+    };
+  }
+
   if (gateApprovalStatus(runState, "QA") === "approved" && !isGateSatisfied(runState, "QA")) return durableArtefactBlock("QA", "UAT");
 
   if (isGateSatisfied(runState, "QA") && !isGateSatisfied(runState, "UAT")) {
@@ -2566,6 +2659,23 @@ function evaluateGateCheck(targetDir, selection = {}) {
   }
 
   const postApproval = postApprovalTransition(missingApproval);
+  const presentationLocale = resolveConfiguredChatLanguage(targetDir);
+  const statusCard = buildStatusCard({
+    status,
+    currentGate,
+    allowed,
+    forbidden,
+    blockingReason,
+    missingApproval,
+    nextAllowedAction,
+    runState,
+    chatLanguage: presentationLocale,
+    findings: deliveryMap.findings,
+  });
+  Object.defineProperty(statusCard, "humanPresentation", {
+    value: buildHumanPresentation(targetDir, runState, currentGate, presentationLocale),
+    enumerable: false,
+  });
 
   return {
     schema_version: "1",
@@ -2582,18 +2692,8 @@ function evaluateGateCheck(targetDir, selection = {}) {
     doctor_summary: doctorReport.summary,
     evidence_refs: runState.evidence_refs,
     quality_outlook: deriveQualityOutlook(runState, deliveryMap.findings),
-    status_card: buildStatusCard({
-      status,
-      currentGate,
-      allowed,
-      forbidden,
-      blockingReason,
-      missingApproval,
-      nextAllowedAction,
-      runState,
-      chatLanguage: resolveConfiguredChatLanguage(targetDir),
-      findings: deliveryMap.findings,
-    }),
+    candidate_runs: runState.candidate_runs ?? [],
+    status_card: statusCard,
     delivery_map: {
       relationships: deliveryMap.relationships,
       mode_slice_decision: runState.mode_slice_decision,
@@ -2609,58 +2709,27 @@ function evaluateGateCheck(targetDir, selection = {}) {
 
 function printGateCheckStatusCard(report) {
   const card = report.status_card;
-  const de = card.presentation_language === "de";
-  const labels = de ? {
-    title: "AGDF-Statuskarte",
-    run: "Ausgewählter Run",
-    gate: "Aktuelles Gate",
-    blocked: "Blockiert durch",
-    missing: "Fehlende Freigabe",
-    outcome: "Ergebnis nach Freigabe",
-    internal: "Interner nächster Schritt",
-    userGate: "Nächstes User-Gate",
-    userAction: "Nutzeraktion erforderlich",
-    nextGate: "Nächstes Gate nach Freigabe",
-    allowedAfter: "Nach Freigabe erlaubt",
-    skill: "Nächster Skill",
-    step: "Nächster Schritt",
-    quality: "Qualitätsausblick",
-    allowed: "Jetzt erlaubt",
-    forbidden: "Aktuell verboten",
-  } : {
-    title: "AGDF status-card",
-    run: "Selected run",
-    gate: "Current gate",
-    blocked: "Blocked by",
-    missing: "Missing approval",
-    outcome: "User-visible outcome after approval",
-    internal: "Internal next step",
-    userGate: "Next user gate",
-    userAction: "User action required",
-    nextGate: "Next gate after approval",
-    allowedAfter: "Allowed after approval",
-    skill: "Next skill",
-    step: "Next step",
-    quality: "Quality outlook",
-    allowed: "Allowed now",
-    forbidden: "Forbidden now",
+  const labels = localePack(interactionLocales, card.presentation_language).statusCard;
+  const primary = localePack(interactionLocales, card.presentation_language).primary;
+  const presentation = card.humanPresentation ?? {
+    runTitle: card.run_id,
+    gateTitle: gateTitle(interactionLocales, card.presentation_language, card.current_gate),
+    artefactRefs: buildArtefactRefs({}, interactionLocales, card.presentation_language),
   };
-  console.log(`${labels.title}: ${card.status}`);
+  console.log(`${labels.title}: ${primary.status[card.status] ?? card.status}`);
   console.log(`${labels.run}: ${card.run_id}`);
-  console.log(`${labels.gate}: ${card.current_gate}`);
-  console.log(`${labels.blocked}: ${card.blocking_condition}`);
-  console.log(`${labels.missing}: ${card.missing_approval}`);
-  console.log(`${labels.outcome}: ${card.user_visible_outcome_after_approval}`);
-  console.log(`${labels.internal}: ${card.internal_next_step}`);
-  console.log(`${labels.userGate}: ${card.next_user_gate}`);
-  console.log(`${labels.userAction}: ${card.user_action_required}`);
-  if (card.next_gate_after_approval !== "none") console.log(`${labels.nextGate}: ${card.next_gate_after_approval}`);
-  if (card.allowed_after_approval !== "none") console.log(`${labels.allowedAfter}: ${card.allowed_after_approval}`);
-  console.log(`${labels.skill}: ${card.next_skill}`);
-  console.log(`${labels.step}: ${card.next_step}`);
-  console.log(`${labels.quality}: ${card.quality_outlook}`);
-  if (card.allowed_now.length > 0) console.log(`${labels.allowed}: ${card.allowed_now.join("; ")}`);
-  if (card.forbidden_now.length > 0) console.log(`${labels.forbidden}: ${card.forbidden_now.join("; ")}`);
+  console.log(`${labels.humanTitle}: ${presentation.runTitle}`);
+  console.log(`${labels.gate}: ${card.current_gate} — ${presentation.gateTitle}`);
+  console.log(`${labels.artefacts}: ${formatArtefactRefs(presentation.artefactRefs)}`);
+  console.log(`${labels.blocked}: ${card.blocking_condition === "none" ? primary.none : primary.blocked}`);
+  console.log(`${labels.missing}: ${card.missing_approval === "none" ? primary.none : card.missing_approval}`);
+  if (card.next_gate_after_approval !== "none") {
+    console.log(`${labels.nextGate}: ${card.next_gate_after_approval} — ${gateTitle(interactionLocales, card.presentation_language, card.next_gate_after_approval)}`);
+    console.log(`${labels.allowedAfter}: ${primary.afterApproval[card.current_gate] ?? primary.actions[card.current_gate]}`);
+  }
+  console.log(`${labels.allowed}: ${primary.actions[card.current_gate] ?? primary.none}`);
+  console.log(`${labels.step}: ${primary.actions[card.current_gate] ?? primary.none}`);
+  console.log(`${labels.quality}: ${primary.quality}`);
 }
 
 function printGateCheckReport(report, json, statusCard = false) {

package/generated/.github/skills/agdf-gate-check/SKILL.md

@@ -54,7 +54,7 @@ The CLI reports are validators and JSON evidence, not the primary user experienc
 
 ## Native Interaction Path
 
-Use the Runtime Contract's Native Interaction Contract to classify every candidate interaction as `clarification`, `tool_permission` or `gate_approval` before selecting a host control.
+Use the Runtime Contract's Native Interaction Contract to classify every candidate interaction as `clarification`, `tool_permission`, `gate_approval`, `blocked` or `status` before selecting a host control.
 
 Prefer inspection over asking. Do not invoke a structured question for status reporting, facts available in the repository, routine read-only work or a gate that is not ready. Do not repeatedly prompt for the same non-ready gate.
 
@@ -62,20 +62,20 @@ For a ready `gate_approval`:
 
 1. Resolve exactly one selected run and evaluate the current gate.
 2. Confirm the required durable artefact is present and ready before presenting a question.
-3. Render a separate localized Gate Transition Card immediately before any native question or exact-text fallback. Never put the card only into the question, button description or hidden tool context.
+3. Render a separate localized Gate Transition Card immediately before any native question or exact-text fallback. It includes the deterministic human run title and `UR · PRD · SD · TP` links from the selected run. Never put the card only into the question, button description or hidden tool context.
 4. Treat the operational Run Status Card as evaluation and audit input, not as the approval-time product surface. Do not paste its table, raw keys, machine statuses, evidence or diagnostic detail into the transition card.
 5. Compose the transition card as one human-readable gate title with `run_id`, one ready-for-decision line, one short approval-effect block and one short next-transition block. It must answer only: where am I, what does this decision do, and what happens next.
 6. Distinguish internal process steps from user decisions in natural language. For example, after `Approval: TP`, say that pre-implementation Brownfield Analysis runs next and that no further user action is required now; do not expose `next_user_gate: none` or `user_action_required: no`, and do not ask for a second approval for Brownfield Analysis.
 7. Ask exactly one question that names the selected `run_id` and `current_gate`.
-8. Offer the exact approving option `Approval: <GateName>` plus bounded revise and cancel/decline outcomes.
+8. Offer options in stable order: exact `Approval: <GateName>`, localized revise and localized decline. Add explicit cancel only where supported after decline; otherwise host dismissal maps to cancel. Never preselect, skip, auto-submit or reorder an option.
 9. Use the surface adapter declared in the canonical plugin definition only when it can wait for deliberate input without auto-resolution; otherwise request the same exact approval in concise text.
 10. Re-run gate evaluation for the same run and expected gate after the response and immediately before persistence.
 11. Reject a missing artefact, ambiguous or wrong run, wrong gate, stale expected gate, timeout/default, hook-supplied answer, agent message, technical permission outcome or plan approval.
 12. Persist accepted input only through the existing control-state workflow.
 
-Before composing the question, resolve the configured chat locale from `.agdf/control/config.json`. Use German presentation text for `chat_language: de`; use English for `chat_language: en` or as the deterministic fallback for an absent or unsupported locale. Keep `Approval: <GateName>` exactly unchanged in every language, and do not mix presentation languages within one question.
+Before composing the question, resolve the configured chat locale from `.agdf/control/config.json` through `../agdf-interaction-locales.json`: exact complete pack, language subtag, then English fallback. German and English are initial packs, not a closed language list. Keep `Approval: <GateName>` exactly unchanged in every language, and do not mix presentation languages within one interaction. Labels and descriptions use the same resolved locale; host-owned UI chrome remains host-owned and may use a different language.
 
-For the transition card, German uses `Bereit für deine Entscheidung`, `Jetzt freigeben` and `Danach`; English uses `Ready for your decision`, `Approve now` and `Next`. Keep each card in one locale. Use a human-readable gate title rather than an internal status label. Do not render a Markdown table, dashboard rows, raw control-state keys, diagnostic codes, evidence lists, a duplicated gate question or a false user gate in the approval-time card.
+For the transition card, use the complete resolved locale pack. The initial German pack includes `Bereit für deine Entscheidung`, `Jetzt freigeben` and `Danach`; the initial English pack includes `Ready for your decision`, `Approve now` and `Next`. Keep each card in one locale. Use a localized human-readable gate title rather than an internal status label, while leaving the exact gate identifier and approval value unchanged. Do not render a Markdown table, dashboard rows, raw control-state keys, diagnostic codes, evidence lists, a duplicated gate question or a false user gate in the approval-time card.
 
 The primary option remains exactly `Approval: SD`; only explanatory copy and non-authoritative outcome labels are localized. Concrete localized copy belongs to the user-facing interaction layer or the approved delivery artefact, not to English runtime rules.
 
@@ -84,6 +84,13 @@ apply or safely return the native question on that attempt, switch immediately
 to the exact textual approval. Do not ask the user to request the buttons again
 and do not create a retry loop or simulated control.
 
+State the outcome visibly: `presented`, `unavailable_before_invocation`,
+`attempted_not_applied` or `unsafe_to_wait`. For every fallback, say in the
+configured locale why a native control was not usable, show the exact approval
+value and confirm that authority is unchanged. This transient outcome is not
+approval evidence. A new explicit user request may reopen the unchanged decision
+only after fresh run/gate/artefact revalidation; never retry automatically.
+
 Surface behavior:
 
 - Codex: invoke the native short-question/request-user-input control on the first eligible attempt when callable, ask one gate question and omit auto-resolution; if it is not rendered or applied, use exact text immediately.
@@ -91,9 +98,11 @@ Surface behavior:
 - OpenCode: use built-in `question` when permitted. Preserve explicit `permission.question` denial and use exact text in that case. `once`, `always`, `reject` and auto mode never become gate input.
 - Other, unavailable or non-interactive surfaces: use exact textual approval and wait for a new explicit user response.
 
-Localized labels such as `Überarbeiten`/`Revise`, `Ablehnen`/`Decline` and `Abbrechen`/`Cancel` are presentation mappings to stable non-approval outcomes only. Host-provided free-text or `Überspringen`/`Skip` actions never advance an AGDF gate.
+Localized labels such as `Überarbeiten`/`Revise`, `Ablehnen`/`Decline` and `Abbrechen`/`Cancel` are presentation mappings to stable non-approval outcomes only. A label, description, option position or recommendation never authorizes a gate. Host-provided free-text or `Überspringen`/`Skip` actions never advance an AGDF gate.
+
+A free-form response must still exactly match the current gate's approval formula after revalidation. Keep `decline`, `cancel`, `no_response`, `timeout`, `empty`, `invalid` and `stale` distinct; none advances the gate. Native presentation, host permission and plan approval are inputs or separate authority domains, never durable AGDF authority.
 
-A free-form response must still exactly match the current gate's approval formula after revalidation. Revise, decline and cancel never advance the gate. Native presentation, host permission and plan approval are inputs or separate authority domains, never durable AGDF authority.
+Every primary chat card shows the selected run's `UR`, `PRD`, `SD` and `TP` in that order. Render an existing canonical path as a readable link and a missing artefact as localized non-link text; never guess paths. Resolve the human run title from current artefact heading, approved UR heading, Objective, then normalized `run_id`. Status, blocked, clarification and internal-step interactions use the same locale and artefact projection but do not show approval buttons. Keep raw process keys and machine status values in JSON or audit detail.
 
 ## Rules
 1. Fail closed when a required approval or artefact status is missing.

package/generated/.github/skills/agdf-interaction-locales.json

@@ -0,0 +1,184 @@
+{
+  "schemaVersion": 1,
+  "fallbackLocale": "en",
+  "optionOrder": ["approve", "revise", "decline", "cancel"],
+  "lengthBudgets": {
+    "label": 40,
+    "description": 160,
+    "title": 100
+  },
+  "locales": {
+    "en": {
+      "statusCard": {
+        "title": "AGDF status-card",
+        "run": "Selected run",
+        "humanTitle": "Run title",
+        "gate": "Current gate",
+        "blocked": "Blocked by",
+        "missing": "Missing approval",
+        "outcome": "Outcome after approval",
+        "internal": "Internal next step",
+        "userGate": "Next user gate",
+        "userAction": "User action required",
+        "nextGate": "Next gate after approval",
+        "allowedAfter": "Allowed after approval",
+        "skill": "Next skill",
+        "step": "Next step",
+        "quality": "Quality outlook",
+        "allowed": "Allowed now",
+        "forbidden": "Forbidden now",
+        "artefacts": "Artefacts"
+      },
+      "gateTitles": {
+        "UR": "User requirements",
+        "PRD": "Product requirements",
+        "SD": "Solution design",
+        "TP": "Task and test plan",
+        "QA": "Quality assurance",
+        "UAT": "User acceptance",
+        "Brownfield Review": "Brownfield review",
+        "Mode/Slice Decision": "Delivery scope decision",
+        "Brownfield Analysis": "Implementation preparation",
+        "CD+Tests": "Implementation and tests",
+        "CR": "Code review",
+        "OR": "Delivery report"
+      },
+      "interaction": {
+        "ready": "Ready for your decision",
+        "approveHeading": "Approve now",
+        "nextHeading": "Next",
+        "approveDescription": "Approve this gate with the exact authorization value.",
+        "reviseLabel": "Revise",
+        "reviseDescription": "Keep the gate open and request changes.",
+        "declineLabel": "Decline",
+        "declineDescription": "Reject this gate deliberately; authority remains unchanged.",
+        "cancelLabel": "Cancel",
+        "cancelDescription": "Close this decision without approving or declining it."
+      },
+      "artefacts": {
+        "notYetCreated": "not yet created"
+      },
+      "primary": {
+        "status": {
+          "open": "open",
+          "blocked": "blocked",
+          "pass": "passed",
+          "warn": "attention needed",
+          "revise": "revision needed",
+          "in_progress": "in progress"
+        },
+        "none": "none",
+        "blocked": "current gate prerequisites",
+        "quality": "Keep the presentation contract, evidence and gate authority aligned.",
+        "actions": {
+          "UR": "Clarify and approve the user requirements.",
+          "Brownfield Review": "Review existing owners and choose the smallest safe delivery path.",
+          "Mode/Slice Decision": "Decide the proportionate delivery scope from repository evidence.",
+          "PRD": "Define and approve the product behavior.",
+          "SD": "Define and approve the solution design.",
+          "TP": "Define and approve the task and test plan.",
+          "Brownfield Analysis": "Verify owners, reuse and regression coverage before implementation.",
+          "CD+Tests": "Implement the approved plan and collect test evidence.",
+          "CR": "Review the implementation and resolve blocking findings.",
+          "QA": "Evaluate quality evidence and make the QA decision.",
+          "UAT": "Make the deliberate user-acceptance decision.",
+          "OR": "Prepare the auditable delivery report."
+        },
+        "afterApproval": {
+          "UR": "Review existing owners and choose the proportionate delivery path; implementation remains blocked.",
+          "PRD": "Draft the solution design; implementation remains blocked.",
+          "SD": "Draft the task and test plan; implementation remains blocked.",
+          "TP": "Run pre-implementation Brownfield Analysis; implementation starts only if it passes.",
+          "QA": "Prepare the user-acceptance decision; release remains blocked.",
+          "UAT": "Prepare the delivery report; version-control and release actions still require explicit instruction."
+        }
+      }
+    },
+    "de": {
+      "statusCard": {
+        "title": "AGDF-Statuskarte",
+        "run": "Ausgewählter Run",
+        "humanTitle": "Run-Titel",
+        "gate": "Aktuelles Gate",
+        "blocked": "Blockiert durch",
+        "missing": "Fehlende Freigabe",
+        "outcome": "Ergebnis nach Freigabe",
+        "internal": "Interner nächster Schritt",
+        "userGate": "Nächstes User-Gate",
+        "userAction": "Nutzeraktion erforderlich",
+        "nextGate": "Nächstes Gate nach Freigabe",
+        "allowedAfter": "Nach Freigabe erlaubt",
+        "skill": "Nächster Skill",
+        "step": "Nächster Schritt",
+        "quality": "Qualitätsausblick",
+        "allowed": "Jetzt erlaubt",
+        "forbidden": "Aktuell verboten",
+        "artefacts": "Artefakte"
+      },
+      "gateTitles": {
+        "UR": "Nutzeranforderungen",
+        "PRD": "Produktanforderungen",
+        "SD": "Lösungsdesign",
+        "TP": "Aufgaben- und Testplan",
+        "QA": "Qualitätssicherung",
+        "UAT": "Nutzerabnahme",
+        "Brownfield Review": "Brownfield-Prüfung",
+        "Mode/Slice Decision": "Entscheidung zum Lieferumfang",
+        "Brownfield Analysis": "Implementierungsvorbereitung",
+        "CD+Tests": "Implementierung und Tests",
+        "CR": "Code-Review",
+        "OR": "Lieferbericht"
+      },
+      "interaction": {
+        "ready": "Bereit für deine Entscheidung",
+        "approveHeading": "Jetzt freigeben",
+        "nextHeading": "Danach",
+        "approveDescription": "Dieses Gate mit dem exakten Freigabewert autorisieren.",
+        "reviseLabel": "Überarbeiten",
+        "reviseDescription": "Das Gate offen lassen und Änderungen anfordern.",
+        "declineLabel": "Ablehnen",
+        "declineDescription": "Dieses Gate bewusst ablehnen; die Berechtigung bleibt unverändert.",
+        "cancelLabel": "Abbrechen",
+        "cancelDescription": "Diese Entscheidung ohne Freigabe oder Ablehnung schließen."
+      },
+      "artefacts": {
+        "notYetCreated": "noch nicht erstellt"
+      },
+      "primary": {
+        "status": {
+          "open": "offen",
+          "blocked": "blockiert",
+          "pass": "bestanden",
+          "warn": "Prüfung erforderlich",
+          "revise": "Überarbeitung erforderlich",
+          "in_progress": "in Arbeit"
+        },
+        "none": "keine",
+        "blocked": "Voraussetzungen des aktuellen Gates",
+        "quality": "Präsentationsvertrag, Nachweise und Gate-Berechtigung konsistent halten.",
+        "actions": {
+          "UR": "Nutzeranforderungen klären und freigeben.",
+          "Brownfield Review": "Bestehende Owner prüfen und den kleinsten sicheren Lieferweg wählen.",
+          "Mode/Slice Decision": "Den angemessenen Lieferumfang anhand der Repository-Nachweise festlegen.",
+          "PRD": "Produktverhalten definieren und freigeben.",
+          "SD": "Lösungsdesign definieren und freigeben.",
+          "TP": "Aufgaben- und Testplan definieren und freigeben.",
+          "Brownfield Analysis": "Owner, Wiederverwendung und Regressionstests vor der Implementierung prüfen.",
+          "CD+Tests": "Den freigegebenen Plan implementieren und Testnachweise sammeln.",
+          "CR": "Implementierung prüfen und blockierende Befunde beheben.",
+          "QA": "Qualitätsnachweise bewerten und die QA-Entscheidung treffen.",
+          "UAT": "Die bewusste Nutzerabnahme entscheiden.",
+          "OR": "Den auditierbaren Lieferbericht erstellen."
+        },
+        "afterApproval": {
+          "UR": "Bestehende Owner prüfen und den angemessenen Lieferweg wählen; die Implementierung bleibt gesperrt.",
+          "PRD": "Das Lösungsdesign entwerfen; die Implementierung bleibt gesperrt.",
+          "SD": "Den Aufgaben- und Testplan entwerfen; die Implementierung bleibt gesperrt.",
+          "TP": "Die Brownfield-Analyse vor der Implementierung durchführen; die Implementierung startet nur nach bestandenem Ergebnis.",
+          "QA": "Die Nutzerabnahme vorbereiten; die Veröffentlichung bleibt gesperrt.",
+          "UAT": "Den Lieferbericht vorbereiten; Versionskontroll- und Veröffentlichungsaktionen benötigen weiterhin eine ausdrückliche Anweisung."
+        }
+      }
+    }
+  }
+}