create-agdf 0.14.5 → 0.20.1

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/control-state/run-text.js

@@ -0,0 +1,8 @@
+// Pure text normalization shared by source and seal readers; preserves the existing byte semantics.
+export function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, "\n");
+}
+
+export function canonicalRunText(content) {
+  return normalizeLineEndings(String(content ?? "")).replace(/^/u, "");
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/delivery-continuation/service.js

@@ -0,0 +1,67 @@
+import process from "node:process";
+import { evaluateGateCheck } from "../control-evaluation/gate-check.js";
+import { correctRunRelationship } from "../control-state/run-relationship-correction.js";
+import { DISPATCH_RECOVERY } from "../interaction-catalog.js";
+import { localePack } from "../interaction-presentation.js";
+import { createSkillDispatchFailure, createSkillDispatchService } from "../skill-dispatch/service.js";
+
+// Application owner for authorized continuation. Routing itself remains read-only.
+// Neither the initial route nor a correction refusal is emitted until this call returns.
+export function createDeliveryContinuationService(dependencies = {}) {
+  const route = createSkillDispatchService(dependencies);
+  const evaluateGate = dependencies.evaluateGateCheck ?? evaluateGateCheck;
+  const correct = dependencies.correctRunRelationship ?? correctRunRelationship;
+  const now = dependencies.now ?? (() => process.hrtime.bigint());
+  const elapsed = start => Math.round(Math.max(0, Number(now() - start) / 1_000_000) * 1000) / 1000;
+
+  return function executeDeliveryContinuation(rawInput) {
+    const started = now();
+    const initial = route(rawInput);
+    // A successful route supplies the validated intent, target and exact control binding.
+    // Invalid, unresolved, stale-assignment, status and judgement routes cannot mutate.
+    if (rawInput.continueDelivery !== true || initial.outcome !== "control_result"
+        || initial.skill?.dispatch_mode !== "deterministic_control"
+        || initial.target?.resolution_state !== "resolved"
+        || initial.control?.run_id !== rawInput.runId || !initial.control?.revision_id
+        || initial.control.blocking_reason !== "AGDF_DELIVERY_RELATIONSHIP_MISSING") return initial;
+
+    const correctionStarted = now();
+    let correction;
+    const fail = details => createSkillDispatchFailure({
+      skill: initial.skill, runtime: initial.runtime,
+      timing: { ...initial.timing, control_ms: initial.timing.control_ms + elapsed(correctionStarted), total_ms: elapsed(started) },
+      code: DISPATCH_RECOVERY.control_evaluation_failed, details,
+      interactionLocales: rawInput.interactionLocales, presentationLanguage: rawInput.presentationLanguage,
+      renderRecovery: dependencies.renderSkillDispatchRecovery,
+    });
+    try {
+      correction = correct(initial.target.governance_target, {
+        runId: initial.control.run_id, revisionId: initial.control.revision_id,
+      }, { evaluateGateCheck: evaluateGate });
+      if (correction.reason === "correction_commit_unconfirmed") {
+        return fail(`AGDF_CORRECTION_COMMIT_UNCONFIRMED: ${correction.run_id}; committed revision ${correction.revision_id}.`);
+      }
+      if (correction.outcome !== "corrected") {
+        initial.timing.control_ms += elapsed(correctionStarted);
+        initial.timing.total_ms = elapsed(started);
+        return initial;
+      }
+      const correctionMs = elapsed(correctionStarted);
+      // Reuse the resolved target; evaluate the committed run afresh and route exactly once.
+      const freshRoute = createSkillDispatchService({ ...dependencies,
+        resolveTaskTarget: () => initial.target,
+        evaluateGateCheck: (root, selection) => {
+          const report = evaluateGate(root, selection);
+          return { ...report, relationship_correction: { ...correction,
+            message: localePack(rawInput.interactionLocales ?? dependencies.pluginDefinition?.interactionLocales,
+              report.status_card?.presentation_language ?? rawInput.presentationLanguage).operationalValues.relationshipCorrected } };
+        },
+      });
+      const result = freshRoute(rawInput);
+      for (const field of ["input_ms", "target_ms", "control_ms", "render_ms"]) result.timing[field] += initial.timing[field];
+      result.timing.control_ms += correctionMs;
+      result.timing.total_ms = elapsed(started);
+      return result;
+    } catch { return fail(); }
+  };
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/index.js

@@ -0,0 +1,14 @@
+import { resources } from "./resources/context.js";
+import { readRuntimeContract, readSkillRuntimeContracts } from "./resources/contracts.js";
+import { createDeliveryContinuationService } from "./delivery-continuation/service.js";
+import { createControlInspectService } from "./control-inspect/service.js";
+import { createRunCommandService } from "./control-state/run-command-service.js";
+export { createResourceContext, resources } from "./resources/context.js";
+export function createCoreServices({ resources: context = resources, observers = {}, runtimeBinding } = {}) {
+  const contracts = { readRuntimeContract: module => readRuntimeContract(module, { context }), readSkillRuntimeContracts: skill => readSkillRuntimeContracts(skill, { context }) };
+  return Object.freeze({ ...contracts, resources: context, runtimeBinding,
+    dispatch: createDeliveryContinuationService({ ...observers, ...contracts, pluginDefinition: context.pluginDefinition }),
+    inspect: createControlInspectService({ ...observers, ...contracts }),
+    command: createRunCommandService({ packageVersion: context.pluginDefinition.version, enabledGroups: observers.commandGroups, runtimeControl: observers.runtimeControl }),
+  });
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/interaction-catalog-validation.js

@@ -0,0 +1,26 @@
+import { INSTALL_SETUP_STATES, INSTALL_ACTIONS, INSTALL_FAILURE_PHASES, INSTALL_FAILURE_CODES,
+  DISPATCH_RECOVERY_CODES, CODEX_HOOK_STATES, DECISION_CARD_LABEL_KEYS, FLOW_EVIDENCE_LABEL_KEYS } from "./interaction-catalog.js";
+
+// Build-time validation, not a second vocabulary. Unknown and missing copy both fail closed.
+export function validateInteractionCatalog(registry) {
+  const check = (path, values, expected) => {
+    if (!values || Object.keys(values).sort().join("\n") !== [...expected].sort().join("\n")
+        || Object.values(values).some(value => typeof value !== "string" || !value.trim())) {
+      throw new Error(`AGDF_INTERACTION_CATALOG_INCOMPLETE: ${path}`);
+    }
+  };
+  if (!registry?.locales?.en || !registry.locales.de) throw new Error("AGDF_INTERACTION_CATALOG_LOCALES_MISSING");
+  for (const [language, pack] of Object.entries(registry.locales)) {
+    for (const [section, keys] of Object.entries({ effectiveStates: Object.keys(INSTALL_SETUP_STATES),
+      actions: INSTALL_ACTIONS, failurePhases: INSTALL_FAILURE_PHASES, failureCodes: INSTALL_FAILURE_CODES })) {
+      check(`${language}.installSetup.${section}`, pack.installSetup?.[section], keys);
+    }
+    check(`${language}.skillDispatch.recoveries`, pack.skillDispatch?.recoveries, DISPATCH_RECOVERY_CODES);
+    check(`${language}.decisionCard`, pack.decisionCard, DECISION_CARD_LABEL_KEYS);
+    check(`${language}.flowEvidence`, pack.flowEvidence, FLOW_EVIDENCE_LABEL_KEYS);
+  }
+  for (const row of Object.values(CODEX_HOOK_STATES)) {
+    if (!INSTALL_SETUP_STATES[row.state]?.actions.includes(row.action)) throw new Error("AGDF_INTERACTION_CATALOG_HOOK_INVALID");
+  }
+  return true;
+}

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/interaction-catalog.d.ts

@@ -0,0 +1,2 @@
+export const DECISION_CARD_LABEL_KEYS: readonly string[];
+export const DECISION_CARD_COPY_BUDGETS: Readonly<Record<string, 'title' | 'description' | 'label'>>;

package/generated/plugins/agdf/runtime/create-agdf/runtime/core/lib/interaction-catalog.js

@@ -0,0 +1,98 @@
+// Canonical machine vocabulary. Copy lives only in the locale registry.
+// Consumers derive allowed values from this owner; CI checks every locale against it.
+function freeze(value) {
+  if (value && typeof value === "object") {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+  }
+  return value;
+}
+export const INSTALL_SETUP_STATES = freeze({
+  cancelled: { result: "cancelled", actions: ["cancelled"] },
+  control_migration_required: { result: "partial", actions: ["migrate_control"] },
+  control_repair_required: { result: "partial", actions: ["repair_control"] },
+  plugin_ready_mcp_absent: { result: "success", actions: ["restart_host"] },
+  plugin_ready_mcp_in_plugin: { result: "success", actions: ["restart_host"] },
+  mcp_ready_hook_review_required: { result: "partial", actions: ["review_codex_hook"] },
+  mcp_ready_hook_verification_pending: { result: "partial", actions: ["enable_codex_hook", "verify_codex_hook", "inspect_codex_hook"] },
+  plugin_ready_mcp_unchanged: { result: "success", actions: ["restart_host"] },
+  configured_pending_restart: { result: "success", actions: ["restart_host"] },
+  configured_unverified: { result: "success", actions: ["verify_host_discovery"] },
+  discovered_ready: { result: "success", actions: ["none"] },
+  partial: { result: "partial", actions: ["retry_mcp", "retry_plugin", "review_runtime_checks", "resolve_mcp_registration"] },
+  degraded_or_foreign: { result: "partial", actions: ["resolve_mcp_registration"] },
+  failed: { result: "failed", actions: ["retry_plugin", "resolve_mcp_registration", "choose_plugin_only_or_cancel"] },
+});
+export const INSTALL_FAILURE_PHASES = freeze([
+  "input_validation",
+  "setup_preflight",
+  "setup_selection",
+  "runtime_check_permission",
+  "plugin_operation",
+  "plugin_verification",
+  "mcp_preflight",
+  "mcp_enable",
+  "mcp_disable",
+  "plugin_disable",
+  "plugin_uninstall",
+  "result_validation",
+  "presentation",
+]);
+export const INSTALL_FAILURE_CODES = freeze([
+  "input_invalid",
+  "setup_preflight_failed",
+  "setup_selection_blocked",
+  "runtime_check_permission_failed",
+  "plugin_operation_failed",
+  "plugin_verification_failed",
+  "mcp_preflight_failed",
+  "mcp_enable_failed",
+  "mcp_disable_failed",
+  "plugin_disable_failed",
+  "plugin_uninstall_failed",
+  "result_invalid",
+  "presentation_failed",
+]);
+export const INSTALL_ACTIONS = freeze([...new Set(Object.values(INSTALL_SETUP_STATES).flatMap(row => row.actions))]);
+
+export const DISPATCH_RECOVERY_CODES = freeze([
+  "target_evaluation_failed", "target_presentation_failed", "control_evaluation_failed",
+  "control_presentation_failed", "runtime_contracts_unavailable", "runtime_evidence_invalid",
+  "internal_failure", "output_too_large", "intake_run_collision", "intake_scaffold_required",
+  "run_assignment_inventory_invalid", "prd_authoring_inputs_invalid", "sd_authoring_inputs_invalid", "tp_authoring_inputs_invalid",
+  "AGDF_ARTEFACT_TEMPLATE_UNSUPPORTED", "AGDF_ARTEFACT_TEMPLATE_ROOT_UNAVAILABLE",
+  "AGDF_ARTEFACT_TEMPLATE_UNAVAILABLE", "AGDF_ARTEFACT_TEMPLATE_UNSAFE",
+]);
+export const DISPATCH_RECOVERY = freeze(Object.fromEntries(DISPATCH_RECOVERY_CODES.map(code => [code, code])));
+
+export const CODEX_HOOK_STATES = freeze({
+  hook_review_required: { state: "mcp_ready_hook_review_required", action: "review_codex_hook" },
+  hook_disabled: { state: "mcp_ready_hook_verification_pending", action: "enable_codex_hook" },
+  host_unverified: { state: "mcp_ready_hook_verification_pending", action: "inspect_codex_hook" },
+  hook_trusted_session_unverified: { state: "mcp_ready_hook_verification_pending", action: "verify_codex_hook" },
+});
+export function codexHookState(verification) {
+  return Object.hasOwn(CODEX_HOOK_STATES, verification) ? CODEX_HOOK_STATES[verification] : CODEX_HOOK_STATES.host_unverified;
+}
+export const DECISION_CARD_LABEL_KEYS = freeze(['title', 'connecting', 'unavailable', 'approve', 'request_change', 'reject', 'openDocument', 'back',
+  'comment', 'commentHelp', 'pending', 'uncertain', 'checkOperation', 'retryOriginal', 'confirmed', 'denied', 'notQualified', 'sourceChanged',
+  'expired', 'comparison', 'comparisonUnavailable', 'sources', 'run', 'gate', 'revision', 'consequence', 'permission', 'docUnavailable',
+  'commentRequired', 'commentTooLarge', 'documentTitle', 'notSaved', 'unknownCurrent', 'sourceLanguage', 'alreadyDecided', 'initialize',
+  'machineComparison', 'documentUnchanged', 'documentChanged', 'previousDocument', 'discussionHint',
+  'nextStep', 'nextInformation', 'nextChat', 'nextWaiting', 'continuationMessage', 'nextRequested', 'nextUnavailable', 'closeUnavailable', 'chatApprovalHint',
+  'approveWithDeviations', 'confirmedWithDeviations', 'deviationAcceptanceIntro',
+  'openPreview', 'previewTitle', 'previewUnavailable', 'previewChanged', 'retryPreview', 'previewIllustrative',
+  'previewTask', 'previewScenarios', 'previewCriteria', 'previewQuestions', 'previewUnsupported', 'previewLoading']);
+export const FLOW_EVIDENCE_LABEL_KEYS = freeze(['title', 'current', 'superseded', 'applicability_unknown', 'currentDescription', 'emptyDescription',
+  'historyDescription', 'unknownDescription', 'unavailable', 'open', 'next', 'human', 'agent', 'completed', 'unconfirmedDescription', 'retainedDescription']);
+// Classify copy by its UI purpose; the existing global budgets remain unchanged.
+export const DECISION_CARD_COPY_BUDGETS = freeze(Object.fromEntries(DECISION_CARD_LABEL_KEYS.map(key => [key,
+  ['title', 'comparison', 'documentTitle'].includes(key) ? 'title'
+    : ['connecting', 'unavailable', 'commentHelp', 'pending', 'uncertain', 'confirmed', 'denied', 'notQualified',
+      'sourceChanged', 'expired', 'comparisonUnavailable', 'consequence', 'permission', 'docUnavailable',
+      'commentRequired', 'commentTooLarge', 'notSaved', 'unknownCurrent', 'sourceLanguage', 'alreadyDecided', 'initialize',
+      'machineComparison', 'documentUnchanged', 'documentChanged', 'discussionHint',
+      'nextInformation', 'nextChat', 'nextWaiting', 'continuationMessage', 'nextRequested', 'nextUnavailable', 'closeUnavailable', 'chatApprovalHint',
+      'previewUnavailable', 'previewChanged', 'previewIllustrative', 'previewUnsupported'].includes(key)
+      ? 'description' : 'label'
+])));