create-agdf 0.20.2 → 0.30.0

package/generated/plugins/agdf/runtime/create-agdf/lib/cli/validation-handlers.js

@@ -1,13 +1,11 @@
-import { recordGateApprovalCommand, resolveControlCommandTarget } from "../control-command.js";
-import { COOPERATIVE_ASSURANCE } from "#agdf-core/control-state/approval-command-contract.js";
+import { executeRunAlias } from './run-command-aliases.js';
+import { executeProjectRead } from './project-read-command.js';
+import { localePack } from '#agdf-core/interaction-presentation.js';
+import { renderCodexDocument } from './codex-document-command.js';
 import { readFileSync, lstatSync, openSync, fstatSync, closeSync, constants } from "node:fs";
 import { commandGroupRoutes } from './command-registry.js';
 import { RUN_COMMAND_LIMITS } from '#agdf-core/control-state/run-command-contract.js';
 import { executeControlMaintenance } from "./control-maintenance-command.js";
-import { createRun } from "#agdf-core/control-state/run-state-repository.js";
-import { extractField } from "#agdf-core/control-evaluation/verified-change.js";
-import { ARTEFACT_TEMPLATE_IDS, resolveArtefactTemplatePath } from "#agdf-core/resources/artefact-templates.js";
-import { prepareRunPresentation } from "#agdf-core/control-state/run-presentation.js";
 import {
   buildStatusCard,
   evaluateGateCheck,
@@ -19,19 +17,19 @@ import { evaluateDeliveryMap, printDeliveryMapReport } from "#agdf-core/control-
 import { evaluateDoctor, printDoctorReport } from "#agdf-core/control-evaluation/doctor.js";
 import { executeDeliveryPathSearch } from "./delivery-path-search-command.js";
 import { resolveTaskTarget } from "#agdf-core/task-target-resolution.js";
-import { renderSkillDispatchRecovery, renderTaskTargetOrientation, renderSourceRevision } from "#agdf-core/interaction-presentation.js";
+import { renderSkillDispatchRecovery, renderTaskTargetOrientation, renderSourceRevision, renderRunInventory } from "#agdf-core/interaction-presentation.js";
+import { readRunInventory } from "#agdf-core/control-state/run-inventory-reader.js";
+import { readWorkInventory } from '#agdf-core/control-state/planned-inventory.js';
+import { readControlLayout, CURRENT_LAYOUT } from '#agdf-core/control-state/control-layout.js';
+import { executePlannedCli } from './planned-command.js';
 import { interactionLocales, pluginDefinition } from "./runtime-context.js";
 import { serializeSkillDispatchResult } from "#agdf-core/skill-dispatch/contract.js";
 import { createCoreServices } from "#agdf-core";
 import { resources } from "../runtime/control-context.js";
-import { approveRunGate, recordRunRevision } from "#agdf-core/control-state/run-recording.js";
-import { reopenPrdRevision, previewSourceRevision, applySourceRevision, inspectSourceRevision, recoverSourceRevision } from "#agdf-core/control-state/run-revision.js";
 import { readRuntimeContract, readSkillRuntimeContracts } from "./contract-command.js";
-import { recordRunStep } from "#agdf-core/control-state/run-steps.js";
-import { policyForRunContent } from "#agdf-core/control-evaluation/run-step-policy.js";
 import { cliGitObservation } from "../control-evaluation/git-observation.js";
 import { resolveRepositoryContext } from "../repository-context.js";
-import { applyRunRecovery, inspectRunRecovery, previewRunRecovery } from "../control-state/run-recovery.js";
+import { resolveConfiguredChatLanguage } from "#agdf-core/resources/context.js";
 
 const evaluateDoctorWithCliGit = (target, selection) => evaluateDoctor(target, selection, cliGitObservation);
 const evaluateGateWithCliGit = (target, selection) => evaluateGateCheck(target, selection, cliGitObservation);
@@ -47,6 +45,9 @@ export function createValidationHandlers(io = console) {
     readSkillRuntimeContracts,
   } }).dispatch;
   return new Map([
+    ...['project-state', 'operation-status'].map(name => [name, options => executeProjectRead(options, io)]),
+    ['render-document', options => renderCodexDocument(options)],
+    ...['run-create', 'run-present', 'run-approve', 'run-step', 'run-revise', 'run-close'].map(name => [name, options => executeRunAlias(options, io)]),
     ...Object.entries(commandGroupRoutes).map(([route, group]) => [route, options => {
       let fd;
       try {
@@ -58,39 +59,14 @@ export function createValidationHandlers(io = console) {
         const bytes = readFileSync(fd);
         if (bytes.length > RUN_COMMAND_LIMITS.input_bytes) throw Error('command_file_invalid');
         const input = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
-        const result = createCoreServices({ resources }).command(group, input);
+        const result = createCoreServices({ resources, observers: { gitObservation: cliGitObservation } }).command(group, input);
         io.log(JSON.stringify(result));
         return ['accepted', 'already_applied'].includes(result.outcome) ? 0 : 2;
       } catch (error) { io.error(error.message); return 1; }
       finally { if (fd !== undefined) closeSync(fd); }
     }]),
     ["control-maintenance", (options) => executeControlMaintenance(options, io)],
-    ["run-create", (options) => {
-      try {
-        const path = createRun(options.dir, options.runId);
-        const revisionId = extractField(readFileSync(path, "utf8"), "revision_id");
-        io.log(path);
-        io.log(`revision_id: ${revisionId}`);
-        // The plugin-owned template is the only authoring source; repository scaffold copies are
-        // derived references. Run creation itself never fails on template availability.
-        let urTemplate = null;
-        try { urTemplate = resolveArtefactTemplatePath(ARTEFACT_TEMPLATE_IDS.UR); } catch {}
-        const templateSource = urTemplate
-          ? `the plugin-owned UR template at ${urTemplate}`
-          : "the plugin-owned UR template supplied as template_path by the bound ur-definition dispatch";
-        io.log(`Next: write .agdf/control/artefacts/${options.runId}/UR.md from ${templateSource}, then record it with run-step --run ${options.runId} --revision ${revisionId} --step ur --title "<short requirement title>".`);
-        return 0;
-      } catch (error) {
-        io.error(error instanceof Error ? error.message : String(error));
-        return 1;
-      }
-    }],
-    ["run-present", (options) => {
-      const result = prepareRunPresentation(options.dir, { runId: options.runId, gate: options.gate,
-        revisionId: options.revisionId, language: options.language?.chat_language }, { evaluateGateCheck: evaluateGateWithCliGit });
-      io.log(JSON.stringify(result, null, 2));
-      return result.outcome === "prepared" ? 0 : 2;
-    }],
+    ['planned', options => executePlannedCli(options, io)],
     ["target-check", (options) => {
       const report = resolveTaskTargetWithCliGit({
         targetSource: options.targetSource,
@@ -138,7 +114,13 @@ export function createValidationHandlers(io = console) {
     }],
     ["doctor", (options) => {
       const report = evaluateDoctorWithCliGit(options.dir, options);
-      printDoctorReport(report, options.json, io);
+      let emptyInventoryText;
+      if (report.empty_inventory && !options.json) {
+        const language = options.languageExplicit ? options.language.chat_language : resolveConfiguredChatLanguage(options.dir);
+        emptyInventoryText = localePack(interactionLocales, language).doctorEmptyInventory?.policyDescription
+          .replace('{policy}', String(report.empty_inventory.allow_no_active_runs));
+      }
+      printDoctorReport(report, options.json, io, { emptyInventoryText });
       return report.status === "block" ? 2 : 0;
     }],
     ["gate-check", (options) => {
@@ -154,6 +136,17 @@ export function createValidationHandlers(io = console) {
       if (presentationRendered === false) return 2;
       return report.status === "blocked" ? 2 : 0;
     }],
+    ["inventory", (options) => {
+      const language = options.languageExplicit ? options.language?.chat_language : resolveConfiguredChatLanguage(options.dir);
+      if (readControlLayout(options.dir).layout === CURRENT_LAYOUT) {
+        const inventory = readWorkInventory(options.dir, { language });
+        io.log(options.json ? JSON.stringify(inventory, null, 2) : inventory.entries.map(row => `${row.kind}: ${row.title} · ${row.coverage}`).join('\n'));
+        return inventory.state === 'unavailable' ? 2 : 0;
+      }
+      const inventory = readRunInventory(options.dir, { language });
+      io.log(options.json ? JSON.stringify(inventory, null, 2) : renderRunInventory(inventory, interactionLocales, language).markdown);
+      return 0;
+    }],
     ["delivery-map", (options) => {
       const report = evaluateDeliveryMap(options.dir, options, deliveryMapDependencies);
       printDeliveryMapReport(report, options.json, io);
@@ -168,69 +161,6 @@ export function createValidationHandlers(io = console) {
       io.log(options.json ? JSON.stringify({ module: result.module, content: result.content }) : result.content.replace(/\n$/u, ""));
       return 0;
     }],
-    ["run-update", (options) => {
-      const result = recordRunRevision(options.dir, { runId: options.runId, revisionId: options.revisionId });
-      io.log(JSON.stringify(result, null, 2));
-      return result.outcome === "rejected" ? 2 : 0;
-    }],
-    ["run-revise", (options) => {
-      const operation = { preview: previewSourceRevision, apply: applySourceRevision, inspect: inspectSourceRevision, recover: recoverSourceRevision }[options.revisionMode] ?? reopenPrdRevision;
-      const result = operation(options.dir, { runId: options.runId, revisionId: options.revisionId,
-        operationId: options.operationId, sourceGate: options.sourceGate, evidence: options.stepFields?.evidence, previewDigest: options.previewDigest });
-      io.log(options.revisionMode && !options.json ? renderSourceRevision(result, interactionLocales, options.language.chat_language,
-        { ...options, target: options.dir }).markdown : JSON.stringify(result, null, 2));
-      return ["rejected", "recovery_required"].includes(result.outcome) ? 2 : 0;
-    }],
-    ["run-step", (options) => {
-      const result = recordRunStep(options.dir, {
-        runId: options.runId,
-        revisionId: options.revisionId,
-        step: options.runStep,
-        ...(options.gate ? { gate: options.gate } : {}),
-        ...options.stepFields,
-      }, { policy: policyForRunContent });
-      io.log(JSON.stringify(result, null, 2));
-      return result.outcome === "rejected" ? 2 : 0;
-    }],
-    ["run-approve", (options) => {
-      let result;
-      if (options.assurance !== undefined && options.assurance !== "cooperative_local") {
-        result = { schema_version: "1", outcome: "rejected", run_id: options.runId,
-          reason: "unsupported_authority", assurance: COOPERATIVE_ASSURANCE };
-      } else if (options.operationId !== undefined) {
-        result = recordGateApprovalCommand(options.dir, {
-          schema_version: "1", action: "record_gate_approval",
-          target_id: resolveControlCommandTarget(options.dir).target_id, run_id: options.runId,
-          gate: options.gate, expected_revision_id: options.revisionId,
-          presentation_id: options.presentationId, response: options.response,
-          operation_id: options.operationId, assurance: options.assurance ?? "cooperative_local",
-        });
-      } else result = { ...approveRunGate(options.dir, {
-        runId: options.runId,
-        gate: options.gate,
-        revisionId: options.revisionId,
-        response: options.response,
-        presentationId: options.presentationId,
-      }, { evaluateGateCheck: evaluateGateWithCliGit }), assurance: COOPERATIVE_ASSURANCE };
-      io.log(JSON.stringify(result, null, 2));
-      return ["approved", "accepted", "already_applied"].includes(result.outcome) ? 0 : 2;
-    }],
-    ["run-recovery", (options) => {
-      try {
-        const result = options.recoveryAction === "inspect"
-          ? inspectRunRecovery(options.dir, options.runId)
-          : options.recoveryAction === "preview"
-            ? previewRunRecovery(options.dir, options.runId)
-            : applyRunRecovery(options.dir, { runId: options.runId,
-              previewId: options.recoveryPreviewId, confirmation: options.recoveryConfirmation });
-        io.log(JSON.stringify(result, null, 2));
-        return 0;
-      } catch (error) {
-        io.log(JSON.stringify({ schema_version: "1", outcome: "blocked", run_id: options.runId,
-          action: options.recoveryAction, reason: error instanceof Error ? error.message : String(error) }, null, 2));
-        return 2;
-      }
-    }],
     ["delivery-path-search", async (options) => {
       try {
         const result = await executeDeliveryPathSearch(options, io);

package/generated/plugins/agdf/runtime/create-agdf/lib/control-evaluation/git-observation.js

@@ -1,11 +1,12 @@
 import { execFileSync } from "node:child_process";
+const readOnlyOptions = ['--no-optional-locks', '-c', 'core.fsmonitor=false'];
 
 export function gitPathList(targetDir, args, exec = execFileSync) {
   try {
-    return exec("git", args, { cwd: targetDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })
-      .split("\n")
-      .map((item) => item.trim())
-      .filter(Boolean);
+    if (![JSON.stringify(['diff', 'HEAD', '--name-only']), JSON.stringify(['ls-files', '--others', '--exclude-standard'])].includes(JSON.stringify(args))) return null;
+    const fixed = args[0] === 'diff' ? ['diff', '--no-ext-diff', '--no-textconv', ...args.slice(1)] : args;
+    const bytes = exec("git", [...readOnlyOptions, ...fixed, '-z'], { cwd: targetDir, encoding: 'buffer', stdio: ["ignore", "pipe", "ignore"], timeout: 3000, maxBuffer: 2 * 1024 * 1024 });
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes).split('\0').filter(item => item.length > 0);
   } catch {
     return null;
   }
@@ -13,7 +14,8 @@ export function gitPathList(targetDir, args, exec = execFileSync) {
 
 export function gitValue(targetDir, args, exec = execFileSync) {
   try {
-    return exec("git", args, { cwd: targetDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (![JSON.stringify(['rev-parse', 'HEAD']), JSON.stringify(['rev-parse', '--show-toplevel'])].includes(JSON.stringify(args))) return null;
+    return exec("git", [...readOnlyOptions, ...args], { cwd: targetDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000, maxBuffer: 2 * 1024 * 1024 }).trim();
   } catch {
     return null;
   }

package/generated/plugins/agdf/runtime/create-agdf/lib/control-maintenance/startup.js

@@ -20,6 +20,6 @@ export function inspectStartupCompatibility({ target, executable, validator, env
 }
 
 export function startupMaintenanceInvocation(facts, { executable, validator, language = "en" }) {
-  if (!["migration_required", "repair_required", "unavailable"].includes(facts.status)) return null;
-  return { executable, argv: [validator, "control-maintenance", "--dir", facts.target, "--guided", "--language", language], authorizes: false };
+  if (!["unsupported", "repair_required", "unavailable"].includes(facts.status)) return null;
+  return { executable, argv: [validator, "control-maintenance", "--dir", facts.target, "--language", language], authorizes: false };
 }

package/generated/plugins/agdf/runtime/create-agdf/lib/mcp-decision-protocol.js

@@ -0,0 +1,40 @@
+import { RUN_COMMAND_GROUPS, RUN_COMMAND_LIMITS } from '#agdf-core/control-state/run-command-schema.js';
+
+// Optional UI composition is deliberately outside the default headless import
+// closure. Full and thin UI fronts share this one structural contract.
+const unwrapped = () => { throw Object.assign(Error('generation_unavailable'), { code: 'generation_unavailable', dispatch: 'not_dispatched' }); };
+
+import { decisionActionDefinition, validateDecisionAction, DECISION_VIEW_DEFINITION, validateDecisionView } from '#agdf-core/control-state/decision-action-contract.js';
+import { COCKPIT_READ_DEFINITION, parseCockpitArguments } from '#agdf-core/control-inspect/cockpit-contract.js';
+
+export function composeMcpDecisionProtocol({ runtime, ui, prepared = unwrapped, open = unwrapped, read = unwrapped, action = unwrapped, close = () => {} } = {}) {
+  const groups = runtime.trustedContext.commandGroups;
+  const facade = decisionActionDefinition(groups);
+  const tools = [...runtime.tools];
+  if (groups.includes('agdf_prepare')) tools.push({ name: DECISION_VIEW_DEFINITION.name, definition: DECISION_VIEW_DEFINITION, requiresUi: true, parentOwned: true,
+    parse: input => { if (validateDecisionView(input).length) throw Error('decision_schema_invalid'); return input; },
+    execute: async (input, signal, host) => {
+      const remembered = prepared(input);
+      if (!remembered) return { schema_version: '1', outcome: 'rejected', reason: 'delivery_state_unavailable', authorizes: false };
+      const opened = await open(remembered.input, remembered.result, host);
+      return { schema_version: '1', outcome: opened._meta ? 'accepted' : 'rejected', reason: opened.app_reason ?? null,
+        app_capability: opened.app_capability, authorizes: false, ...(opened._meta ? { _meta: opened._meta } : {}) };
+    }, serialize: JSON.stringify });
+  tools.push({ name: COCKPIT_READ_DEFINITION.name, definition: COCKPIT_READ_DEFINITION, requiresUi: true, parentOwned: true,
+    parse: parseCockpitArguments, execute: (input, signal, host) => read(input, signal, host), serialize: value => JSON.stringify(value) });
+  if (facade) tools.push({ name: facade.name, definition: facade, requiresUi: true, parentOwned: true,
+    parse: input => { if (validateDecisionAction(input, facade.inputSchema.properties.action.enum).length) throw Error('decision_schema_invalid'); return input; },
+    execute: (input, signal, host) => action(input, host), serialize: value => JSON.stringify(value) });
+  const bytes = tools.filter(tool => Object.hasOwn(RUN_COMMAND_GROUPS, tool.name) || tool.name === facade?.name || tool.name === DECISION_VIEW_DEFINITION.name)
+    .reduce((sum, tool) => sum + Buffer.byteLength(JSON.stringify(tool.definition)), 0);
+  if (bytes > RUN_COMMAND_LIMITS.aggregate_definition_bytes) { void close(); throw Error('command_aggregate_definition_budget_exceeded'); }
+  return Object.freeze({ ...runtime, tools: Object.freeze(tools), ui, mode: 'decision',
+    tool: name => tools.find(tool => tool.name === name) ?? null,
+    failure(code, name, input, dispatch) {
+      return name === 'agdf_decision_action' ? { schema_version: '1', outcome: dispatch?.dispatch === 'not_dispatched' ? 'rejected' : 'effect_unknown',
+        reason: code, operation_id: input?.operation_id ?? null, authorizes: false, recovery: 'Inspect the original UUID; do not infer non-execution or submit another decision.' }
+        : ['agdf_cockpit_read', 'agdf_decision_view'].includes(name) ? { schema_version: '1', outcome: 'rejected', reason: code, authorizes: false } : runtime.failure(code, name, input, dispatch);
+    },
+  });
+}
+