create-agdf 0.7.3 → 0.8.1

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,23 @@ import {
   parseControlState,
   verifyLegacyProjection,
 } from "../lib/control-state/index.js";
+import {
+  buildArtefactRefs,
+  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 +232,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 +257,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 +281,7 @@ function detectSystemLocale() {
 }
 
 function resolveLanguagePreference(explicitLanguage) {
-  const explicit = normalizeLanguage(explicitLanguage);
+  const explicit = configuredLanguage(explicitLanguage);
   if (explicit) {
     return {
       artifact_language: explicit,
@@ -276,7 +293,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,
@@ -286,6 +303,17 @@ function resolveLanguagePreference(explicitLanguage) {
   };
 }
 
+function resolveConfiguredChatLanguage(targetDir) {
+  const configPath = join(targetDir, ".agdf", "control", "config.json");
+  if (!existsSync(configPath)) return interactionLocales.fallbackLocale;
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    return resolvePresentationLocale(interactionLocales, config.chat_language);
+  } catch {
+    return interactionLocales.fallbackLocale;
+  }
+}
+
 function languageConfigContent(languagePreference) {
   return `${JSON.stringify({
     artifact_language: languagePreference.artifact_language,
@@ -403,9 +431,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;
@@ -2149,26 +2177,44 @@ function postApprovalTransition(missingApproval) {
     ["Approval: UR", {
       next_gate_after_approval: "Brownfield Review",
       allowed_after_approval: "Run Brownfield Review and record Mode/Slice Decision before PRD or implementation.",
+      internal_next_step: "Brownfield Review and Mode/Slice Decision",
+      next_user_gate: "PRD",
+      user_action_required: "yes",
     }],
     ["Approval: PRD", {
       next_gate_after_approval: "SD",
       allowed_after_approval: "Draft Solution Design; implementation remains forbidden.",
+      internal_next_step: "draft Solution Design",
+      next_user_gate: "SD",
+      user_action_required: "yes",
     }],
     ["Approval: SD", {
       next_gate_after_approval: "TP",
       allowed_after_approval: "Draft Task/Test Plan; implementation remains forbidden.",
+      internal_next_step: "draft Task/Test Plan",
+      next_user_gate: "TP",
+      user_action_required: "yes",
     }],
     ["Approval: TP", {
-      next_gate_after_approval: "Brownfield Analysis",
-      allowed_after_approval: "Run implementation-prep Brownfield Analysis before CD+Tests.",
+      next_gate_after_approval: "none",
+      allowed_after_approval: "Run implementation-prep Brownfield Analysis before CD+Tests; no further user approval is required at this internal step.",
+      internal_next_step: "pre-implementation Brownfield Analysis",
+      next_user_gate: "none",
+      user_action_required: "no",
     }],
     ["Approval: QA", {
       next_gate_after_approval: "UAT",
       allowed_after_approval: "Request UAT when QA has passed; release remains gated.",
+      internal_next_step: "prepare UAT evidence",
+      next_user_gate: "UAT",
+      user_action_required: "yes",
     }],
     ["Approval: UAT", {
       next_gate_after_approval: "OR",
       allowed_after_approval: "Produce OR or delivery closeout; VCS and release actions still require explicit instruction.",
+      internal_next_step: "OR or delivery closeout",
+      next_user_gate: "none",
+      user_action_required: "no",
     }],
   ]);
 
@@ -2187,11 +2233,15 @@ function buildStatusCard({
   missingApproval = "none",
   nextAllowedAction,
   runState,
+  chatLanguage = "en",
   findings = [],
 }) {
   const qualityOutlook = deriveQualityOutlook(runState, findings);
   const postApproval = postApprovalTransition(missingApproval);
+  const isUserGateApproval = missingApproval !== "none";
   return {
+    run_id: extractField(runState.content ?? "", "run_id") || "unknown",
+    presentation_language: chatLanguage,
     mode: extractField(runState.content ?? "", "mode") || "unknown",
     status,
     current_gate: currentGate,
@@ -2202,6 +2252,10 @@ function buildStatusCard({
     missing_approval: missingApproval || "none",
     next_gate_after_approval: postApproval.next_gate_after_approval,
     allowed_after_approval: postApproval.allowed_after_approval,
+    user_visible_outcome_after_approval: postApproval.allowed_after_approval,
+    internal_next_step: postApproval.internal_next_step || (isUserGateApproval ? "none" : nextAllowedAction),
+    next_user_gate: postApproval.next_user_gate || "none",
+    user_action_required: postApproval.user_action_required || (isUserGateApproval ? "yes" : "no"),
     evidence: runState.evidence_refs,
     next_skill: nextSkillByGate[currentGate] ?? "gate-check",
     next_step: nextAllowedAction,
@@ -2209,6 +2263,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`;
@@ -2529,6 +2625,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",
@@ -2545,17 +2658,7 @@ 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,
-      findings: deliveryMap.findings,
-    }),
+    status_card: statusCard,
     delivery_map: {
       relationships: deliveryMap.relationships,
       mode_slice_decision: runState.mode_slice_decision,
@@ -2571,17 +2674,27 @@ function evaluateGateCheck(targetDir, selection = {}) {
 
 function printGateCheckStatusCard(report) {
   const card = report.status_card;
-  console.log(`AGDF status-card: ${card.status}`);
-  console.log(`Current gate: ${card.current_gate}`);
-  console.log(`Blocked by: ${card.blocking_condition}`);
-  console.log(`Missing approval: ${card.missing_approval}`);
-  if (card.next_gate_after_approval !== "none") console.log(`Next gate after approval: ${card.next_gate_after_approval}`);
-  if (card.allowed_after_approval !== "none") console.log(`Allowed after approval: ${card.allowed_after_approval}`);
-  console.log(`Next skill: ${card.next_skill}`);
-  console.log(`Next step: ${card.next_step}`);
-  console.log(`Quality outlook: ${card.quality_outlook}`);
-  if (card.allowed_now.length > 0) console.log(`Allowed now: ${card.allowed_now.join("; ")}`);
-  if (card.forbidden_now.length > 0) console.log(`Forbidden now: ${card.forbidden_now.join("; ")}`);
+  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}: ${primary.status[card.status] ?? card.status}`);
+  console.log(`${labels.run}: ${card.run_id}`);
+  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) {
@@ -2698,6 +2811,7 @@ function evaluateDeliveryMap(targetDir, selection = {}) {
       missingApproval: gateDecision.missing_approval,
       nextAllowedAction,
       runState,
+      chatLanguage: resolveConfiguredChatLanguage(targetDir),
       findings: map.findings,
     }),
     backlog_pointers: readBacklogPointers(targetDir),

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,12 +62,22 @@ 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. Ask exactly one question that names the selected `run_id` and `current_gate`.
-4. Offer the exact approving option `Approval: <GateName>` plus bounded revise and cancel/decline outcomes.
-5. 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.
-6. Re-run gate evaluation for the same run and expected gate after the response and immediately before persistence.
-7. 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.
-8. Persist accepted input only through the existing control-state workflow.
+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 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` 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, 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.
 
 Make exactly one native-attempt for the ready gate. If the host does not render,
 apply or safely return the native question on that attempt, switch immediately
@@ -81,7 +91,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.
 
-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.
+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.
+
+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.
@@ -170,6 +184,11 @@ Keep the result short and operational. Render the Runtime Contract's compact hum
 
 When an approval is missing, also include `Next gate after approval` and `Allowed after approval` exactly as constrained by the Runtime Contract. Keep forbidden outputs, evidence and next-skill detail in the concise surrounding text when relevant; they are not extra status-card rows.
 
+This operational status table is for status reporting. When the same response
+immediately requests a ready gate approval, replace the table in the visible
+approval experience with the Gate Transition Card defined above, then invoke
+the native question or exact-text fallback. Do not show both cards.
+
 If this skill creates or updates control artefacts, do not paste full file bodies into the chat.
 List paths, summarize the decision, name the blocker or approval needed, and keep the durable content in the files.
 

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