@neurcode-ai/cli 0.10.1 → 0.14.0

package/dist/governance/pipeline/orchestration/advisory-mode.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Advisory-Mode Orchestration
+ * ---------------------------
+ * Extracts the no-plan / advisory-first branch previously inlined at
+ * `commands/verify.ts:4161–4321`.
+ *
+ * RESPONSIBILITIES (data-pure):
+ *   - resolve auto-contract path when no change-contract is present
+ *   - evaluate advisory signals (with runtime-pressure gating)
+ *   - run structural rules (via the existing structural-analysis stage)
+ *   - compute verdict / grade / score
+ *   - assemble the advisory canonical payload
+ *
+ * EXPLICITLY NOT RESPONSIBLE FOR:
+ *   - human-readable rendering (caller owns chalk + printFirstRunAdvisoryMessage)
+ *   - emitting verify JSON (caller owns emitVerifyJson + emitCanonicalVerifyJson)
+ *   - recording telemetry verdict (caller owns recordVerifyEvent)
+ *   - calling exitWithEvidence (caller owns process termination)
+ *
+ * SEMANTIC PRESERVATION:
+ *   The output `payload` is byte-equivalent to the prior inline literal at
+ *   line ~4276 (the `emitVerifyJson({...})` call). Field order matches the
+ *   inline implementation so JSON serialization is identical.
+ *
+ * REPLAY INVARIANT:
+ *   - structural-analysis stage call is identical to the prior wire-in
+ *   - advisory signals evaluation is identical to the prior call
+ *   - structural-engine fault swallowing is preserved (try/swallow in compute)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAdvisoryMode = runAdvisoryMode;
+const change_contract_1 = require("../../../utils/change-contract");
+const advisory_signals_1 = require("../../../utils/advisory-signals");
+const verify_runtime_stability_1 = require("../../../utils/verify-runtime-stability");
+const advisory_mode_contract_1 = require("./advisory-mode-contract");
+const helpers_1 = require("../helpers");
+const stages_1 = require("../stages");
+const structural_on_diff_1 = require("../../structural-on-diff");
+const ADVISORY_MESSAGE = 'No plan linked yet. Ran advisory verification for quick first-run experience. ' +
+    'Use `neurcode plan` and `neurcode contract import --auto-detect --write-change-contract` for full enforcement.';
+/**
+ * Compute the advisory-mode result. Replaces the inline compute region.
+ *
+ * Does not emit JSON, does not log, does not exit.
+ */
+async function runAdvisoryMode(input) {
+    const { options, projectRoot, diffFiles, summary, runtimeCtx, changeContractRead, changeContractSummary, strictArtifactMode, pipelineCtx } = input;
+    // ── Auto-contract generation ──────────────────────────────────────────
+    let autoContractPath = null;
+    let updatedChangeContractSummary = changeContractSummary;
+    if (!changeContractRead.contract && !strictArtifactMode) {
+        try {
+            const fallbackPlanId = `advisory_${Date.now()}`;
+            const advisoryContract = (0, advisory_mode_contract_1.buildMinimalAdvisoryContractFromDiff)(diffFiles, fallbackPlanId);
+            autoContractPath = (0, change_contract_1.writeChangeContract)(projectRoot, advisoryContract, options.changeContract);
+            updatedChangeContractSummary = {
+                path: autoContractPath,
+                exists: true,
+                enforced: false,
+                valid: true,
+                planId: advisoryContract.planId,
+                contractId: advisoryContract.contractId,
+                coverage: {
+                    expectedFiles: advisoryContract.expectedFiles.length,
+                    changedFiles: diffFiles.length,
+                    outOfContractFiles: 0,
+                    missingExpectedFiles: 0,
+                    blockedFilesTouched: 0,
+                    actionMismatches: 0,
+                    expectedSymbols: advisoryContract.expectedSymbols?.length || 0,
+                    changedSymbols: 0,
+                    missingExpectedSymbols: 0,
+                    blockedSymbolsTouched: 0,
+                    symbolActionMismatches: 0,
+                    symbolRenameMatches: 0,
+                    toleratedUnexpectedFiles: 0,
+                    toleratedMissingExpectedSymbols: 0,
+                },
+                signature: changeContractSummary.signature,
+                violations: [],
+            };
+        }
+        catch {
+            autoContractPath = null;
+        }
+    }
+    // ── Advisory signals ──────────────────────────────────────────────────
+    const advisorySignalsSkipped = (0, verify_runtime_stability_1.shouldSkipAdvisoryLayer)(runtimeCtx);
+    const advisorySignals = advisorySignalsSkipped
+        ? []
+        : (0, advisory_signals_1.evaluateAdvisorySignals)({ diffFiles, summary });
+    const advisoryWarnCount = advisorySignals.filter(s => s.severity === 'warn').length;
+    // ── Structural rules (advisory) ───────────────────────────────────────
+    let advisoryStructuralViolations = [];
+    let advisoryStructuralBlockingCount = 0;
+    try {
+        const structuralResult = await (0, helpers_1.runStageOrFallback)(stages_1.structuralAnalysisStage, { projectRoot, diffFiles }, pipelineCtx, () => (0, structural_on_diff_1.runStructuralOnDiffFiles)(projectRoot, diffFiles));
+        advisoryStructuralViolations = structuralResult.violations;
+        advisoryStructuralBlockingCount = structuralResult.violations.filter(v => v.severity === 'BLOCKING').length;
+    }
+    catch {
+        // Structural engine failure must never block advisory verify.
+    }
+    // ── Verdict / grade / score ──────────────────────────────────────────
+    const hasFlags = advisoryWarnCount > 0 || advisoryStructuralBlockingCount > 0;
+    const advisoryVerdict = hasFlags ? 'WARN' : 'PASS';
+    const advisoryGrade = hasFlags ? 'C' : 'B';
+    const advisoryScore = hasFlags ? 60 : 70;
+    // ── Build violations array (advisory shape) ──────────────────────────
+    const advisoryViolations = [
+        ...advisorySignals.map(item => ({
+            file: item.files[0] || '.',
+            rule: `advisory:${item.code.toLowerCase()}`,
+            severity: item.severity === 'warn' ? 'warn' : 'allow',
+            message: `${item.title}: ${item.detail}`,
+        })),
+        ...advisoryStructuralViolations.map(v => ({
+            file: v.filePath,
+            rule: `structural-advisory:${v.ruleId.toLowerCase()}`,
+            severity: 'warn',
+            message: `${v.ruleId} ${v.ruleName}: ${v.evidence.slice(0, 100)} (advisory — link plan to enforce)`,
+        })),
+    ];
+    // ── Canonical advisory payload assembly ──────────────────────────────
+    const payload = {
+        grade: advisoryGrade,
+        score: advisoryScore,
+        verdict: advisoryVerdict,
+        violations: advisoryViolations,
+        adherenceScore: advisoryScore,
+        bloatCount: 0,
+        bloatFiles: [],
+        plannedFilesModified: 0,
+        totalPlannedFiles: 0,
+        message: ADVISORY_MESSAGE,
+        scopeGuardPassed: true,
+        mode: 'advisory_missing_plan',
+        advisoryMode: true,
+        advisorySignals,
+        structuralViolations: advisoryStructuralViolations,
+        structuralBlockingCount: advisoryStructuralBlockingCount,
+        ...(advisoryStructuralBlockingCount > 0
+            ? {
+                structuralNote: `${advisoryStructuralBlockingCount} structural finding(s) surfaced in advisory mode. Link a plan to enforce.`,
+            }
+            : {}),
+        policyOnly: true,
+        policyOnlySource: 'fallback_missing_plan',
+        ...(autoContractPath
+            ? { changeContract: { ...updatedChangeContractSummary, path: autoContractPath } }
+            : { changeContract: changeContractSummary }),
+    };
+    return {
+        payload,
+        telemetry: {
+            verdict: advisoryVerdict,
+            detail: `advisory_missing_plan;signals=${advisorySignals.length};warn=${advisoryWarnCount}`,
+            files: diffFiles.map(f => f.path),
+        },
+        autoContractPath,
+        message: ADVISORY_MESSAGE,
+        updatedChangeContractSummary,
+        advisorySignals,
+        advisoryStructuralViolations,
+        advisoryStructuralBlockingCount,
+        advisorySignalsSkipped,
+    };
+}
+//# sourceMappingURL=advisory-mode.js.map

package/dist/governance/pipeline/orchestration/advisory-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advisory-mode.js","sourceRoot":"","sources":["../../../../src/governance/pipeline/orchestration/advisory-mode.ts"],"names":[],"mappings":"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"}

package/dist/governance/pipeline/orchestration/evidence-lifecycle.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Evidence Lifecycle Runtime
+ * --------------------------
+ * Extracts the closure-heavy evidence/finalize plumbing previously inlined at
+ * `commands/verify.ts:2816–2905`. The original implementation captured five
+ * pieces of mutable state via closure (`lastCanonicalOutput`,
+ * `lastEvidenceFallbackOutput`, `evidenceFinalizeAttempted`,
+ * `verifyStartedAtMs`, `lastProvenanceRunId`) and exposed three lambdas
+ * (`captureEvidencePayload`, `finalizeEvidence`, `exitWithEvidence`).
+ *
+ * This module replaces that pattern with a typed, explicit holder object so:
+ *   - lifecycle state is replay-visible (not hidden inside a closure)
+ *   - finalize idempotency is enforced at the type level
+ *   - the caller decides termination policy (we DO NOT call process.exit here)
+ *   - degraded persistence (write failure, missing payload) is explicit
+ *
+ * Semantic preservation:
+ *   - finalize is called at most once (existing invariant)
+ *   - write failure is swallowed and (in non-JSON mode) reported (existing)
+ *   - calibration telemetry call (`appendVerifyCompletedFromCanonical`) is
+ *     wrapped in try/catch (existing)
+ *   - process.exit is INVOKED BY THE CALLER, not by this module
+ *
+ * Replay invariant:
+ *   The evidence artifact written by `runEvidenceFinalize` is byte-identical
+ *   to what the prior closure wrote, for any given lifecycle state. The
+ *   transition `appendVerifyCompletedFromCanonical(...)` happens at the same
+ *   point (after finalize, before exit) so telemetry semantics are preserved.
+ */
+import type { VerificationEvidenceContext } from '../../../utils/verification-evidence';
+/**
+ * Replay-visible lifecycle state. Replaces the four mutable `let`s previously
+ * declared at the top of `verifyCommand`.
+ *
+ * Mutated by `captureEvidencePayload`, `setProvenanceRunId`, and
+ * `runEvidenceFinalize` — never by external callers.
+ */
+export interface EvidenceLifecycleState {
+    /** Last canonical (toCanonicalVerifyOutput-shaped) payload observed. */
+    lastCanonicalOutput: Record<string, unknown> | null;
+    /** Last raw verify payload observed (fallback used when canonical is null). */
+    lastEvidenceFallbackOutput: Record<string, unknown> | null;
+    /** True once finalize has been attempted (success OR failure); idempotent. */
+    finalizeAttempted: boolean;
+    /** Provenance run ID written during normal flow; null until set. */
+    lastProvenanceRunId: string | null;
+}
+/**
+ * Static configuration for the lifecycle. Captured once when verify starts.
+ */
+export interface EvidenceLifecycleConfig {
+    enabled: boolean;
+    projectRoot: string;
+    startedAtMs: number;
+    ciMode: boolean;
+    deterministicMode: boolean;
+    evidenceDir?: string;
+    ciContext: VerificationEvidenceContext;
+    /** Runtime-metadata block embedded in the evidence artifact. */
+    runtimeMetadata: {
+        cliJsonContractVersion: string;
+        runtimeCompatibilityContractVersion: string;
+        componentVersion: string;
+        nodeVersion: string;
+        platform: string;
+        arch: string;
+        command: string;
+    };
+    /** JSON mode flag — controls whether finalize-failure prints to stderr. */
+    jsonMode: boolean;
+    /**
+     * Caller-supplied chalk-dimming logger for the success path. The original
+     * implementation used `chalk.dim` from `commands/verify.ts`; we delegate to
+     * the caller so this module stays chalk-free.
+     */
+    reportArtifactPath?: (path: string) => void;
+    /** Caller-supplied warning logger for finalize-failure (non-JSON mode). */
+    reportFinalizeFailure?: (message: string) => void;
+    /**
+     * Caller-supplied canonical-form transformer. The original verify.ts
+     * function `toCanonicalVerifyOutput` is passed in to avoid a circular
+     * dependency between this module and the command file. Required.
+     */
+    toCanonicalVerifyOutput: (payload: Record<string, unknown>) => Record<string, unknown>;
+}
+/**
+ * Create a fresh lifecycle state. Replaces the four `let` declarations at the
+ * top of `verifyCommand`.
+ */
+export declare function createEvidenceLifecycleState(): EvidenceLifecycleState;
+/**
+ * Record a verify payload into the lifecycle state. Computes the canonical
+ * representation eagerly so finalize can write either form. Replaces the
+ * `captureEvidencePayload` closure.
+ *
+ * Pure side-effect on the state object — no I/O.
+ */
+export declare function captureEvidencePayload(state: EvidenceLifecycleState, config: Pick<EvidenceLifecycleConfig, 'toCanonicalVerifyOutput'>, payload: Record<string, unknown>): void;
+/**
+ * Set the provenance run ID. Replaces the inline mutation `lastProvenanceRunId = ...`.
+ */
+export declare function setProvenanceRunId(state: EvidenceLifecycleState, runId: string | null): void;
+/**
+ * Result of finalizing the evidence lifecycle. Surfaced so the caller can
+ * print to stdout in non-JSON mode and trace the lifecycle in replay tools.
+ */
+export interface EvidenceFinalizeResult {
+    attempted: boolean;
+    skipped: boolean;
+    /** Reason for skip when `skipped` is true. */
+    skipReason?: 'disabled' | 'already-attempted';
+    /** Path of the written evidence artifact when persistence succeeded. */
+    artifactPath: string | null;
+    /** Error message when persistence failed. */
+    error?: string;
+}
+/**
+ * Run the evidence-finalize lifecycle. Replaces the `finalizeEvidence` closure.
+ *
+ * Idempotent: subsequent calls return `{ attempted: true, skipped: true }`.
+ * Never throws — failures are surfaced via the returned `error` field and the
+ * configured warning logger.
+ */
+export declare function runEvidenceFinalize(state: EvidenceLifecycleState, config: EvidenceLifecycleConfig, exitCode: number): EvidenceFinalizeResult;
+/**
+ * Run the telemetry-calibration emission. Replaces the inline call
+ * `appendVerifyCompletedFromCanonical(projectRoot, lastCanonicalOutput,
+ * lastProvenanceRunId)` previously inside the `exitWithEvidence` closure.
+ *
+ * Never throws — calibration must not affect verify exit.
+ */
+export declare function emitCalibrationTelemetry(state: EvidenceLifecycleState, config: Pick<EvidenceLifecycleConfig, 'projectRoot'>): void;
+//# sourceMappingURL=evidence-lifecycle.d.ts.map

package/dist/governance/pipeline/orchestration/evidence-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-lifecycle.d.ts","sourceRoot":"","sources":["../../../../src/governance/pipeline/orchestration/evidence-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EACV,2BAA2B,EAC5B,MAAM,sCAAsC,CAAC;AAM9C;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,wEAAwE;IACxE,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACpD,+EAA+E;IAC/E,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC3D,8EAA8E;IAC9E,iBAAiB,EAAE,OAAO,CAAC;IAC3B,oEAAoE;IACpE,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,2BAA2B,CAAC;IACvC,gEAAgE;IAChE,eAAe,EAAE;QACf,sBAAsB,EAAE,MAAM,CAAC;QAC/B,mCAAmC,EAAE,MAAM,CAAC;QAC5C,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,2EAA2E;IAC3E,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD;;;;OAIG;IACH,uBAAuB,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxF;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,sBAAsB,CAOrE;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,sBAAsB,EAC7B,MAAM,EAAE,IAAI,CAAC,uBAAuB,EAAE,yBAAyB,CAAC,EAChE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,IAAI,CAGN;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,IAAI,CAEN;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,UAAU,GAAG,mBAAmB,CAAC;IAC9C,wEAAwE;IACxE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,sBAAsB,EAC7B,MAAM,EAAE,uBAAuB,EAC/B,QAAQ,EAAE,MAAM,GACf,sBAAsB,CAiCxB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,sBAAsB,EAC7B,MAAM,EAAE,IAAI,CAAC,uBAAuB,EAAE,aAAa,CAAC,GACnD,IAAI,CAUN"}

package/dist/governance/pipeline/orchestration/evidence-lifecycle.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * Evidence Lifecycle Runtime
+ * --------------------------
+ * Extracts the closure-heavy evidence/finalize plumbing previously inlined at
+ * `commands/verify.ts:2816–2905`. The original implementation captured five
+ * pieces of mutable state via closure (`lastCanonicalOutput`,
+ * `lastEvidenceFallbackOutput`, `evidenceFinalizeAttempted`,
+ * `verifyStartedAtMs`, `lastProvenanceRunId`) and exposed three lambdas
+ * (`captureEvidencePayload`, `finalizeEvidence`, `exitWithEvidence`).
+ *
+ * This module replaces that pattern with a typed, explicit holder object so:
+ *   - lifecycle state is replay-visible (not hidden inside a closure)
+ *   - finalize idempotency is enforced at the type level
+ *   - the caller decides termination policy (we DO NOT call process.exit here)
+ *   - degraded persistence (write failure, missing payload) is explicit
+ *
+ * Semantic preservation:
+ *   - finalize is called at most once (existing invariant)
+ *   - write failure is swallowed and (in non-JSON mode) reported (existing)
+ *   - calibration telemetry call (`appendVerifyCompletedFromCanonical`) is
+ *     wrapped in try/catch (existing)
+ *   - process.exit is INVOKED BY THE CALLER, not by this module
+ *
+ * Replay invariant:
+ *   The evidence artifact written by `runEvidenceFinalize` is byte-identical
+ *   to what the prior closure wrote, for any given lifecycle state. The
+ *   transition `appendVerifyCompletedFromCanonical(...)` happens at the same
+ *   point (after finalize, before exit) so telemetry semantics are preserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvidenceLifecycleState = createEvidenceLifecycleState;
+exports.captureEvidencePayload = captureEvidencePayload;
+exports.setProvenanceRunId = setProvenanceRunId;
+exports.runEvidenceFinalize = runEvidenceFinalize;
+exports.emitCalibrationTelemetry = emitCalibrationTelemetry;
+const verification_evidence_1 = require("../../../utils/verification-evidence");
+const telemetry_1 = require("@neurcode-ai/telemetry");
+/**
+ * Create a fresh lifecycle state. Replaces the four `let` declarations at the
+ * top of `verifyCommand`.
+ */
+function createEvidenceLifecycleState() {
+    return {
+        lastCanonicalOutput: null,
+        lastEvidenceFallbackOutput: null,
+        finalizeAttempted: false,
+        lastProvenanceRunId: null,
+    };
+}
+/**
+ * Record a verify payload into the lifecycle state. Computes the canonical
+ * representation eagerly so finalize can write either form. Replaces the
+ * `captureEvidencePayload` closure.
+ *
+ * Pure side-effect on the state object — no I/O.
+ */
+function captureEvidencePayload(state, config, payload) {
+    state.lastEvidenceFallbackOutput = payload;
+    state.lastCanonicalOutput = config.toCanonicalVerifyOutput(payload);
+}
+/**
+ * Set the provenance run ID. Replaces the inline mutation `lastProvenanceRunId = ...`.
+ */
+function setProvenanceRunId(state, runId) {
+    state.lastProvenanceRunId = runId;
+}
+/**
+ * Run the evidence-finalize lifecycle. Replaces the `finalizeEvidence` closure.
+ *
+ * Idempotent: subsequent calls return `{ attempted: true, skipped: true }`.
+ * Never throws — failures are surfaced via the returned `error` field and the
+ * configured warning logger.
+ */
+function runEvidenceFinalize(state, config, exitCode) {
+    if (!config.enabled) {
+        return { attempted: false, skipped: true, skipReason: 'disabled', artifactPath: null };
+    }
+    if (state.finalizeAttempted) {
+        return { attempted: true, skipped: true, skipReason: 'already-attempted', artifactPath: null };
+    }
+    state.finalizeAttempted = true;
+    try {
+        const artifactPath = (0, verification_evidence_1.writeVerificationEvidence)({
+            enabled: config.enabled,
+            projectRoot: config.projectRoot,
+            startedAtMs: config.startedAtMs,
+            exitCode,
+            ciMode: config.ciMode,
+            deterministicMode: config.deterministicMode,
+            evidenceDir: config.evidenceDir,
+            canonicalOutput: state.lastCanonicalOutput,
+            fallbackOutput: state.lastEvidenceFallbackOutput,
+            ciContext: config.ciContext,
+            runtimeMetadata: config.runtimeMetadata,
+        });
+        if (artifactPath && !config.jsonMode && config.reportArtifactPath) {
+            config.reportArtifactPath(artifactPath);
+        }
+        return { attempted: true, skipped: false, artifactPath: artifactPath ?? null };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!config.jsonMode && config.reportFinalizeFailure) {
+            config.reportFinalizeFailure(message);
+        }
+        return { attempted: true, skipped: false, artifactPath: null, error: message };
+    }
+}
+/**
+ * Run the telemetry-calibration emission. Replaces the inline call
+ * `appendVerifyCompletedFromCanonical(projectRoot, lastCanonicalOutput,
+ * lastProvenanceRunId)` previously inside the `exitWithEvidence` closure.
+ *
+ * Never throws — calibration must not affect verify exit.
+ */
+function emitCalibrationTelemetry(state, config) {
+    try {
+        (0, telemetry_1.appendVerifyCompletedFromCanonical)(config.projectRoot, state.lastCanonicalOutput, state.lastProvenanceRunId);
+    }
+    catch {
+        // calibration must never affect exit
+    }
+}
+//# sourceMappingURL=evidence-lifecycle.js.map

package/dist/governance/pipeline/orchestration/evidence-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-lifecycle.js","sourceRoot":"","sources":["../../../../src/governance/pipeline/orchestration/evidence-lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/governance/pipeline/orchestration/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pipeline orchestration extractions — public re-exports.
+ *
+ * Each module in this directory is a typed, replay-aware extraction of an
+ * orchestration region previously inlined in `commands/verify.ts`. The goal
+ * is to reduce orchestration concentration in verify.ts while preserving
+ * byte-for-byte semantics (replay checksum, finding identity, JSON shape).
+ */
+export { runAdvisoryMode, type AdvisoryChangeContractSummary, type AdvisoryModeInput, type AdvisoryModeResult, } from './advisory-mode';
+export { buildMinimalAdvisoryContractFromDiff, } from './advisory-mode-contract';
+export { captureEvidencePayload, createEvidenceLifecycleState, emitCalibrationTelemetry, runEvidenceFinalize, setProvenanceRunId, type EvidenceFinalizeResult, type EvidenceLifecycleConfig, type EvidenceLifecycleState, } from './evidence-lifecycle';
+export { runPlanStructuralAnalysis, type PlanStructuralAnalysisInput, type PlanStructuralAnalysisResult, } from './plan-structural-analysis';
+export { runScopeGuardOrchestration, type ScopeGuardOrchestrationInput, type ScopeGuardOrchestrationResult, type ScopeGuardPlanClient, type ScopeGuardLocalPlan, type ScopeGuardSigningParams, type SessionResolutionNote, } from './scope-guard-orchestration';
+export { buildPolicyEvaluationSummaries, type PolicyEvaluationSummariesInput, type PolicyEvaluationSummariesResult, type PolicyExceptionsSummary, type PolicyGovernanceSummary, type PolicyExceptionResolutionSummary, type ExceptionApprovalConfig, type GovernanceAuditConfig, type AuditIntegrityData, } from './policy-evaluation-summaries';
+export { runIntentDriftOrchestration, type IntentDriftOrchestrationInput, type IntentDriftOrchestrationResult, } from './intent-drift-orchestration';
+//# sourceMappingURL=index.d.ts.map

package/dist/governance/pipeline/orchestration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/governance/pipeline/orchestration/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,eAAe,EACf,KAAK,6BAA6B,EAClC,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,GACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,oCAAoC,GACrC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,GAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,yBAAyB,EACzB,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,GAClC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,0BAA0B,EAC1B,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,GAC3B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,8BAA8B,EAC9B,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,EACpC,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,gCAAgC,EACrC,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,GACxB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,2BAA2B,EAC3B,KAAK,6BAA6B,EAClC,KAAK,8BAA8B,GACpC,MAAM,8BAA8B,CAAC"}

package/dist/governance/pipeline/orchestration/index.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Pipeline orchestration extractions — public re-exports.
+ *
+ * Each module in this directory is a typed, replay-aware extraction of an
+ * orchestration region previously inlined in `commands/verify.ts`. The goal
+ * is to reduce orchestration concentration in verify.ts while preserving
+ * byte-for-byte semantics (replay checksum, finding identity, JSON shape).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIntentDriftOrchestration = exports.buildPolicyEvaluationSummaries = exports.runScopeGuardOrchestration = exports.runPlanStructuralAnalysis = exports.setProvenanceRunId = exports.runEvidenceFinalize = exports.emitCalibrationTelemetry = exports.createEvidenceLifecycleState = exports.captureEvidencePayload = exports.buildMinimalAdvisoryContractFromDiff = exports.runAdvisoryMode = void 0;
+var advisory_mode_1 = require("./advisory-mode");
+Object.defineProperty(exports, "runAdvisoryMode", { enumerable: true, get: function () { return advisory_mode_1.runAdvisoryMode; } });
+var advisory_mode_contract_1 = require("./advisory-mode-contract");
+Object.defineProperty(exports, "buildMinimalAdvisoryContractFromDiff", { enumerable: true, get: function () { return advisory_mode_contract_1.buildMinimalAdvisoryContractFromDiff; } });
+var evidence_lifecycle_1 = require("./evidence-lifecycle");
+Object.defineProperty(exports, "captureEvidencePayload", { enumerable: true, get: function () { return evidence_lifecycle_1.captureEvidencePayload; } });
+Object.defineProperty(exports, "createEvidenceLifecycleState", { enumerable: true, get: function () { return evidence_lifecycle_1.createEvidenceLifecycleState; } });
+Object.defineProperty(exports, "emitCalibrationTelemetry", { enumerable: true, get: function () { return evidence_lifecycle_1.emitCalibrationTelemetry; } });
+Object.defineProperty(exports, "runEvidenceFinalize", { enumerable: true, get: function () { return evidence_lifecycle_1.runEvidenceFinalize; } });
+Object.defineProperty(exports, "setProvenanceRunId", { enumerable: true, get: function () { return evidence_lifecycle_1.setProvenanceRunId; } });
+var plan_structural_analysis_1 = require("./plan-structural-analysis");
+Object.defineProperty(exports, "runPlanStructuralAnalysis", { enumerable: true, get: function () { return plan_structural_analysis_1.runPlanStructuralAnalysis; } });
+var scope_guard_orchestration_1 = require("./scope-guard-orchestration");
+Object.defineProperty(exports, "runScopeGuardOrchestration", { enumerable: true, get: function () { return scope_guard_orchestration_1.runScopeGuardOrchestration; } });
+var policy_evaluation_summaries_1 = require("./policy-evaluation-summaries");
+Object.defineProperty(exports, "buildPolicyEvaluationSummaries", { enumerable: true, get: function () { return policy_evaluation_summaries_1.buildPolicyEvaluationSummaries; } });
+var intent_drift_orchestration_1 = require("./intent-drift-orchestration");
+Object.defineProperty(exports, "runIntentDriftOrchestration", { enumerable: true, get: function () { return intent_drift_orchestration_1.runIntentDriftOrchestration; } });
+//# sourceMappingURL=index.js.map

package/dist/governance/pipeline/orchestration/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/governance/pipeline/orchestration/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,iDAKyB;AAJvB,gHAAA,eAAe,OAAA;AAKjB,mEAEkC;AADhC,8IAAA,oCAAoC,OAAA;AAEtC,2DAS8B;AAR5B,4HAAA,sBAAsB,OAAA;AACtB,kIAAA,4BAA4B,OAAA;AAC5B,8HAAA,wBAAwB,OAAA;AACxB,yHAAA,mBAAmB,OAAA;AACnB,wHAAA,kBAAkB,OAAA;AAKpB,uEAIoC;AAHlC,qIAAA,yBAAyB,OAAA;AAI3B,yEAQqC;AAPnC,uIAAA,0BAA0B,OAAA;AAQ5B,6EAUuC;AATrC,6IAAA,8BAA8B,OAAA;AAUhC,2EAIsC;AAHpC,yIAAA,2BAA2B,OAAA"}

package/dist/governance/pipeline/orchestration/intent-drift-orchestration.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Intent Drift Orchestration
+ * ---------------------------
+ * Wraps the intent-governance module (`governance/intent/*`) into an
+ * orchestration surface consumable by verify.ts. Pattern matches the other
+ * orchestration modules:
+ *
+ *   - Caller hands us inputs (projectRoot, diffFiles, options).
+ *   - We load the contract, run drift detection, return a typed result.
+ *   - We do NOT render, log, or emit JSON. Caller owns presentation.
+ *   - On any internal error, we return a safe empty result. Drift detection
+ *     is opt-in; a malformed contract must never break verification.
+ *
+ * Phase 1 INVARIANT: drift detection is ADVISORY by default. The detector
+ * only emits BLOCK-severity violations when `enforce: true` is passed
+ * explicitly. Callers wishing to enforce must read the contract's
+ * enforcement signal (a future schema field, or an environment opt-in).
+ *
+ * Intelligence classification: DETERMINISTIC (delegated to inner module).
+ */
+import { type DriftReport } from '../../intent';
+import type { DiffFile } from '@neurcode-ai/diff-parser';
+export interface IntentDriftOrchestrationInput {
+    /** Absolute project root. */
+    projectRoot: string;
+    /** Parsed diff files for the current change. */
+    diffFiles: DiffFile[];
+    /** Optional contract path override (relative to projectRoot). */
+    contractPath?: string;
+    /**
+     * When true, forbidden-edge violations are emitted as `block` severity.
+     * Default is `false` — advisory-only, safe-by-default rollout.
+     * Tier-up to enforcement happens via NEURCODE_INTENT_ENFORCE=1 or a future
+     * contract field; callers compute this externally and pass it in.
+     */
+    enforce?: boolean;
+}
+export interface IntentDriftOrchestrationResult {
+    /**
+     * True when a contract file was found and parsed (regardless of contents).
+     * False when the project has no `.neurcode/intent.json` — drift detection
+     * is then skipped and `report` reflects an empty run.
+     */
+    contractPresent: boolean;
+    /** Absolute path of the contract we looked at. */
+    contractPath: string;
+    /** Validation errors encountered while loading the contract, if any. */
+    contractErrors: string[];
+    /** Soft warnings from the loader. */
+    contractWarnings: string[];
+    /** Whether enforcement was active for this run. */
+    enforced: boolean;
+    /** The drift report. Always present, even when no contract was found. */
+    report: DriftReport;
+}
+/**
+ * Run the intent-drift detection orchestration. Safe to call on every verify run.
+ *
+ * Cost model:
+ *   - No contract → ~1ms (filesystem stat + early return).
+ *   - Contract present → proportional to (diff size × layer count). For a typical
+ *     50-file diff against a 5-layer contract, well under 50ms.
+ */
+export declare function runIntentDriftOrchestration(input: IntentDriftOrchestrationInput): IntentDriftOrchestrationResult;
+//# sourceMappingURL=intent-drift-orchestration.d.ts.map

package/dist/governance/pipeline/orchestration/intent-drift-orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-drift-orchestration.d.ts","sourceRoot":"","sources":["../../../../src/governance/pipeline/orchestration/intent-drift-orchestration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAIL,KAAK,WAAW,EAEjB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD,MAAM,WAAW,6BAA6B;IAC5C,6BAA6B;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,8BAA8B;IAC7C;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,qCAAqC;IACrC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,mDAAmD;IACnD,QAAQ,EAAE,OAAO,CAAC;IAClB,yEAAyE;IACzE,MAAM,EAAE,WAAW,CAAC;CACrB;AAID;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,6BAA6B,GACnC,8BAA8B,CAoEhC"}