@openrig/cli 0.5.8 → 0.5.10

package/daemon/dist/domain/workflow-runtime.js

@@ -12,16 +12,17 @@ import { WorkflowInstanceStore, WorkflowInstanceError, } from "./workflow-instan
 import { resolveExceptionRoute } from "./workflow-exception-router.js";
 import { classifyGateTrip, workflowExceptionTags } from "./workflow-exception.js";
 import { newQitemId } from "./queue-repository.js";
-import { WorkflowProjector, WorkflowProjectorError, compileGate, nodeRuntimeOf, reconcileExplicitOwnerHarness, resolveDefaultOwner, } from "./workflow-projector.js";
+import { WorkflowProjector, WorkflowProjectorError, compileGate, nodeRuntimeOf, reconcileExplicitOwnerHarness, resolveDefaultOwner, withWorkflowContinuation, workflowWaitWakeMessage, } from "./workflow-projector.js";
 import { loadHostRegistry } from "./hosts/hosts-registry-reader.js";
 import { WorkflowSpecCache, WorkflowSpecError } from "./workflow-spec-cache.js";
 import { WorkflowStepTrailLog } from "./workflow-step-trail-log.js";
 import { WorkflowValidator, } from "./workflow-validator.js";
-import { disarmWorkflowKeepalive, ensureWorkflowKeepaliveArmed } from "./workflow-keepalive-arming.js";
+import { disarmAllWorkflowKeepalives, disarmWorkflowKeepalive, ensureWorkflowKeepaliveArmed } from "./workflow-keepalive-arming.js";
 import { evaluateStepDeadline } from "./workflow-deadline.js";
 import { rigDeclaresRole, rigMemberExists, roleResolutionContext, tryResolveRoleByCapability, } from "./workflow-role-context.js";
 import { isHumanSeatSession } from "./human-route-enforcer.js";
 import { parseSessionName } from "./session-name.js";
+import { compileProjectLifecycle } from "./project-lifecycle-compiler.js";
 export class WorkflowRuntime {
     specCache;
     instanceStore;
@@ -47,6 +48,33 @@ export class WorkflowRuntime {
         this.validator = new WorkflowValidator();
         this.projector = new WorkflowProjector(this.db, this.eventBus, this.queueRepo, this.instanceStore, this.trailLog, this.specCache, this.now, this.watchdogJobsRepo, deps.exceptionDial);
     }
+    compileLifecycle(missionPath, operationKey) {
+        return compileProjectLifecycle({ missionPath, operationKey });
+    }
+    async instantiateLifecycle(input) {
+        const compilation = this.compileLifecycle(input.missionPath, input.operationKey);
+        if (!compilation.eligible || !compilation.workflowSpec) {
+            throw new WorkflowProjectorError("lifecycle_not_eligible", "compiled lifecycle is inspectable but not eligible for instantiation", { missionPath: input.missionPath, unknowns: compilation.unknowns });
+        }
+        const result = await this.instantiate({
+            specPath: input.missionPath,
+            rootObjective: input.rootObjective,
+            createdBySession: input.createdBySession,
+            entryOwnerSession: input.entryOwnerSession,
+            targetRig: input.targetRig,
+            compiledLifecycle: compilation,
+            lifecycle: {
+                operationKey: input.operationKey,
+                compiledInputDigest: compilation.compiledInputDigest,
+                binding: {
+                    identity: compilation.identity,
+                    sources: compilation.sources,
+                    dependencies: compilation.dependencies,
+                },
+            },
+        });
+        return { ...result, compilation };
+    }
     /**
      * OPR.0.4.6.WF5 FR-2: resolve the maturity dial for a CACHED spec —
      * the class-(b) detection paths (sweep/keepalive) call this through
@@ -119,6 +147,42 @@ export class WorkflowRuntime {
      * see the workflow.instantiated + queue.created events together.
      */
     async instantiate(input) {
+        // Replay/conflict classification must precede every cache or queue write.
+        // The operation key is the durable outer identity; an exact replay reads
+        // the already-cached spec and entry row, while changed bytes refuse with
+        // zero mutation.
+        if (input.lifecycle) {
+            if (!input.lifecycle.operationKey || !input.lifecycle.compiledInputDigest) {
+                throw new WorkflowProjectorError("lifecycle_identity_invalid", "lifecycle instantiation requires non-empty operationKey and compiledInputDigest");
+            }
+            const existing = this.instanceStore.getByLifecycleOperationKey(input.lifecycle.operationKey);
+            if (existing) {
+                if (existing.compiledInputDigest !== input.lifecycle.compiledInputDigest) {
+                    throw new WorkflowProjectorError("lifecycle_operation_conflict", `lifecycle operation key ${input.lifecycle.operationKey} already binds different compiled input bytes`, {
+                        operationKey: input.lifecycle.operationKey,
+                        expectedDigest: existing.compiledInputDigest,
+                        attemptedDigest: input.lifecycle.compiledInputDigest,
+                        instanceId: existing.instanceId,
+                    });
+                }
+                const spec = this.specCache.getByNameVersion(existing.workflowName, existing.workflowVersion);
+                const entryQitemId = typeof existing.lifecycleBinding?.entryQitemId === "string"
+                    ? existing.lifecycleBinding.entryQitemId
+                    : null;
+                const entryPacket = entryQitemId ? this.queueRepo.getById(entryQitemId) : null;
+                if (!spec || !entryQitemId || !entryPacket) {
+                    throw new WorkflowProjectorError("lifecycle_replay_indeterminate", `lifecycle operation ${input.lifecycle.operationKey} exists but its cached spec or entry packet cannot be resolved`, { operationKey: input.lifecycle.operationKey, instanceId: existing.instanceId, entryQitemId });
+                }
+                return {
+                    instance: existing,
+                    spec,
+                    entryQitemId,
+                    entryOwnerSession: entryPacket.destinationSession,
+                    advisories: [],
+                    replayed: true,
+                };
+            }
+        }
         // OPR.0.3.3.04.1 (AC-3 reachability): a fresh operator runs
         // `workflow instantiate <discovered-name>` (e.g. `conveyor`), not a hidden
         // file path. Resolve the identifier against the seeded spec cache BY NAME
@@ -127,7 +191,10 @@ export class WorkflowRuntime {
         // operator-authored spec at an explicit path). Before this, instantiate fed
         // the bare name straight to readThrough -> spec_file_missing.
         const resolvedSpecPath = this.specCache.resolveSourcePathByName(input.specPath) ?? input.specPath;
-        const specRow = this.specCache.readThrough(resolvedSpecPath);
+        const generatedSpec = input.compiledLifecycle?.workflowSpec;
+        const specRow = generatedSpec
+            ? this.specCache.putGenerated(generatedSpec, input.compiledLifecycle.sources.find((source) => source.kind === "mission")?.path ?? resolvedSpecPath, input.compiledLifecycle.compiledInputDigest)
+            : this.specCache.readThrough(resolvedSpecPath);
         const validation = this.validator.validate(specRow.spec, this.seatLivenessCheck, this.hostRegistryLookup);
         if (!validation.ok) {
             throw new WorkflowProjectorError("spec_invalid", `cannot instantiate: spec ${specRow.name}@${specRow.version} has ${validation.issues.filter((i) => i.severity === "error").length} validation error(s); run validate to inspect`, { specPath: input.specPath, issues: validation.issues });
@@ -379,6 +446,7 @@ export class WorkflowRuntime {
             throw new WorkflowProjectorError("entry_owner_unresolved", `cannot instantiate: entry step "${entryStep.id}" (role "${entryStep.actor_role}") has no preferred_targets and no entryOwnerSession was supplied`, { specPath: input.specPath, entryStepId: entryStep.id, entryRole: entryStep.actor_role });
         }
         const createdAt = this.now().toISOString();
+        const preallocatedEntryQitemId = newQitemId();
         let entryQitemId;
         let entryQitemDestinationSession;
         let entryQitemNudge;
@@ -396,6 +464,12 @@ export class WorkflowRuntime {
                 // OPR.0.4.6.FAC1: the resolved rig binding persists with the
                 // instance row (same txn as the entry packet).
                 boundRig,
+                lifecycle: input.lifecycle
+                    ? {
+                        ...input.lifecycle,
+                        binding: { ...input.lifecycle.binding, entryQitemId: preallocatedEntryQitemId },
+                    }
+                    : undefined,
             });
             instanceId = instance.instanceId;
             // Create entry qitem in the same txn (gate-aware: a gated entry
@@ -405,7 +479,7 @@ export class WorkflowRuntime {
             // carries the class-(c) exception identity on the WF-2 item
             // itself, occurrence = the preallocated packet id. Handler-role
             // entries stay negative.
-            const entryGateQitemId = entryGate ? newQitemId() : undefined;
+            const entryGateQitemId = preallocatedEntryQitemId;
             const entryGateException = entryGate && entryGateQitemId
                 ? classifyGateTrip({
                     workflowName: specRow.name,
@@ -426,6 +500,8 @@ export class WorkflowRuntime {
                     entryStep,
                     rootObjective: input.rootObjective,
                     gate: entryGate,
+                    packetId: entryGateQitemId,
+                    ownerSession: entryOwner,
                 }),
                 priority: "routine",
                 tier: entryGate?.tier ?? "mode2",
@@ -443,6 +519,14 @@ export class WorkflowRuntime {
             entryQitemDestinationSession = created.destinationSession;
             entryQitemNudge = created.nudge;
             register(created.persistedEvent);
+            const packetAddressed = specRow.spec.steps.some((step) => step.depends_on !== undefined);
+            if (packetAddressed) {
+                this.instanceStore.bindFrontierPacket({
+                    instanceId: instance.instanceId,
+                    packetId: created.qitemId,
+                    stepId: entryStep.id,
+                });
+            }
             // OPR.0.4.6.WF2 FR-5 (guard blocker 1): a HUMAN-gated ENTRY parks
             // in the same txn — the leg-1 blocked_on human-seat shape the
             // shipped resolve verb acts on (same as the projector's mid-flow
@@ -464,14 +548,15 @@ export class WorkflowRuntime {
                 // txn at version 0; uniformity keeps every advance guarded.
                 expectedVersion: instance.version,
             });
-            // FR-3: arm the per-instance keepalive INSIDE the same txn that
-            // creates the entry packet (covers commit-then-crash-before-nudge
-            // from the very first step).
+            // FR-3: arm the packet-addressed keepalive (or legacy instance job)
+            // INSIDE the same txn that creates the entry packet. This covers the
+            // commit-then-crash-before-nudge window from the very first step.
             if (this.watchdogJobsRepo) {
                 ensureWorkflowKeepaliveArmed(this.watchdogJobsRepo, {
                     instanceId: instance.instanceId,
                     targetSession: entryOwner,
                     registeredBySession: input.createdBySession,
+                    packetId: packetAddressed ? created.qitemId : undefined,
                 });
             }
             register(this.eventBus.persistWithinTransaction({
@@ -492,11 +577,103 @@ export class WorkflowRuntime {
             entryQitemId: entryQitemId,
             entryOwnerSession: entryOwner,
             advisories,
+            replayed: false,
         };
     }
     async project(input) {
         return this.projector.project(input);
     }
+    inspect(instanceId) {
+        const instance = this.instanceStore.getByIdOrThrow(instanceId);
+        const unknowns = [];
+        const spec = this.specCache.getByNameVersion(instance.workflowName, instance.workflowVersion)?.spec;
+        const frontier = instance.currentFrontier.map((packetId) => {
+            const binding = this.instanceStore.getFrontierBinding(instanceId, packetId);
+            const packet = this.queueRepo.getById(packetId);
+            const stepId = binding?.stepId ?? (instance.currentFrontier.length === 1 ? instance.currentStepId : null);
+            const step = stepId ? spec?.steps.find((candidate) => candidate.id === stepId) : undefined;
+            if (!binding && instance.currentFrontier.length > 1)
+                unknowns.push(`frontier packet ${packetId} has no unique step binding`);
+            if (!packet)
+                unknowns.push(`frontier packet ${packetId} has no queue row`);
+            return {
+                packetId,
+                stepId,
+                ownerSession: packet?.destinationSession ?? null,
+                queueState: packet?.state ?? null,
+                blockedOn: packet?.blockedOn ?? null,
+                targetedAction: stepId && packet ? "project" : "indeterminate",
+                dependsOn: step?.depends_on ?? [],
+                gate: step?.gate ?? null,
+                acceptance: step?.acceptance ?? null,
+                deadline: evaluateStepDeadline({ ...instance, currentFrontier: [packetId], currentStepId: stepId }, packet ? [packet] : [], this.now()),
+            };
+        });
+        const failureResumeAvailable = instance.status !== "completed" && instance.status !== "aborted";
+        const failures = this.instanceStore.listFailureOccurrences(instanceId).map((failure) => ({
+            ...failure,
+            targetedAction: failure.status === "unresolved" && failureResumeAvailable
+                ? "resume"
+                : "none",
+        }));
+        return { instance, frontier, failures, unknowns };
+    }
+    async abort(input) {
+        if (!input.reason.trim()) {
+            throw new WorkflowProjectorError("abort_reason_required", "workflow abort requires a non-empty reason");
+        }
+        const closedPacketIds = [];
+        this.eventBus.withNotifyEnvelope((register) => {
+            const instance = this.instanceStore.getByIdOrThrow(input.instanceId);
+            if (instance.status === "completed" || instance.status === "aborted") {
+                throw new WorkflowProjectorError("instance_not_abortable", `instance ${instance.instanceId} is ${instance.status}`, { instanceId: instance.instanceId, status: instance.status });
+            }
+            const spec = this.specCache.getByNameVersion(instance.workflowName, instance.workflowVersion)?.spec;
+            const bindingByPacket = new Map(this.instanceStore.listFrontierBindings(instance.instanceId).map((binding) => [binding.packetId, binding]));
+            const closedAt = this.now().toISOString();
+            for (const packetId of instance.currentFrontier) {
+                const packet = this.queueRepo.getById(packetId);
+                if (!packet)
+                    throw new WorkflowProjectorError("packet_not_found", `frontier packet ${packetId} not found`, { instanceId: instance.instanceId, packetId });
+                const binding = bindingByPacket.get(packetId);
+                const stepId = binding?.stepId ?? (instance.currentFrontier.length === 1 ? instance.currentStepId : null);
+                if (!stepId)
+                    throw new WorkflowProjectorError("frontier_binding_indeterminate", `cannot abort: packet ${packetId} has no step binding`, { instanceId: instance.instanceId, packetId });
+                const step = spec?.steps.find((candidate) => candidate.id === stepId);
+                const closed = this.queueRepo.updateWithinTransaction({
+                    qitemId: packetId,
+                    actorSession: input.actorSession,
+                    viaWorkflowVerb: true,
+                    state: "canceled",
+                    transitionNote: `workflow abort by ${input.actorSession}: ${input.reason}`,
+                });
+                register(closed.persistedEvent);
+                this.trailLog.record({
+                    instanceId: instance.instanceId,
+                    stepId,
+                    stepRole: step?.actor_role ?? "unknown",
+                    closedAt,
+                    closureReason: "failed",
+                    closureEvidence: { abort: { reason: input.reason, actorSession: input.actorSession } },
+                    actorSession: input.actorSession,
+                    nextQitemId: null,
+                    priorQitemId: packetId,
+                });
+                this.instanceStore.removeFrontierBinding(instance.instanceId, packetId);
+                closedPacketIds.push(packetId);
+            }
+            this.instanceStore.updateFrontier(instance.instanceId, [], "aborted", {
+                currentStepId: "clear",
+                completedAt: closedAt,
+                expectedVersion: instance.version,
+                lastContinuationDecision: { action: "abort", actorSession: input.actorSession, reason: input.reason, closedPacketIds },
+            });
+            if (this.watchdogJobsRepo)
+                disarmAllWorkflowKeepalives(this.watchdogJobsRepo, instance.instanceId, `workflow_aborted: ${input.reason}`);
+            register(this.eventBus.persistWithinTransaction({ type: "workflow.failed", instanceId: instance.instanceId, workflowName: instance.workflowName, reason: `aborted: ${input.reason}` }));
+        });
+        return { instanceId: input.instanceId, closedPacketIds, status: "aborted" };
+    }
     /**
      * OPR.0.4.6.WF3 FR-4 — `route`: re-target the CURRENT FRONTIER step
      * of a live instance to a new owner. THE ADJUDICATED MECHANISM
@@ -535,6 +712,10 @@ export class WorkflowRuntime {
      * upgrades uniformly.
      */
     async resume(input) {
+        const occurrences = this.instanceStore.listFailureOccurrences(input.instanceId);
+        if (input.occurrenceId || occurrences.length > 0) {
+            return this.resumeFailureOccurrence(input);
+        }
         let result;
         let nudgeTo = null;
         this.eventBus.withNotifyEnvelope((register) => {
@@ -570,16 +751,25 @@ export class WorkflowRuntime {
             // Fresh frontier packet — the redrive delivery. The --decision
             // text lands durably in the packet body (the resumer’s
             // instruction reaches the step owner).
+            const redrivePacketId = newQitemId();
             const created = this.queueRepo.createWithinTransaction({
+                qitemId: redrivePacketId,
                 sourceSession: input.actorSession,
                 destinationSession: owner,
-                body: `WORKFLOW RESUME (redrive)\n` +
-                    `workflow: ${instance.workflowName} v${instance.workflowVersion}\n` +
-                    `instance: ${instance.instanceId}\n` +
-                    `step: ${step.id} (role ${step.actor_role}) — re-driven from the recorded failure; completed steps are NOT re-run\n` +
-                    `resumed by: ${input.actorSession} (redrive #${(instance.resumeCount ?? 0) + 1})\n` +
-                    (input.decision ? `decision: ${input.decision}\n` : "") +
-                    `history: rig workflow trace ${instance.instanceId}`,
+                body: withWorkflowContinuation({
+                    body: `WORKFLOW RESUME (redrive)\n` +
+                        `workflow: ${instance.workflowName} v${instance.workflowVersion}\n` +
+                        `instance: ${instance.instanceId}\n` +
+                        `step: ${step.id} (role ${step.actor_role}) — re-driven from the recorded failure; completed steps are NOT re-run\n` +
+                        `resumed by: ${input.actorSession} (redrive #${(instance.resumeCount ?? 0) + 1})\n` +
+                        (input.decision ? `decision: ${input.decision}\n` : "") +
+                        `history: rig workflow trace ${instance.instanceId}`,
+                    instanceId: instance.instanceId,
+                    packetId: redrivePacketId,
+                    ownerSession: owner,
+                    step,
+                    contextRefs: specRow.spec.context_refs,
+                }),
                 priority: "routine",
                 tier: "mode2",
                 tags: [
@@ -685,6 +875,104 @@ export class WorkflowRuntime {
         }
         return result;
     }
+    async resumeFailureOccurrence(input) {
+        const all = this.instanceStore.listFailureOccurrences(input.instanceId);
+        const selected = input.occurrenceId
+            ? all.find((occurrence) => occurrence.occurrenceId === input.occurrenceId)
+            : undefined;
+        if (selected?.status === "resolved" && selected.redrivePacketId) {
+            if (selected.resumeDecision !== (input.decision ?? null)) {
+                throw new WorkflowProjectorError("failure_occurrence_replay_conflict", `failure occurrence ${selected.occurrenceId} was already resumed with different decision bytes`, {
+                    instanceId: input.instanceId,
+                    occurrenceId: selected.occurrenceId,
+                    expectedDecision: selected.resumeDecision,
+                    attemptedDecision: input.decision ?? null,
+                });
+            }
+            const packet = this.queueRepo.getById(selected.redrivePacketId);
+            if (!packet) {
+                throw new WorkflowProjectorError("failure_occurrence_replay_indeterminate", `resolved occurrence ${selected.occurrenceId} points to missing redrive packet ${selected.redrivePacketId}`, { instanceId: input.instanceId, occurrenceId: selected.occurrenceId });
+            }
+            const instance = this.instanceStore.getByIdOrThrow(input.instanceId);
+            return { instanceId: input.instanceId, stepId: selected.stepId, newPacketId: selected.redrivePacketId, ownerSession: packet.destinationSession, resumeCount: instance.resumeCount, exceptionItemsClosed: 0, absorbedReplay: true };
+        }
+        const unresolved = all.filter((occurrence) => occurrence.status === "unresolved");
+        if (!input.occurrenceId && unresolved.length !== 1) {
+            throw new WorkflowProjectorError("failure_occurrence_required", `instance ${input.instanceId} has ${unresolved.length} unresolved failure occurrences; --occurrence is required`, { instanceId: input.instanceId, candidates: unresolved });
+        }
+        const occurrence = selected ?? unresolved[0];
+        if (!occurrence || occurrence.status !== "unresolved") {
+            throw new WorkflowProjectorError("failure_occurrence_not_unresolved", `failure occurrence ${input.occurrenceId ?? "(unspecified)"} is not unresolved`, { instanceId: input.instanceId, occurrenceId: input.occurrenceId ?? null });
+        }
+        let output;
+        let wake = null;
+        this.eventBus.withNotifyEnvelope((register) => {
+            const instance = this.instanceStore.getByIdOrThrow(input.instanceId);
+            if (instance.status === "completed" || instance.status === "aborted") {
+                throw new WorkflowProjectorError("instance_not_resumable", `instance ${instance.instanceId} is ${instance.status}`, { instanceId: instance.instanceId, status: instance.status });
+            }
+            const specRow = this.specCache.getByNameVersion(instance.workflowName, instance.workflowVersion);
+            if (!specRow)
+                throw new WorkflowProjectorError("spec_not_cached", `workflow spec ${instance.workflowName}@${instance.workflowVersion} is not cached`);
+            const step = specRow.spec.steps.find((candidate) => candidate.id === occurrence.stepId);
+            if (!step)
+                throw new WorkflowProjectorError("resume_step_missing_from_spec", `failed step "${occurrence.stepId}" no longer exists`, { instanceId: instance.instanceId, stepId: occurrence.stepId });
+            const owner = resolveDefaultOwner(specRow.spec, step, (session) => nodeRuntimeOf(this.db, session), roleResolutionContext(this.db, instance.boundRig));
+            if (!owner)
+                throw new WorkflowProjectorError("next_owner_unresolved", `cannot resolve owner for failed step "${step.id}"`);
+            const redrivePacketId = newQitemId();
+            const created = this.queueRepo.createWithinTransaction({
+                qitemId: redrivePacketId,
+                sourceSession: input.actorSession,
+                destinationSession: owner,
+                body: withWorkflowContinuation({
+                    body: `WORKFLOW RESUME (packet redrive)\nworkflow: ${instance.workflowName} v${instance.workflowVersion}\ninstance: ${instance.instanceId}\noccurrence: ${occurrence.occurrenceId}\nstep: ${step.id}\n${input.decision ? `decision: ${input.decision}\n` : ""}`,
+                    instanceId: instance.instanceId,
+                    packetId: redrivePacketId,
+                    ownerSession: owner,
+                    step,
+                    contextRefs: specRow.spec.context_refs,
+                }),
+                priority: "routine",
+                tier: "mode2",
+                tags: ["workflow", "resume", `workflow:${instance.workflowName}`, `instance:${instance.instanceId}`, `occurrence:${occurrence.occurrenceId}`],
+                chainOfRecord: [occurrence.failedPacketId],
+            });
+            register(created.persistedEvent);
+            this.queueRepo.stageWakeIntent(created.qitemId, input.actorSession, created.destinationSession, null, created.nudge);
+            this.instanceStore.bindFrontierPacket({
+                instanceId: instance.instanceId,
+                packetId: created.qitemId,
+                stepId: occurrence.stepId,
+                branchDrive: occurrence.branchDrive + 1,
+                hopCount: occurrence.hopCount,
+                hopsBaseline: occurrence.hopCount,
+            });
+            this.instanceStore.resolveFailureOccurrence(instance.instanceId, occurrence.occurrenceId, created.qitemId, input.decision);
+            const nextFrontier = [...instance.currentFrontier, created.qitemId];
+            const bindings = this.instanceStore.listFrontierBindings(instance.instanceId);
+            this.instanceStore.updateFrontier(instance.instanceId, nextFrontier, "active", {
+                currentStepId: bindings.length === 1 ? bindings[0].stepId : "clear",
+                expectedVersion: instance.version,
+                resumeStamp: { resumeCount: instance.resumeCount + 1, hopsBaseline: instance.hopCount },
+                lastContinuationDecision: { action: "resume_occurrence", occurrenceId: occurrence.occurrenceId, redrivePacketId: created.qitemId, actorSession: input.actorSession, decision: input.decision ?? null },
+            });
+            if (this.watchdogJobsRepo)
+                ensureWorkflowKeepaliveArmed(this.watchdogJobsRepo, {
+                    instanceId: instance.instanceId,
+                    packetId: created.qitemId,
+                    targetSession: owner,
+                    registeredBySession: input.actorSession,
+                });
+            register(this.eventBus.persistWithinTransaction({ type: "workflow.resumed", instanceId: instance.instanceId, workflowName: instance.workflowName, stepId: step.id, occurrenceId: occurrence.occurrenceId, resumedBy: input.actorSession, decision: input.decision ?? null, resumeCount: instance.resumeCount + 1 }));
+            wake = { qitemId: created.qitemId, session: created.destinationSession, nudge: created.nudge };
+            output = { instanceId: instance.instanceId, stepId: step.id, newPacketId: created.qitemId, ownerSession: owner, resumeCount: instance.resumeCount + 1, exceptionItemsClosed: 0 };
+        });
+        const nudge = wake;
+        if (nudge)
+            await this.queueRepo.deliverWakeForSuccessor(nudge.qitemId, nudge.session, nudge.nudge, input.actorSession);
+        return output;
+    }
     async route(input) {
         let result;
         let nudgeTo = null;
@@ -693,9 +981,26 @@ export class WorkflowRuntime {
             if (instance.status !== "active" && instance.status !== "waiting") {
                 throw new WorkflowProjectorError("instance_not_active", `instance ${instance.instanceId} is ${instance.status}; only a live (active|waiting) instance can be re-routed`, { instanceId: instance.instanceId, status: instance.status });
             }
-            const oldPacketId = instance.currentFrontier[0];
+            let oldPacketId = input.packetId;
+            if (!oldPacketId) {
+                if (instance.currentFrontier.length !== 1) {
+                    if (instance.currentFrontier.length === 0) {
+                        throw new WorkflowProjectorError("packet_not_found", `instance ${instance.instanceId} has an empty frontier; nothing to re-route`, { instanceId: instance.instanceId });
+                    }
+                    const candidates = instance.currentFrontier.map((packetId) => {
+                        const binding = this.instanceStore.getFrontierBinding(instance.instanceId, packetId);
+                        const packet = this.queueRepo.getById(packetId);
+                        return { packetId, stepId: binding?.stepId ?? null, ownerSession: packet?.destinationSession ?? null };
+                    });
+                    throw new WorkflowProjectorError("frontier_packet_required", `instance ${instance.instanceId} has ${instance.currentFrontier.length} live packets; --packet is required`, { instanceId: instance.instanceId, candidates });
+                }
+                [oldPacketId] = instance.currentFrontier;
+            }
             if (!oldPacketId) {
-                throw new WorkflowProjectorError("packet_not_found", `instance ${instance.instanceId} has an empty frontier; nothing to re-route`, { instanceId: instance.instanceId });
+                throw new WorkflowProjectorError("packet_not_found", `instance ${instance.instanceId} has no selectable frontier packet`, { instanceId: instance.instanceId });
+            }
+            if (!instance.currentFrontier.includes(oldPacketId)) {
+                throw new WorkflowProjectorError("packet_not_on_frontier", `qitem ${oldPacketId} is not in workflow instance ${instance.instanceId} frontier`, { instanceId: instance.instanceId, packetId: oldPacketId, frontier: instance.currentFrontier });
             }
             const oldPacket = this.queueRepo.getById(oldPacketId);
             if (!oldPacket) {
@@ -706,8 +1011,10 @@ export class WorkflowRuntime {
             // to explicit --next-owner overrides — an explicit route target
             // never silently defeats a declared pin.
             const specRow = this.specCache.getByNameVersion(instance.workflowName, instance.workflowVersion);
-            const step = instance.currentStepId && specRow
-                ? specRow.spec.steps.find((s) => s.id === instance.currentStepId) ?? null
+            const oldBinding = this.instanceStore.getFrontierBinding(instance.instanceId, oldPacketId);
+            const selectedStepId = oldBinding?.stepId ?? (instance.currentFrontier.length === 1 ? instance.currentStepId : null);
+            const step = selectedStepId && specRow
+                ? specRow.spec.steps.find((s) => s.id === selectedStepId) ?? null
                 : null;
             if (step) {
                 reconcileExplicitOwnerHarness(step, input.toSession, (session) => nodeRuntimeOf(this.db, session));
@@ -722,7 +1029,7 @@ export class WorkflowRuntime {
                 closureReason: "handed_off_to",
                 closureTarget: input.toSession,
                 handedOffTo: input.toSession,
-                transitionNote: `workflow route: ${input.actorSession} re-routed step ${instance.currentStepId ?? "?"} from ${fromSession} to ${input.toSession}${input.reason ? ` — ${input.reason}` : ""}`,
+                transitionNote: `workflow route: ${input.actorSession} re-routed step ${selectedStepId ?? "?"} from ${fromSession} to ${input.toSession}${input.reason ? ` — ${input.reason}` : ""}`,
             });
             register(closed.persistedEvent);
             // Recreate the SAME step for the new owner (step identity is the
@@ -736,10 +1043,19 @@ export class WorkflowRuntime {
             // rejects the repark below (human_route_fields_required) and
             // the waiting-on-human class — the one route most exists for —
             // becomes un-routable.
+            const routedPacketId = newQitemId();
             const created = this.queueRepo.createWithinTransaction({
+                qitemId: routedPacketId,
                 sourceSession: input.actorSession,
                 destinationSession: input.toSession,
-                body: oldPacket.body,
+                body: withWorkflowContinuation({
+                    body: oldPacket.body,
+                    instanceId: instance.instanceId,
+                    packetId: routedPacketId,
+                    ownerSession: input.toSession,
+                    step: step ?? undefined,
+                    contextRefs: specRow?.spec.context_refs,
+                }),
                 priority: oldPacket.priority ?? "routine",
                 tier: oldPacket.tier ?? "mode2",
                 // OPR.0.4.6.WF5 (rev1-r2 B1 fold): the successor IS the same work
@@ -786,21 +1102,46 @@ export class WorkflowRuntime {
                     closureTarget: oldPacket.blockedOn,
                     blockedOn: oldPacket.blockedOn,
                     transitionNote: `workflow route: park preserved (${oldPacket.blockedOn})`,
+                    wakeAfterSeconds: step?.re_present_after_seconds,
+                    wakeMaxSeconds: step?.re_present_max_seconds,
+                    wakeMessage: step?.re_present_after_seconds !== undefined
+                        ? workflowWaitWakeMessage({
+                            spec: specRow.spec,
+                            instance,
+                            step,
+                            packetId: routedPacketId,
+                            ownerSession: input.toSession,
+                        })
+                        : undefined,
                 });
                 register(reparked.persistedEvent);
             }
             // (2)+(5)+(7) frontier REBIND: same step, new packet, version
             // guard held; NO hop bump (not an advance).
-            this.instanceStore.updateFrontier(instance.instanceId, [created.qitemId], instance.status, {
-                currentStepId: "preserve",
+            const nextFrontier = instance.currentFrontier.map((packetId) => packetId === oldPacketId ? created.qitemId : packetId);
+            if (oldBinding) {
+                this.instanceStore.removeFrontierBinding(instance.instanceId, oldPacketId);
+                this.instanceStore.bindFrontierPacket({
+                    instanceId: instance.instanceId,
+                    packetId: created.qitemId,
+                    stepId: oldBinding.stepId,
+                    branchDrive: oldBinding.branchDrive,
+                    hopCount: oldBinding.hopCount,
+                    hopsBaseline: oldBinding.hopsBaseline,
+                });
+            }
+            const rebound = this.instanceStore.listFrontierBindings(instance.instanceId);
+            this.instanceStore.updateFrontier(instance.instanceId, nextFrontier, instance.status, {
+                currentStepId: rebound.length === 1 ? rebound[0].stepId : rebound.length > 1 ? "clear" : "preserve",
                 expectedVersion: instance.version,
             });
             // Keepalive re-target IN-TXN (arch n3: covers route's lost-nudge
             // window — the armed job re-nudges the new owner).
             if (this.watchdogJobsRepo) {
-                disarmWorkflowKeepalive(this.watchdogJobsRepo, instance.instanceId, `workflow route: re-targeted to ${input.toSession}`);
+                disarmWorkflowKeepalive(this.watchdogJobsRepo, instance.instanceId, `workflow route: re-targeted to ${input.toSession}`, oldBinding ? oldPacketId : undefined);
                 ensureWorkflowKeepaliveArmed(this.watchdogJobsRepo, {
                     instanceId: instance.instanceId,
+                    packetId: oldBinding ? created.qitemId : undefined,
                     targetSession: input.toSession,
                     registeredBySession: input.actorSession,
                 });
@@ -813,13 +1154,13 @@ export class WorkflowRuntime {
                 rigName: instance.boundRig ?? specRow?.targetRig ?? "",
                 cause: "workflow_route",
                 instanceId: instance.instanceId,
-                stepId: instance.currentStepId,
+                stepId: selectedStepId,
                 from: fromSession,
                 to: input.toSession,
             }));
             result = {
                 instanceId: instance.instanceId,
-                stepId: instance.currentStepId,
+                stepId: selectedStepId,
                 closedPacketId: oldPacketId,
                 newPacketId: created.qitemId,
                 fromSession,
@@ -847,7 +1188,14 @@ export class WorkflowRuntime {
     continue(instanceId) {
         const instance = this.instanceStore.getByIdOrThrow(instanceId);
         const trail = this.trailLog.listForInstance(instanceId);
-        return { instance: this.withDeadline(instance), trail };
+        const inspected = this.inspect(instanceId);
+        return {
+            instance: this.withDeadline(instance),
+            trail,
+            frontier: inspected.frontier,
+            failures: inspected.failures,
+            unknowns: inspected.unknowns,
+        };
     }
     /**
      * OPR.0.4.6.WF1 FR-2 COMPLETION FIXBACK (build-vs-ratified-AC debt,
@@ -879,7 +1227,15 @@ export class WorkflowRuntime {
     /** List instances (optionally filtered) with the deadline verdict attached. */
     listInstancesWithDeadline(status) {
         const rows = status ? this.instanceStore.listByStatus(status) : this.instanceStore.listAll();
-        return rows.map((row) => this.withDeadline(row));
+        return rows.map((row) => {
+            const inspected = this.inspect(row.instanceId);
+            return {
+                ...this.withDeadline(row),
+                frontierPackets: inspected.frontier,
+                failureOccurrences: inspected.failures,
+                unknowns: inspected.unknowns,
+            };
+        });
     }
 }
 function workflowInstantiateBody(input) {
@@ -901,7 +1257,14 @@ function workflowInstantiateBody(input) {
     if (input.entryStep.objective) {
         lines.push("", `Step objective: ${input.entryStep.objective}`);
     }
-    return lines.join("\n");
+    return withWorkflowContinuation({
+        body: lines.join("\n"),
+        contextRefs: input.spec.context_refs,
+        instanceId: input.instanceId,
+        packetId: input.packetId,
+        ownerSession: input.ownerSession,
+        step: input.entryStep,
+    });
 }
 export { WorkflowInstanceError, WorkflowProjectorError, WorkflowSpecError, };
 //# sourceMappingURL=workflow-runtime.js.map