openplanr 1.16.2 → 1.18.0

package/dist/services/operate/engine.d.ts

@@ -1,5 +1,6 @@
-import { type AdvisorAdapter } from './advisors.js';
-import { type OperatingCycleManifest, type OperatingDataGap, type OperatingDecision, type OperatingEvidence, type OperatingEvidenceReadiness, type OperatingFinding, type OperatingProviderManifest, type OperatingRoleResult, type OperatingRoutePlan, type OperatingState } from './types.js';
+import { type AdvisorAdapter, type AdvisorDispatchResult, type AdvisorOperatingContext } from './advisors.js';
+import type { CitationResolutionContext } from './citation-resolution.js';
+import { type OperatingConfig, type OperatingCycleManifest, type OperatingDataGap, type OperatingDecision, type OperatingEvidence, type OperatingEvidenceIndexItem, type OperatingEvidenceReadiness, type OperatingFinding, type OperatingMissionPacket, type OperatingMissionPacketState, type OperatingProviderManifest, type OperatingRoleId, type OperatingRoleResult, type OperatingRoutePlan, type OperatingSensitivity, type OperatingState, type OperatingWorkspaceManifest } from './types.js';
 export interface RunOperatingCycleInput {
     projectRoot: string;
     cycleId?: string;
@@ -43,12 +44,75 @@ export interface RunOperatingCycleResult {
     modelCalls: number;
     warnings: string[];
     nativeHandoff?: NativeAdvisorHandoff;
+    /**
+     * Per-role dispatch provenance from this run's advisor dispatch (FR4 / E-004).
+     * Carries the configured `dispatchMode` (registry default overridden by the
+     * persisted per-project `dispatchModeOverrides`) so a persisted override is
+     * observable end-to-end. Empty for preview/dry-run/native-handoff returns.
+     */
+    dispatchProvenance?: AdvisorDispatchResult['provenance'];
 }
+/**
+ * Source a mission packet's non-evidence payload (FR1/E-001) from live cycle
+ * and workspace state at the point mission packets are constructed: the product
+ * charter and current goals, a prior-cycle summary with its open
+ * decisions/gaps/pending outcomes, planning and delivery status, the read roots
+ * declared for the index, and the revision pinned once at cycle start (recorded
+ * in the workspace manifest's control repository and threaded identically into
+ * every mission packet). Nothing here is invented: every value is read from the
+ * parsed charter context, the reduced state, the operating config, and the
+ * captured workspace manifest.
+ */
+export declare function sourceOperatingMissionPacketState(input: {
+    cycleId: string;
+    config: OperatingConfig;
+    workspace: OperatingWorkspaceManifest;
+    context: AdvisorOperatingContext;
+    evidenceIndex: readonly OperatingEvidenceIndexItem[];
+}): OperatingMissionPacketState;
+/**
+ * Build the Protocol v1.3 mission packets (FR1/E-001) for a cycle from live
+ * state: derive the body-free evidence index from the collected snapshot,
+ * source the non-evidence payload once, and construct one digest-bound packet
+ * per requested role. Each packet is measured against its role's derived
+ * single-digit-KiB mission budget and fails closed with
+ * `E_OPERATE_MISSION_PACKET_BUDGET` naming the role before any dispatch. Pack
+ * mode (`createOperatingAdvisorPack`) is untouched.
+ */
+export declare function buildOperatingMissionPackets(input: {
+    cycleId: string;
+    config: OperatingConfig;
+    workspace: OperatingWorkspaceManifest;
+    context: AdvisorOperatingContext;
+    evidence: OperatingEvidence;
+    roleIds?: OperatingRoleId[];
+    sensitivityCeiling?: OperatingSensitivity;
+    maxEvidenceItems?: number;
+}): Promise<OperatingMissionPacket[]>;
 export declare function buildChairEvidence(evidence: OperatingEvidence, results: OperatingRoleResult[], now: string): OperatingEvidence;
 /**
  * Full evidence → advisors → deterministic consolidation lifecycle. All
  * mutations are serialized under the process-identity lease; preview and
  * dry-run never enter the mutating branch.
  */
+/**
+ * FR3 / E-003 citation gate, invoked immediately before consolidation.
+ *
+ * Every recorded proposal that carries citations is resolved against the cycle's
+ * pinned revision through T-004's `enforceRecordedProposalCitations`. A proposal
+ * with ANY unresolvable citation is DROPPED — it never reaches
+ * `consolidateOperatingResults` — and exactly one `unresolvable-citation` gap is
+ * opened in its place. A proposal whose citations all resolve keeps its minted
+ * evidence IDs. Proposals carrying no citations (the v1.2 evidence-ref path) pass
+ * through untouched, so this is a byte-for-byte no-op for every non-citation
+ * cycle: the same `roleResults` reference is returned and no gap is emitted.
+ */
+export declare function gateRecordedProposalCitations(input: {
+    roleResults: OperatingRoleResult[];
+    context: CitationResolutionContext;
+}): Promise<{
+    roleResults: OperatingRoleResult[];
+    gaps: OperatingDataGap[];
+}>;
 export declare function runOperatingCycle(input: RunOperatingCycleInput): Promise<RunOperatingCycleResult>;
 //# sourceMappingURL=engine.d.ts.map

package/dist/services/operate/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/services/operate/engine.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,cAAc,EAQpB,MAAM,eAAe,CAAC;AA0BvB,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEtB,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,gBAAgB,EAErB,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EAEpB,MAAM,YAAY,CAAC;AAOpB,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,sBAAsB,CAAC,OAAO,CAAC,CAAC;IACxC,KAAK,CAAC,EAAE,sBAAsB,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,UAAU,MAAM,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,sBAAsB,CAAC;IAC9B,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,SAAS,CAAC,EAAE,0BAA0B,CAAC;IACvC,WAAW,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACpC,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC9B,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAChC,IAAI,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,yBAAyB,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,oBAAoB,CAAC;CACtC;AA+HD,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,EAAE,mBAAmB,EAAE,EAC9B,GAAG,EAAE,MAAM,GACV,iBAAiB,CA6DnB;AAuPD;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CAs4BlC"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/services/operate/engine.ts"],"names":[],"mappings":"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"}

package/dist/services/operate/engine.js

@@ -3,15 +3,17 @@ import { mkdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { OPENPLANR_VERSION } from '../../utils/package-version.js';
 import { loadConfig } from '../config-service.js';
-import { advisorFailureGaps, buildAdvisorOperatingContext, configuredAdvisorProviderPolicy, createConfiguredStructuredAdapter, createOfflineAdvisorAdapter, dispatchOperatingAdvisors, ensureOperatingProviderConsent, } from './advisors.js';
+import { advisorFailureGaps, buildAdvisorOperatingContext, buildOperatingMissionPacket, configuredAdvisorProviderPolicy, createConfiguredStructuredAdapter, createOfflineAdvisorAdapter, dispatchOperatingAdvisors, ensureOperatingProviderConsent, } from './advisors.js';
+import { recordOperatingCadenceRun } from './cadence.js';
 import { canonicalDigest, canonicalize } from './canonical.js';
-import { operatingProjectKey, validateOperatingConfiguration } from './config.js';
+import { operatingProjectKey, readOperatingDispatchModeOverrides, validateOperatingConfiguration, } from './config.js';
 import { consolidateOperatingResults } from './consolidation.js';
 import { OperatingEventStore } from './event-store.js';
-import { collectOperatingEvidence, evidenceProjectionSources, unqualifiedCommercialEvidenceGaps, } from './evidence.js';
+import { buildOperatingEvidenceIndex, collectOperatingEvidence, deriveOperatingDeclaredRoots, evidenceProjectionSources, unqualifiedCommercialEvidenceGaps, } from './evidence.js';
 import { OperatingEvidenceCache } from './evidence-cache.js';
 import { evaluateEvidenceReadiness } from './evidence-readiness.js';
 import { nextCycleId } from './ids.js';
+import { enforceRecordedProposalCitations } from './interaction/action-service.js';
 import { applyJournalTransaction, prepareJournalTransaction, readJournal, rollbackJournalTransaction, } from './journal.js';
 import { reconcileOperatingDecisionDeadlines } from './lifecycle.js';
 import { withOperatingLock } from './lock-service.js';
@@ -20,7 +22,7 @@ import { persistOperatingProjections } from './projection-persistence.js';
 import { assertOperatingArtifact, loadOperatingProtocol } from './protocol.js';
 import { maximumSensitivity } from './redaction.js';
 import { createOperatingRoutePlan, nextOperatingSpecOrdinal } from './routes.js';
-import { OPERATE_PROTOCOL_VERSION, OPERATE_SCHEMA_VERSION, OperateError, } from './types.js';
+import { OPERATE_MISSION_PROTOCOL_VERSION, OPERATE_PROTOCOL_VERSION, OPERATE_SCHEMA_VERSION, OperateError, } from './types.js';
 import { assertOperatingProject, refreshOperatingWorkspaceManifest, resolveOperatingPaths, } from './workspace.js';
 function normalizeFocus(focus) {
     const supported = new Set(['strategy', 'product', 'growth', 'operations', 'technology', 'all']);
@@ -32,6 +34,110 @@ function normalizeFocus(focus) {
 function loadJson(target) {
     return readFile(target, 'utf8').then((raw) => JSON.parse(raw));
 }
+const MISSION_REVISION_PATTERN = /^[a-f0-9]{7,64}$/;
+const MISSION_CYCLE_PATTERN = /^CYCLE-[0-9]{3,}$/;
+const MISSION_DECISION_PATTERN = /^DEC-[0-9]{3,}$/;
+const MISSION_GAP_PATTERN = /^GAP-[A-Za-z0-9._-]+$/;
+const MISSION_OUTCOME_PATTERN = /^OUT-[0-9]{3,}$/;
+function boundedMissionText(value, maximum, fallback) {
+    const text = value.replace(/\s+/g, ' ').trim().slice(0, maximum);
+    return text || fallback;
+}
+function missionOpenItemIds(items, pattern) {
+    return [...new Set(items.map((item) => item.id).filter((id) => pattern.test(id)))].sort();
+}
+/**
+ * Source a mission packet's non-evidence payload (FR1/E-001) from live cycle
+ * and workspace state at the point mission packets are constructed: the product
+ * charter and current goals, a prior-cycle summary with its open
+ * decisions/gaps/pending outcomes, planning and delivery status, the read roots
+ * declared for the index, and the revision pinned once at cycle start (recorded
+ * in the workspace manifest's control repository and threaded identically into
+ * every mission packet). Nothing here is invented: every value is read from the
+ * parsed charter context, the reduced state, the operating config, and the
+ * captured workspace manifest.
+ */
+export function sourceOperatingMissionPacketState(input) {
+    const { context } = input;
+    const charter = context.charter;
+    const charterLine = [
+        charter.purpose && `Purpose: ${charter.purpose}`,
+        charter.stage && `Stage: ${charter.stage}`,
+        charter.businessModel && `Business model: ${charter.businessModel}`,
+        charter.idealCustomer && `Ideal customer: ${charter.idealCustomer}`,
+    ]
+        .filter(Boolean)
+        .join('. ');
+    const currentGoals = [...new Set(charter.goals.map((goal) => goal.trim()).filter(Boolean))]
+        .map((goal) => goal.slice(0, 512))
+        .sort();
+    const prior = context.priorCycle;
+    const priorSummaryText = prior
+        ? `Prior cycle ${prior.id} (${prior.state}, health ${prior.health ?? 'unknown'}) closed with ` +
+            `${prior.findings} finding(s), ${prior.decisions} decision(s), ${prior.gaps} gap(s), and ` +
+            `${prior.pendingOutcomes} pending outcome(s).`
+        : 'No prior operating cycle.';
+    const priorCycleSummary = {
+        ...(prior && MISSION_CYCLE_PATTERN.test(prior.id) ? { cycleId: prior.id } : {}),
+        summary: boundedMissionText(priorSummaryText, 8192, 'No prior operating cycle.'),
+        openDecisions: missionOpenItemIds(context.openDecisions, MISSION_DECISION_PATTERN),
+        openGaps: missionOpenItemIds(context.openGaps, MISSION_GAP_PATTERN),
+        pendingOutcomes: missionOpenItemIds(context.pendingOutcomes, MISSION_OUTCOME_PATTERN),
+    };
+    const planning = boundedMissionText(`${context.openDecisions.length} open decision(s); ${context.openGaps.length} open gap(s); ` +
+        `${context.pendingOutcomes.length} pending outcome(s).`, 2048, 'No open planning items.');
+    const delivery = boundedMissionText(prior
+        ? `Most recent cycle ${prior.id} is ${prior.state}.`
+        : 'No delivery cycle has completed yet.', 2048, 'No delivery status recorded.');
+    const pinnedRevision = input.workspace.controlRepository.pinnedRevision;
+    return {
+        cycleId: input.cycleId,
+        ...(pinnedRevision && MISSION_REVISION_PATTERN.test(pinnedRevision) ? { pinnedRevision } : {}),
+        charter: {
+            productCharter: boundedMissionText(charterLine, 8192, 'No product charter recorded.'),
+            currentGoals,
+        },
+        priorCycleSummary,
+        planningStatus: {
+            planningEngine: input.config.planningEngine,
+            planning,
+            delivery,
+        },
+        declaredRoots: deriveOperatingDeclaredRoots(input.evidenceIndex),
+    };
+}
+/**
+ * Build the Protocol v1.3 mission packets (FR1/E-001) for a cycle from live
+ * state: derive the body-free evidence index from the collected snapshot,
+ * source the non-evidence payload once, and construct one digest-bound packet
+ * per requested role. Each packet is measured against its role's derived
+ * single-digit-KiB mission budget and fails closed with
+ * `E_OPERATE_MISSION_PACKET_BUDGET` naming the role before any dispatch. Pack
+ * mode (`createOperatingAdvisorPack`) is untouched.
+ */
+export async function buildOperatingMissionPackets(input) {
+    const evidenceIndex = buildOperatingEvidenceIndex(input.evidence, {
+        sensitivityCeiling: input.sensitivityCeiling,
+    });
+    const state = sourceOperatingMissionPacketState({
+        cycleId: input.cycleId,
+        config: input.config,
+        workspace: input.workspace,
+        context: input.context,
+        evidenceIndex,
+    });
+    const roleIds = input.roleIds ?? input.config.enabledRoles;
+    const packets = [];
+    for (const roleId of roleIds) {
+        packets.push(await buildOperatingMissionPacket({
+            roleId,
+            ...state,
+            evidenceIndex,
+            maxEvidenceItems: input.maxEvidenceItems,
+        }));
+    }
+    return packets;
+}
 async function snapshotWorkspace(projectRoot, localRoot) {
     return refreshOperatingWorkspaceManifest(projectRoot, { localRoot });
 }
@@ -323,6 +429,52 @@ async function persistedCycleRoleResults(store, events, cycleId) {
  * mutations are serialized under the process-identity lease; preview and
  * dry-run never enter the mutating branch.
  */
+/**
+ * FR3 / E-003 citation gate, invoked immediately before consolidation.
+ *
+ * Every recorded proposal that carries citations is resolved against the cycle's
+ * pinned revision through T-004's `enforceRecordedProposalCitations`. A proposal
+ * with ANY unresolvable citation is DROPPED — it never reaches
+ * `consolidateOperatingResults` — and exactly one `unresolvable-citation` gap is
+ * opened in its place. A proposal whose citations all resolve keeps its minted
+ * evidence IDs. Proposals carrying no citations (the v1.2 evidence-ref path) pass
+ * through untouched, so this is a byte-for-byte no-op for every non-citation
+ * cycle: the same `roleResults` reference is returned and no gap is emitted.
+ */
+export async function gateRecordedProposalCitations(input) {
+    const bearing = [];
+    for (const result of input.roleResults) {
+        for (const proposal of result.proposals) {
+            const citations = proposal.citations;
+            if (Array.isArray(citations) && citations.length > 0) {
+                bearing.push({ proposalKey: proposal.proposalKey, citations });
+            }
+        }
+    }
+    if (bearing.length === 0)
+        return { roleResults: input.roleResults, gaps: [] };
+    const enforcement = await enforceRecordedProposalCitations(bearing, input.context);
+    const rejectedKeys = new Set(enforcement.rejected.map((entry) => entry.proposalKey));
+    const evidenceByKey = new Map(enforcement.accepted.map((entry) => [entry.proposal.proposalKey, entry.evidenceRefs]));
+    const roleResults = input.roleResults.map((result) => ({
+        ...result,
+        proposals: result.proposals
+            .filter((proposal) => !rejectedKeys.has(proposal.proposalKey))
+            .map((proposal) => {
+            const minted = evidenceByKey.get(proposal.proposalKey);
+            return minted && minted.length > 0
+                ? {
+                    ...proposal,
+                    evidenceRefs: [...new Set([...proposal.evidenceRefs, ...minted])].sort(),
+                }
+                : proposal;
+        }),
+    }));
+    // The unresolvable-citation gaps are Protocol v1.3 data gaps (they validate
+    // against the v1.3 operating-data-gap schema, which admits `category`). They
+    // are persisted alongside the cycle's other gaps by the committed path.
+    return { roleResults, gaps: enforcement.gaps };
+}
 export async function runOperatingCycle(input) {
     const projectRoot = await assertOperatingProject(input.projectRoot);
     const config = await validateOperatingConfiguration(projectRoot);
@@ -330,6 +482,12 @@ export async function runOperatingCycle(input) {
     const initializedWorkspace = await loadJson(paths.workspace);
     await assertOperatingArtifact('operating-workspace-manifest', initializedWorkspace);
     const preferences = await readPreferences(projectRoot, input.localRoot);
+    // FR4 / E-004 fold-in: the live dispatch call site reads the persisted
+    // per-project dispatch-mode overrides once and threads them into every advisor
+    // dispatch below, so a persisted override reaches dispatch provenance.
+    const dispatchModeOverrides = await readOperatingDispatchModeOverrides(projectRoot, {
+        localRoot: input.localRoot,
+    });
     const store = new OperatingEventStore(projectRoot, { localRoot: input.localRoot });
     const now = input.now ?? new Date();
     const deadlineReconciliation = !input.preview && !input.dryRun
@@ -579,9 +737,11 @@ export async function runOperatingCycle(input) {
                 adapter: await resolveAdapter(),
                 depth,
                 runtime: resolvedRuntime,
+                dispatchModeOverrides,
             })
             : {
                 results: [],
+                provenance: [],
                 modelCalls: 0,
                 blocked: false,
                 skipped: skippedMissingNonChair,
@@ -593,6 +753,7 @@ export async function runOperatingCycle(input) {
         ];
         let modelCalls = first.modelCalls;
         let blocked = first.blocked;
+        const dispatchProvenance = [...first.provenance];
         const skipped = [...first.skipped];
         const failed = [...first.failed];
         let consolidationEvidence = evidence;
@@ -648,6 +809,7 @@ export async function runOperatingCycle(input) {
             const chair = persistedChair
                 ? {
                     results: [persistedChair],
+                    provenance: [],
                     modelCalls: 0,
                     blocked: false,
                     skipped: [],
@@ -661,9 +823,11 @@ export async function runOperatingCycle(input) {
                     adapter: await resolveAdapter(),
                     depth,
                     runtime: resolvedRuntime,
+                    dispatchModeOverrides,
                 });
             roleResults = [...roleResults, ...chair.results];
             modelCalls += chair.modelCalls;
+            dispatchProvenance.push(...chair.provenance);
             skipped.push(...chair.skipped);
             failed.push(...chair.failed);
             blocked ||= chair.blocked || chairReadiness.roles.some((role) => !role.modelCallAllowed);
@@ -672,9 +836,28 @@ export async function runOperatingCycle(input) {
         const technologyRiskFailed = failed.some((entry) => entry.roleId === 'technology-risk');
         const sensitiveRouteBlocked = containsSensitiveRouteProposal(roleResults) && (!technologyRiskReady || technologyRiskFailed);
         blocked ||= sensitiveRouteBlocked;
+        // FR3 / E-003: resolve every recorded proposal's citations against the cycle's
+        // pinned revision before consolidation. A proposal built on a fabricated,
+        // drifted, or uncommitted citation is dropped here and can never reach
+        // consolidation; its place is taken by a single unresolvable-citation gap.
+        const citationGate = await gateRecordedProposalCitations({
+            roleResults,
+            context: {
+                projectRoot,
+                cycleId: cycle.id,
+                descriptor: workspace.controlRepository,
+                cache: new OperatingEvidenceCache(resolveOperatingPaths(projectRoot, { localRoot: input.localRoot }).evidence, preferences.sensitivityCeiling),
+                owner: config.decisionOwner,
+                now,
+            },
+        });
+        // Only the gated proposals feed consolidation, so a proposal with an
+        // unresolvable citation can never become a finding/route. The raw advisor
+        // result stays intact as the audit record; the rejection is recorded as the
+        // opened unresolvable-citation gap threaded into `gaps` below.
         const consolidated = await consolidateOperatingResults({
             cycleId: cycle.id,
-            results: roleResults,
+            results: citationGate.roleResults,
             evidence: consolidationEvidence,
             config,
             now: timestamp,
@@ -740,16 +923,23 @@ export async function runOperatingCycle(input) {
             roleResults,
             findings: [...reconciledFindings, ...reconciledParked],
             decisions: remapped.decisions,
-            gaps: [...readinessGaps(readiness, config.decisionOwner, timestamp), ...remapped.gaps],
+            // Citation gaps bypass remapConsolidation (their IDs are digest-derived and
+            // already canonical) and are persisted alongside the cycle's other gaps.
+            gaps: [
+                ...readinessGaps(readiness, config.decisionOwner, timestamp),
+                ...remapped.gaps,
+                ...citationGate.gaps,
+            ],
             routes: [],
             provider,
             modelCalls,
             warnings,
+            dispatchProvenance,
         };
     };
     if (input.dryRun)
         return evaluate(false);
-    return withOperatingLock(projectRoot, {
+    const cycleResult = await withOperatingLock(projectRoot, {
         projectKey: operatingProjectKey(projectRoot),
         expectedEventHead: initial.eventHead,
         currentEventHead: initial.eventHead,
@@ -1030,6 +1220,12 @@ export async function runOperatingCycle(input) {
                             correlationId,
                             evidenceRefs: route.actions.flatMap((action) => action.evidenceRefs),
                             payload: { record: route },
+                            // A v1.3 (create-quick-task) route plan embedded in the event
+                            // payload stamps the event v1.3, whose schema accepts either
+                            // route-plan version; every v1.2 route keeps the frozen v1.2 event.
+                            ...(route.protocolVersion === OPERATE_MISSION_PROTOCOL_VERSION
+                                ? { protocolVersion: OPERATE_MISSION_PROTOCOL_VERSION }
+                                : {}),
                         });
                         head = appended.head;
                     }
@@ -1119,5 +1315,21 @@ export async function runOperatingCycle(input) {
             throw error;
         }
     });
+    // FR8 / E-008: persist the cadence `lastRunAt` marker once a committed cycle
+    // reaches a terminal reviewable/blocked/closed state, so a later `operate
+    // status` surfaces the pipeline's `nextDueAt` without re-running a cycle. Uses
+    // the injected clock (`timestamp`), never a wall-clock read. Preview, dry-run,
+    // and native-handoff returns have not completed a cycle and record nothing.
+    if (!cycleResult.preview && !cycleResult.dryRun && !cycleResult.nativeHandoff) {
+        const finalCycleState = cycleResult.state?.cycles.find((candidate) => candidate.id === cycle.id)?.state;
+        if (finalCycleState && ['reviewable', 'blocked', 'closed'].includes(finalCycleState)) {
+            await recordOperatingCadenceRun({
+                projectRoot,
+                localRoot: input.localRoot,
+                runAt: timestamp,
+            });
+        }
+    }
+    return cycleResult;
 }
 //# sourceMappingURL=engine.js.map