create-agdf 0.20.2 → 0.30.0

package/generated/plugins/agdf/runtime/create-agdf/lib/runtime/control-command-service.js

@@ -1,12 +1,27 @@
-import { executeApprovalCommand } from "#agdf-core/control-state/approval-command.js";
-import { evaluateGateCheck } from "#agdf-core/control-evaluation/gate-check.js";
-import { cliGitObservation } from "../control-evaluation/git-observation.js";
-import { pluginDefinition } from "./control-context.js";
+import { executeApprovalCommand } from '#agdf-core/control-state/approval-command.js';
+import { validateApprovalCommand, resolveControlCommandTarget } from '#agdf-core/control-state/approval-command-contract.js';
+import { createCoreServices } from '#agdf-core';
+import { evaluateGateCheck } from '#agdf-core/control-evaluation/gate-check.js';
+import { cliGitObservation } from '../control-evaluation/git-observation.js';
+import { pluginDefinition, resources } from './control-context.js';
 
 const evaluateLocalGate = (root, selection) => evaluateGateCheck(root, selection, cliGitObservation);
+const invalidResult = (root, command) => executeApprovalCommand(root, command, {
+  evaluateGateCheck: evaluateLocalGate, packageVersion: pluginDefinition.version,
+});
 
 export function recordGateApprovalCommand(root, command) {
-  return executeApprovalCommand(root, command, {
-    evaluateGateCheck: evaluateLocalGate, packageVersion: pluginDefinition.version,
-  });
+  // Preserve the public action's strict descriptor validation before copying
+  // any field. Valid calls share CLI/MCP normalization and original UUID proof.
+  if (validateApprovalCommand(command)) return invalidResult(root, command);
+  let target;
+  try { target = resolveControlCommandTarget(root); } catch { return invalidResult(root, command); }
+  const input = { working_directory: process.cwd(), primary_target: target.root, target_source: 'explicit_target',
+    target_id: command.target_id, run_id: command.run_id, expected_revision_id: command.expected_revision_id,
+    operation_id: command.operation_id, assurance: command.assurance,
+    command: { kind: 'approval.record', payload: { gate: command.gate, presentation_id: command.presentation_id, response: command.response } } };
+  const result = createCoreServices({ resources, observers: { gitObservation: cliGitObservation } }).command('agdf_approve', input);
+  // The action facade keeps its existing result observations. The canonical
+  // command owner supplies its current receipt and replay, never a second writer.
+  return result.family_result?.operation_id === command.operation_id ? result.family_result : result;
 }

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

@@ -5,7 +5,14 @@ const generatedURL = new URL("../../generated/", import.meta.url);
 const contractsURL = coreResources.packageRoot === fileURLToPath(packageURL)
   ? pathToFileURL(`${coreResources.contractsRoot}/`)
   : new URL("plugins/agdf/meta/contracts/", generatedURL);
-export const resources = createResourceContext({ packageURL, generatedURL, contractsURL });
+// Projected packages bind Core and CLI to the same immutable resource files.
+// Reuse that already-validated data instead of parsing/freezing it twice. Source
+// compositions with different roots still construct their own bound context;
+// CLI's existing null template-root contract and fresh runtime digests remain.
+const sameResources = coreResources.packageRoot === fileURLToPath(packageURL)
+  && coreResources.generatedRoot === fileURLToPath(generatedURL);
+export const resources = sameResources ? Object.freeze({ ...coreResources, templatesRoot: null })
+  : createResourceContext({ packageURL, generatedURL, contractsURL });
 export const { packageRoot, generatedRoot, pluginDefinition, interactionLocales } = resources;
 export const configuredLanguage = value => configured(value, resources);
 export const resolveConfiguredChatLanguage = target => resolveLanguage(target, resources);

package/generated/plugins/agdf/runtime/create-agdf/lib/runtime/validator-application.js

@@ -4,7 +4,7 @@ import { validateCommandOptions, commandGroupRoutes } from "../cli/command-regis
 import { CliUsageError, parseArgs } from "../cli/parse-args.js";
 import { pluginDefinition } from "../cli/runtime-context.js";
 
-const validatorCommands = new Set(["target-check", "skill-dispatch", "doctor", "gate-check", "delivery-map", "delivery-path-search", "contract", "control-maintenance", "run-create", "run-present", "run-update", "run-revise", "run-step", "run-approve", ...Object.keys(commandGroupRoutes)]);
+const validatorCommands = new Set(["project-state", "operation-status", "target-check", "skill-dispatch", "doctor", "gate-check", "delivery-map", "inventory", "delivery-path-search", "contract", "control-maintenance", "run-create", "run-present", "run-revise", "run-step", "run-approve", "run-close", ...Object.keys(commandGroupRoutes)]);
 
 export async function runValidatorCli(argv = process.argv.slice(2), adapters = {}) {
   const io = adapters.io ?? console;
@@ -22,7 +22,7 @@ export async function runValidatorCli(argv = process.argv.slice(2), adapters = {
     return error.exitCode;
   }
   if (parsed.kind === "help") {
-    io.log("AGDF surface-local validator: target-check | skill-dispatch | doctor | gate-check | delivery-map | delivery-path-search | contract | control-maintenance | run-create | run-present | run-update | run-revise | run-step | run-approve");
+    io.log("AGDF surface-local validator: project-state | operation-status | target-check | skill-dispatch | doctor | gate-check | delivery-map | inventory | delivery-path-search | contract | control-maintenance | run-create | run-present | run-revise | run-step | run-approve | run-close");
     return 0;
   }
   let options;

package/generated/plugins/agdf/runtime/create-agdf/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@agdf/local-validator-runtime",
-  "version": "0.20.2",
+  "version": "0.30.0",
   "private": true,
   "type": "module",
   "imports": {
     "#agdf-core": "./runtime/core/lib/index.js",
     "#agdf-core/*": "./runtime/core/lib/*"
+  },
+  "exports": {
+    "./mcp-worker-runtime": "./lib/mcp-worker-runtime.js",
+    "./mcp-owner-protocol": "./lib/mcp-owner-protocol.js"
   }
 }

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/closeout-readiness.js

@@ -8,6 +8,14 @@ import { inspectQaReports } from './qa-follow-up.js';
 export { STRUCTURED_REQUIRED_REVIEWS, reviewArtefactType };
 
 export const closeoutConfirmation = (runId, revisionId, operationId, orDigest) => `Close Run: ${runId} ${revisionId} ${operationId} ${orDigest}`;
+// Discovery and validation share the existing compact document requirements.
+export const QUICK_CLOSEOUT_AUTHORING_FORMAT = {
+  template: 'OR', report_mode: 'OR-lite',
+  required_metadata: [{ field: 'run_id', label: 'Run' }, { field: 'report_mode', label: 'Report mode' }],
+  run_binding: 'Exactly one Run: <current run_id> or - run_id: <current run_id>; never both.',
+  required_sections: ['Result', 'Evidence', 'Risk', 'Next Step'],
+  template_scope: 'Use the bound OR template for identity; OR-lite needs only the declared metadata and four concrete sections, not OR-full sections.',
+};
 const value = (text, field, label) => cleanStatusCell(extractField(text, field) || (label ? text.match(new RegExp(`^${label}:[ \\t]*(.*)$`, 'mu'))?.[1] : ''));
 const concrete = text => filled(text) && !isPlaceholderValue(text) && !/^(?:tbd|todo|<)/iu.test(text);
 export function closeoutContext(text) {
@@ -22,7 +30,7 @@ export function evaluateCloseoutReadiness(state, report, readArtefact, { prepare
   const findings = [], fail = reason => findings.push(reason), route = state.mode_slice_decision?.decision;
   const structured = ['structured_slice', 'structured_delivery'].includes(route);
   if (typeof report !== 'string' || Buffer.byteLength(report) > 131072) return { ready: false, findings: ['or_unavailable_or_oversized'] };
-  if (prepared) for (const [field, label] of [['run_id', 'Run'], ['report_mode', 'Report mode'], ...(structured ? [['status', 'Status']] : [])]) {
+  if (prepared) for (const [field, label] of [...QUICK_CLOSEOUT_AUTHORING_FORMAT.required_metadata.map(row => [row.field, row.label]), ...(structured ? [['status', 'Status']] : [])]) {
     const declarations = [...report.matchAll(new RegExp(`^(?:- ${field}|${label}):[ \\t]*(.*)$`, 'gmu'))];
     if (declarations.length !== 1) fail('or_field_ambiguous:' + field);
   }
@@ -34,7 +42,7 @@ export function evaluateCloseoutReadiness(state, report, readArtefact, { prepare
   if (programme?.applicable && !programme.final_ready) fail('programme_aggregation_unfulfilled');
   if (!structured) {
     if (state.artefacts.get('CR')?.status !== 'done') fail('code_review_missing');
-    for (const section of ['Result', 'Evidence', 'Risk', 'Next Step']) if (!concrete(markdownSection(report, section).trim())) fail(`or_${section.toLowerCase().replaceAll(' ', '_')}_missing`);
+    for (const section of QUICK_CLOSEOUT_AUTHORING_FORMAT.required_sections) if (!concrete(markdownSection(report, section).trim())) fail(`or_${section.toLowerCase().replaceAll(' ', '_')}_missing`);
   } else {
     if (!['done', 'completed', 'pass'].includes(value(report, 'status', 'Status'))) fail('or_status_unconfirmed');
     for (const gate of ['UR', 'PRD', 'SD', 'TP', 'QA', 'UAT']) {

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/decision-content-placeholder.js

@@ -0,0 +1,9 @@
+// Template prompts and status-only values that never count as authored content. Pure, so the
+// run inventory and other `node:`-free readers share the same rule.
+const prompts = new Set(['describe the trustworthy outcome.', 'what outcome should become possible?',
+  'which tp tasks are fully done, partially done or not done?', 'what remains unverified?', 'which risks remain and what is their impact?']);
+export function isDecisionContentPlaceholder(value) {
+  if (typeof value !== 'string') return true;
+  const text = value.trim().replace(/^`([^`]+)`$/u, '$1').replace(/\s+/gu, ' ').toLowerCase();
+  return !text || prompts.has(text) || /^(?:todo|tbd|<[^>]+>|(?:draft|done|ready|blocked|pass|revise|block)(?:\s*\|\s*(?:draft|done|ready|blocked|pass|revise|block))+)$/.test(text);
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/decision-content-readiness.js

@@ -3,14 +3,9 @@ import { containedRegularFile, hasSymlinkComponent } from '../control-state/cont
 import { artefactFileDigest } from '../control-state/run-seal-compute.js';
 import { readAuthoredContent, readReportDecision } from './report-decision.js';
 import { inspectQaReports } from './qa-follow-up.js';
+import { isDecisionContentPlaceholder } from './decision-content-placeholder.js';
 
-const prompts = new Set(['describe the trustworthy outcome.', 'what outcome should become possible?',
-  'which tp tasks are fully done, partially done or not done?', 'what remains unverified?', 'which risks remain and what is their impact?']);
-export function isDecisionContentPlaceholder(value) {
-  if (typeof value !== 'string') return true;
-  const text = value.trim().replace(/^`([^`]+)`$/u, '$1').replace(/\s+/gu, ' ').toLowerCase();
-  return !text || prompts.has(text) || /^(?:todo|tbd|<[^>]+>|(?:draft|done|ready|blocked|pass|revise|block)(?:\s*\|\s*(?:draft|done|ready|blocked|pass|revise|block))+)$/.test(text);
-}
+export { isDecisionContentPlaceholder };
 export function concreteDecisionContent(value, { allowNone = false } = {}) {
   return typeof value === 'string' && value.length <= 1200 && !isDecisionContentPlaceholder(value)
     && !/^(?:pass|passed|revise|block|done|ready|draft)$/iu.test(value.trim())

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/definition-sources.js

@@ -1,3 +1,4 @@
+import { runDocumentPath } from '../control-state/run-identity.js';
 import { readFileSync } from '../control-read/fs.js';
 import { hasSymlinkComponent, containedRegularFile } from '../control-state/contained-file.js';
 import { artefactFileDigest } from '../control-state/run-seal-compute.js';
@@ -14,7 +15,7 @@ export function inspectUxIntentDecision(content) {
 export function inspectDefinitionSources(root, state, runId, gate, sourceTypes) {
   const sources = [];
   const issue = (code, path, expected, observed, repairable = false) => ({ sources, issue: { code, path, expected, observed, repairable } });
-  const output = `.agdf/control/artefacts/${runId}/${gate}.md`;
+  const output = `${runDocumentPath(runId, '')}/${gate}.md`;
   if (!state || hasSymlinkComponent(root, output)) return issue('unsafe_destination', output, 'contained non-symlink output', 'unsafe');
   for (const type of sourceTypes) {
     const path = String(state.artefacts.get(type)?.path ?? '').replace(/^`|`$/gu, '');
@@ -29,7 +30,7 @@ export function inspectDefinitionSources(root, state, runId, gate, sourceTypes)
   const reviewSource = sources.find(source => source.type === 'Brownfield Review');
   const review = reviewSource ? readFileSync(containedRegularFile(root, reviewSource.path).path, 'utf8') : '';
   if (extractField(review, 'ux_intent_definition_required') === 'yes') {
-    const canonical = `.agdf/control/artefacts/${runId}/UX_INTENT_DEFINITION.md`;
+    const canonical = `${runDocumentPath(runId, '')}/UX_INTENT_DEFINITION.md`;
     const analysis = state.artefacts.get('UX Intent Definition');
     const path = String(analysis?.path || canonical).replace(/^`|`$/gu, '');
     if (path !== canonical || hasSymlinkComponent(root, path)) return issue('unsafe_ux_source', path, canonical, 'foreign or unsafe source');

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-evaluation/delivery-map.js

@@ -1,5 +1,3 @@
-import { existsSync } from "../control-read/fs.js";
-import { join } from 'node:path';
 import { aggregate } from "../control-state/aggregate.js";
 import { resolveRuns } from "../control-state/run-state-resolver.js";
 import { resolveConfiguredChatLanguage } from "../resources/context.js";
@@ -7,7 +5,7 @@ import { isGateSatisfied, transitionDecisionForRunState } from "./gate-policy.js
 import { effectiveNextAllowedAction } from "./next-action.js";
 import { gateApprovalStatus, readRunState, resolvedArtefactFile } from "./run-state.js";
 import { deliveryRelationships, relationshipRequired, sameRelationship } from "./delivery-relationships.js";
-import { allowNoActiveRuns, filled, markdownSection, parseBacklogSection, readTargetFile } from "./shared.js";
+import { allowNoActiveRuns, filled } from "./shared.js";
 import { evaluateReconciliationState } from "./parent-reconciliation.js";
 import { readSourceRevisions, sourceRevisionObservation } from "../control-state/run-source-revisions.js";
 import { readArtefactBindings } from "../control-state/artefact-bindings.js";
@@ -153,14 +151,6 @@ export function deriveQualityOutlook(runState, findings = []) {
   return "No additional quality follow-up identified from the current control state.";
 }
 
-function readBacklogPointers(targetDir) {
-  const backlogPath = join(".agdf", "control", "MASTER_BACKLOG.md");
-  if (!existsSync(join(targetDir, backlogPath))) return [];
-
-  const backlog = readTargetFile(targetDir, backlogPath);
-  const activeSection = markdownSection(backlog, "Active Backlog");
-  return parseBacklogSection(activeSection);
-}
 
 export function evaluateDeliveryMap(targetDir, selection = {}, dependencies = {}) {
   const { evaluateDoctor, buildStatusCard, postApprovalTransition } = dependencies;
@@ -253,7 +243,7 @@ export function evaluateDeliveryMap(targetDir, selection = {}, dependencies = {}
       chatLanguage: resolveConfiguredChatLanguage(targetDir),
       findings: map.findings,
     }),
-    backlog_pointers: readBacklogPointers(targetDir),
+    backlog_pointers: [], // Legacy field: current relationships come from registered Run sources.
     artefacts: Object.fromEntries([...runState.artefacts.entries()]),
     approvals: Object.fromEntries([...runState.approvals.entries()]),
     mode_slice_decision: runState.mode_slice_decision,