fraim 2.0.360-next.2 → 2.0.360

package/dist/src/core/ai-mentor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIMentor = void 0;
+const crypto_1 = require("crypto");
 const include_resolver_1 = require("./utils/include-resolver");
 const resolve_phase_edge_1 = require("./resolve-phase-edge");
 class AIMentor {
@@ -31,18 +32,53 @@ class AIMentor {
                 throw new Error(`Phase "${args.currentPhase}" not found in job "${args.jobName}".`);
             }
         }
+        let response;
         if (args.status === 'starting') {
-            return await this.generateStartingMessage(workflow, args.currentPhase, args.skipIncludes, args.requestInstructions);
+            response = await this.generateStartingMessage(workflow, args.currentPhase, args.skipIncludes, args.requestInstructions);
         }
         else if (args.status === 'complete') {
-            return await this.generateCompletionMessage(workflow, args.currentPhase, args.findings, args.evidence, args.skipIncludes);
+            response = await this.generateCompletionMessage(workflow, args.currentPhase, args.findings, args.evidence, args.skipIncludes);
         }
         else {
             // Issue #1123: findings/evidence must reach the failure path too. The
             // MCP layer has always forwarded them for every status; only this hop
             // dropped them, which is why a failure edge could not be discriminated.
-            return await this.generateHelpMessage(workflow, args.currentPhase, args.status, args.skipIncludes, args.findings, args.evidence);
+            response = await this.generateHelpMessage(workflow, args.currentPhase, args.status, args.skipIncludes, args.findings, args.evidence);
         }
+        response.workflowDigest = (0, crypto_1.createHash)('sha256').update(JSON.stringify({ metadata: workflow.metadata, phases: Array.from(workflow.phases.entries()), overview: workflow.overview })).digest('hex');
+        const phases = workflow.metadata.phases;
+        const member = (0, resolve_phase_edge_1.findRecurrenceForMember)(phases, args.currentPhase);
+        const definition = phases?.[args.currentPhase];
+        const edge = args.status === 'complete' && !(0, resolve_phase_edge_1.isRecurrencePhase)(definition) ? definition?.onSuccess
+            : args.status === 'failure' ? member?.node[member.role].onFailure ?? (!(0, resolve_phase_edge_1.isRecurrencePhase)(definition) ? definition?.onFailure : undefined) : undefined;
+        if (edge != null && !(0, resolve_phase_edge_1.resolvePhaseEdge)(edge, (0, resolve_phase_edge_1.resolveDiscriminant)(args.findings, args.evidence))) {
+            response.outcome = { kind: 'invalid', reason: 'The workflow edge has no matching valid target.' };
+        }
+        else if (response.nextPhase === resolve_phase_edge_1.WAITING_FOR_NEXT_INVOCATION) {
+            response.outcome = { kind: 'recurring_wait' };
+        }
+        else if (response.nextPhase === resolve_phase_edge_1.AWAITING_RECURRING_REVIEW) {
+            response.outcome = { kind: 'review_wait' };
+        }
+        else if (response.nextPhase && !workflow.isSimple && !phases?.[response.nextPhase]
+            && !workflow.phases.has(response.nextPhase) && !(0, resolve_phase_edge_1.findRecurrenceForMember)(phases, response.nextPhase)) {
+            response.outcome = { kind: 'invalid', reason: `Workflow target ${response.nextPhase} does not exist.` };
+        }
+        else if (response.nextPhase) {
+            response.outcome = { kind: 'next', phaseId: response.nextPhase };
+        }
+        else if (args.status === 'complete' && (workflow.isSimple || definition || member?.role === 'done')) {
+            response.outcome = { kind: 'terminal' };
+        }
+        else if (workflow.isSimple) {
+            response.outcome = { kind: 'next', phaseId: args.currentPhase };
+        }
+        else {
+            response.outcome = { kind: 'invalid', reason: 'Only a declared workflow leaf may terminate execution.' };
+        }
+        if (response.outcome.kind === 'invalid')
+            response.message = `Phase transition rejected: ${response.outcome.reason}`;
+        return response;
     }
     async getOrLoadJob(jobType) {
         if (this.jobCache.has(jobType)) {

package/dist/src/core/handoff-contracts.js

@@ -7,7 +7,7 @@
  *
  *   - evidence.reviewHandoff   (job's submission phase, status === "complete";
  *                               see isSubmitPhase for how that phase is found)
- *   - evidence.nextJobRecommendations  (retrospective phase completion)
+ *   - evidence.nextJobRecommendations  (optional at submission, or completion for jobs without submission)
  *   - evidence.delegationLedger  (create-delegation-graph phase)
  *
  * Lives in src/core so both the local MCP proxy and evals can import the same
@@ -507,6 +507,28 @@ function validateNextJobRecommendations(value) {
         if (typeof rec.contextSummary === 'string' && rec.contextSummary.length > 300) {
             errors.push(`evidence.nextJobRecommendations[${i}].contextSummary must be 300 characters or fewer`);
         }
+        if (rec.artifactIds !== undefined && (!Array.isArray(rec.artifactIds)
+            || rec.artifactIds.some(id => typeof id !== 'string' || !id.trim()))) {
+            errors.push(`evidence.nextJobRecommendations[${i}].artifactIds must be an array of non-empty artifact references`);
+        }
+        if (rec.prerequisites !== undefined) {
+            const kinds = new Set(['approved_artifact', 'delivered_artifact', 'selected_action_success', 'required_child_success', 'external_result']);
+            if (!Array.isArray(rec.prerequisites)) {
+                errors.push(`evidence.nextJobRecommendations[${i}].prerequisites must be an array`);
+            }
+            else {
+                rec.prerequisites.forEach((value, index) => {
+                    const prerequisite = value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+                    if (!prerequisite || typeof prerequisite.kind !== 'string' || !kinds.has(prerequisite.kind)
+                        || typeof prerequisite.reference !== 'string' || !prerequisite.reference.trim()) {
+                        errors.push(`evidence.nextJobRecommendations[${i}].prerequisites[${index}] requires a supported kind and non-empty reference`);
+                    }
+                });
+            }
+        }
+        if (['ready', 'readiness', 'readinessReason', 'candidateId', 'revisionId', 'sourceRunId', 'sourceConversationId', 'startedRunId'].some(key => key in rec)) {
+            errors.push(`evidence.nextJobRecommendations[${i}] must not claim readiness or server-owned revision/source/start identities; provide prerequisites and artifactIds instead`);
+        }
     });
     return errors.length > 0 ? errors : null;
 }
@@ -657,7 +679,11 @@ evidence: {
       jobId: "<job-slug>",
       label: "<human-readable label>",
       reason: "<optional: why this job is recommended>",
-      contextSummary: "<optional: one sentence context for the next agent>"
+      contextSummary: "<optional: one sentence context for the next agent>",
+      artifactIds: ["<optional: reference from the reviewed artifact manifest>"],
+      prerequisites: [{ kind: "approved_artifact", reference: "<artifact reference>" }]
+      // Other kinds: delivered_artifact, selected_action_success, required_child_success, external_result.
+      // Omit optional dependencies when none apply. Never emit readiness or server-owned identities.
     }
     // 0–3 entries; an empty array [] is valid
   ]

package/dist/src/core/review-lifecycle.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewDigest = reviewDigest;
+exports.createReviewLifecycle = createReviewLifecycle;
+exports.activateReviewJob = activateReviewJob;
+exports.activeReview = activeReview;
+exports.currentReviewTerminalReceipt = currentReviewTerminalReceipt;
+exports.obligationDigest = obligationDigest;
+exports.submitReviewRevision = submitReviewRevision;
+exports.decideReviewRevision = decideReviewRevision;
+exports.acceptReviewReceipt = acceptReviewReceipt;
+exports.unsupportedReviewDeliveryActions = unsupportedReviewDeliveryActions;
+exports.projectReviewLifecycle = projectReviewLifecycle;
+exports.normalizeReviewCandidates = normalizeReviewCandidates;
+exports.candidateReadiness = candidateReadiness;
+const crypto_1 = require("crypto");
+function reviewDigest(value) {
+    const canonical = (v) => Array.isArray(v) ? v.map(canonical)
+        : v && typeof v === 'object' ? Object.fromEntries(Object.entries(v).filter(([, x]) => x !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([k, x]) => [k, canonical(x)])) : v;
+    return (0, crypto_1.createHash)('sha256').update(JSON.stringify(canonical(value))).digest('hex');
+}
+function createReviewLifecycle(source) {
+    return { version: 1, sequence: 0, source, jobs: {}, reviewsByJobInstance: {}, operations: {}, consumedReceipts: [] };
+}
+function activateReviewJob(state, job) {
+    state.jobs[job.jobInstanceId] = { ...job, ...(state.jobs[job.jobInstanceId]?.manualClosure ? { manualClosure: state.jobs[job.jobInstanceId].manualClosure } : {}) };
+    state.activeJob = state.jobs[job.jobInstanceId];
+}
+function activeReview(state) {
+    return state?.activeJob ? state.reviewsByJobInstance[state.activeJob.jobInstanceId] : undefined;
+}
+function currentReviewTerminalReceipt(state) {
+    const job = state?.activeJob;
+    const review = activeReview(state);
+    const receipt = review?.terminalReceipt;
+    return receipt && job && receipt.sourceRunId === state?.source.runId && receipt.jobInstanceId === job.jobInstanceId
+        && receipt.jobName === job.jobName && receipt.workflowDigest === review?.workflowDigest
+        && receipt.sessionId === job.sessionId && receipt.executionEpoch === job.executionEpoch
+        && receipt.revisionId === review?.revisionId && receipt.obligationSetDigest === obligationDigest(review.obligations)
+        ? receipt : undefined;
+}
+function obligationDigest(obligations) {
+    // Verification outcomes change as delivery completes; membership and identity do not.
+    return reviewDigest(obligations.map(({ id, kind, subject, issueNumber, childRunId, childJobName, childJobInstanceId, childRevisionId }) => ({ id, kind, subject, issueNumber, childRunId, childJobName, childJobInstanceId, childRevisionId })).sort((a, b) => a.id.localeCompare(b.id)));
+}
+function submitReviewRevision(state, input, resubmission = false) {
+    const manifest = [...input.manifest].sort((a, b) => a.id.localeCompare(b.id));
+    const target = input.handoff.reviewTarget;
+    const revisionId = reviewDigest({ source: state.source, owner: input.jobInstanceId, jobName: input.jobName, workflowDigest: input.workflowDigest,
+        target: target ? { type: target.type, url: target.url || undefined } : undefined, manifest });
+    const old = state.reviewsByJobInstance[input.jobInstanceId];
+    const actionSetDigest = reviewDigest(input.handoff.reviewActions || []);
+    const candidates = input.candidates.map(c => {
+        const candidateId = reviewDigest({ revisionId, ...candidateIdentity(c) });
+        return { ...c, candidateId, revisionId, sourceRunId: state.source.runId, sourceConversationId: state.source.conversationId };
+    }).filter((c, index, all) => all.findIndex(other => other.candidateId === c.candidateId) === index).slice(0, 3);
+    if (old?.revisionId === revisionId && old.actionSetDigest === actionSetDigest) {
+        if (resubmission && old.decision?.status === 'changes_requested') {
+            old.history.push({ revisionId: old.revisionId, decision: old.decision, manifest: old.manifest, handoff: old.handoff });
+            delete old.decision;
+            delete old.terminalReceipt;
+            old.obligations = [];
+        }
+        old.handoff = input.handoff;
+        old.candidates = candidates.map(candidate => ({ ...candidate,
+            ...(old.candidates.find(prior => prior.candidateId === candidate.candidateId)?.startedRunId
+                ? { startedRunId: old.candidates.find(prior => prior.candidateId === candidate.candidateId).startedRunId } : {}),
+        }));
+        return old;
+    }
+    const review = {
+        jobInstanceId: input.jobInstanceId, jobName: input.jobName, workflowDigest: input.workflowDigest,
+        handoff: input.handoff, manifest, revisionId, actionSetDigest, candidates, obligations: [],
+        history: old ? [...old.history, { revisionId: old.revisionId, decision: old.decision, terminalReceipt: old.terminalReceipt, manifest: old.manifest, handoff: old.handoff }] : [],
+    };
+    state.reviewsByJobInstance[input.jobInstanceId] = review;
+    return review;
+}
+function decideReviewRevision(state, input, obligations = []) {
+    const review = activeReview(state);
+    if (state.activeJob?.manualClosure)
+        throw new Error('This job was closed manually. Start a new job to continue work.');
+    if (!review || review.revisionId !== input.revisionId || review.actionSetDigest !== input.actionSetDigest)
+        throw new Error('The reviewed result changed. Refresh before deciding.');
+    const action = review.handoff.reviewActions?.find(a => a.id === input.actionId);
+    if (!action || !['approve', 'approve_delivery', 'request_changes'].includes(action.kind) || !input.decisionId)
+        throw new Error('This review action is not available.');
+    const existingOperation = state.operations[input.decisionId];
+    if (existingOperation && (existingOperation.payloadDigest !== reviewDigest(input) || existingOperation.jobInstanceId !== review.jobInstanceId))
+        throw new Error('This decision identifier is already bound to another decision.');
+    if (existingOperation)
+        return { duplicate: true, review, operation: existingOperation };
+    if (review.decision) {
+        if (review.decision.decisionId === input.decisionId && review.decision.actionId === input.actionId)
+            return { duplicate: true, review, operation: state.operations[input.decisionId] };
+        throw new Error('This revision already has a review decision.');
+    }
+    review.decision = { ...input, status: action.kind === 'request_changes' ? 'changes_requested' : 'approved', at: new Date().toISOString(), action };
+    review.obligations = obligations;
+    delete review.terminalReceipt;
+    const operation = { id: input.decisionId, kind: 'approval', payloadDigest: reviewDigest(input), state: 'reserved', jobInstanceId: review.jobInstanceId, revisionId: review.revisionId };
+    state.operations[operation.id] = operation;
+    return { duplicate: false, review, operation };
+}
+function acceptReviewReceipt(state, receipt) {
+    if (state.consumedReceipts.includes(receipt.acceptanceId))
+        return false;
+    const review = state.reviewsByJobInstance[receipt.jobInstanceId];
+    const job = state.jobs[receipt.jobInstanceId];
+    if (!review || !job || receipt.sourceRunId !== state.source.runId || receipt.jobName !== review.jobName
+        || receipt.sessionId !== job.sessionId || receipt.executionEpoch !== job.executionEpoch
+        || receipt.workflowDigest !== review.workflowDigest || receipt.revisionId !== review.revisionId)
+        return false;
+    if (receipt.requestedStatus === 'complete' && receipt.outcome === 'terminal'
+        && receipt.obligationSetDigest === obligationDigest(review.obligations)) {
+        review.terminalReceipt = receipt;
+        state.consumedReceipts.push(receipt.acceptanceId);
+        return true;
+    }
+    return false;
+}
+function unsupportedReviewDeliveryActions(subject) {
+    return subject.split('+').filter(action => !['merge_pr', 'merge_pr_work_completion', 'cleanup_branch'].includes(action));
+}
+function projectReviewLifecycle(state) {
+    const job = state.activeJob;
+    const review = activeReview(state);
+    const view = { version: 1, sequence: state.sequence, jobInstanceId: job?.jobInstanceId,
+        revisionId: review?.revisionId, actionSetDigest: review?.actionSetDigest,
+        decisionStatus: review ? review.decision?.status || 'pending' : undefined, displayState: 'working' };
+    if (job?.manualClosure)
+        return { ...view, displayState: 'closed_manually', attentionReason: 'Closed manually. Delivery and unresolved obligations remain unverified.' };
+    if (job?.state === 'error')
+        return { ...view, displayState: 'error', attentionReason: 'The active job needs recovery.' };
+    if (job?.state === 'scheduled')
+        return { ...view, displayState: 'scheduled' };
+    if (job?.state === 'waiting')
+        return { ...view, displayState: 'waiting', attentionReason: 'The active job needs a decision.' };
+    if (!review)
+        return { ...view, displayState: job?.state === 'complete' ? 'complete' : 'working' };
+    if (review.verificationError)
+        return { ...view, displayState: 'error', attentionReason: review.verificationError };
+    if (!review.decision || review.decision.status === 'changes_requested')
+        return { ...view, displayState: 'waiting', attentionReason: review.decision ? 'Changes requested.' : 'Review the current result.' };
+    if (review.obligations.some(o => o.state === 'failed'))
+        return { ...view, displayState: 'error', attentionReason: 'Required delivery failed.' };
+    if (review.terminalReceipt && review.terminalReceipt.sessionId === job?.sessionId
+        && review.terminalReceipt.executionEpoch === job?.executionEpoch && review.terminalReceipt.revisionId === review.revisionId
+        && review.terminalReceipt.obligationSetDigest === obligationDigest(review.obligations)
+        && review.obligations.every(o => o.state === 'succeeded'))
+        return { ...view, displayState: 'complete' };
+    const unsupported = review.obligations.filter(o => o.kind === 'delivery' && o.state !== 'succeeded')
+        .flatMap(o => unsupportedReviewDeliveryActions(o.subject));
+    return { ...view, displayState: 'finalizing', ...(unsupported.length ? { attentionReason: `Cannot automatically verify ${[...new Set(unsupported)].join(', ')}. Mark complete can close the job manually without confirming delivery.` } : {}) };
+}
+function candidateIdentity(candidate) {
+    return { jobId: candidate.jobId,
+        prerequisites: [...new Set((candidate.prerequisites || []).map(p => JSON.stringify({ kind: p.kind, reference: p.reference })))].sort(),
+        artifactIds: [...new Set(candidate.artifactIds || [])].sort() };
+}
+function normalizeReviewCandidates(value) {
+    if (!Array.isArray(value))
+        return [];
+    const kinds = new Set(['approved_artifact', 'delivered_artifact', 'selected_action_success', 'required_child_success', 'external_result']);
+    return value.filter((c) => !!c && typeof c === 'object' && typeof c.jobId === 'string'
+        && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(c.jobId) && typeof c.label === 'string' && !!c.label.trim()
+        && (c.artifactIds === undefined || Array.isArray(c.artifactIds) && c.artifactIds.every((x) => typeof x === 'string'))
+        && (c.prerequisites === undefined || Array.isArray(c.prerequisites) && c.prerequisites.every((p) => p && kinds.has(p.kind) && typeof p.reference === 'string')))
+        .filter((c, index, all) => all.findIndex(other => reviewDigest(candidateIdentity(other)) === reviewDigest(candidateIdentity(c))) === index)
+        .slice(0, 3).map(c => ({ jobId: c.jobId, label: c.label, reason: typeof c.reason === 'string' ? c.reason : undefined,
+        contextSummary: typeof c.contextSummary === 'string' ? c.contextSummary : undefined, artifactIds: c.artifactIds, prerequisites: c.prerequisites }));
+}
+function candidateReadiness(review, candidate, available) {
+    if (!available)
+        return { readiness: 'unavailable', readinessReason: 'Unavailable in this project.' };
+    if (review.verificationError)
+        return { readiness: 'unavailable', readinessReason: review.verificationError };
+    if (review.decision?.status !== 'approved')
+        return { readiness: 'waiting', readinessReason: 'Waiting for approval of this result.' };
+    for (const p of candidate.prerequisites || []) {
+        const artifact = review.manifest.find(a => a.id === p.reference);
+        const obligation = review.obligations.find(o => o.id === p.reference || o.subject === p.reference);
+        const met = p.kind === 'approved_artifact' ? !!artifact
+            : p.kind === 'delivered_artifact' ? !!artifact
+                && review.obligations.some(o => o.kind === 'artifact' && o.subject === artifact.id && o.state === 'succeeded')
+                // Matching local bytes prove integrity, not publication or receipt at a destination.
+                // Delivery remains unknown until the selected action's owning verifier supplies proof.
+                && review.obligations.some(o => o.kind === 'delivery')
+                && review.obligations.filter(o => o.kind === 'delivery').every(o => o.state === 'succeeded' && !!o.evidenceRef)
+                : p.kind === 'selected_action_success' ? obligation?.kind === 'delivery' && obligation.state === 'succeeded'
+                    : p.kind === 'required_child_success' ? obligation?.kind === 'child' && obligation.state === 'succeeded'
+                        : false; // External facts require an owning provider verifier; absence is never Ready.
+        if (!met)
+            return { readiness: 'waiting', readinessReason: `Waiting for ${p.kind.replace(/_/g, ' ')}: ${p.reference}.` };
+    }
+    if (candidate.artifactIds?.some(id => !review.manifest.some(a => a.id === id)))
+        return { readiness: 'unavailable', readinessReason: 'A referenced artifact is unavailable.' };
+    return { readiness: 'ready', readinessReason: 'Ready' };
+}

package/dist/src/core/run-recovery-state.js

@@ -1,7 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReviewExecutionBinding = parseReviewExecutionBinding;
 exports.safeRunStateKey = safeRunStateKey;
 const crypto_1 = require("crypto");
+/** Supplied only by the executing Hub's launch environment, never tool evidence. */
+function parseReviewExecutionBinding(value) {
+    if (!value)
+        return undefined;
+    let binding;
+    try {
+        binding = JSON.parse(value);
+    }
+    catch {
+        throw new Error('Invalid Hub review execution binding.');
+    }
+    const fields = ['sourceRunId', 'jobInstanceId', 'executionEpoch'];
+    if (!binding || fields.some(key => typeof binding[key] !== 'string' || !binding[key] || binding[key].length > 512)
+        || ['revisionId', 'obligationSetDigest'].some(key => binding[key] !== undefined && (typeof binding[key] !== 'string' || !binding[key] || binding[key].length > 512))
+        || Boolean(binding.revisionId) !== Boolean(binding.obligationSetDigest)
+        || (binding.sessionId !== undefined && typeof binding.sessionId !== 'string')) {
+        throw new Error('Invalid Hub review execution binding.');
+    }
+    return binding;
+}
 /** UUIDs retain their documented filenames; other IDs cannot become paths or device names. */
 function safeRunStateKey(id) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)

package/dist/src/local-mcp-server/artifact-retention-cleanup.js

@@ -16,6 +16,7 @@ const learning_source_record_1 = require("./learning-source-record");
 const artifact_paths_1 = require("../../registry/scripts/artifact-paths");
 const completion_state_1 = require("../../registry/scripts/learning/completion-state");
 const pack_home_1 = require("../cli/utils/pack-home");
+const review_lifecycle_1 = require("../core/review-lifecycle");
 exports.ARTIFACT_RETENTION_CATEGORIES = [
     'learning_archive',
     'retrospectives',
@@ -32,6 +33,108 @@ exports.ARTIFACT_RETENTION_CATEGORIES = [
     'learning_usage',
     'hub_event_logs',
 ];
+/** Read-only consumer of canonical conversation shard envelope v2 (not index headers).
+ * Keep this layout contract covered by store-written fixtures. The CLI package must
+ * not import Hub runtime or create another lifecycle writer/cache. Unknown or unreadable
+ * authority conservatively defers cleanup; a later healthy pass can apply retention.
+ */
+function activeReviewReferences() {
+    const paths = new Set();
+    const root = node_path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), 'ai-hub-conversations');
+    try {
+        let rootStat;
+        try {
+            rootStat = node_fs_1.default.lstatSync(root);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return { paths, unknown: false };
+            throw error;
+        }
+        if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
+            throw new Error('Unknown conversation root');
+        const records = [];
+        for (const bucket of node_fs_1.default.readdirSync(root, { withFileTypes: true })) {
+            if (!/^[a-f0-9]{16}$/.test(bucket.name))
+                continue;
+            if (!bucket.isDirectory() || bucket.isSymbolicLink())
+                throw new Error('Unreadable conversation bucket');
+            for (const file of node_fs_1.default.readdirSync(node_path_1.default.join(root, bucket.name), { withFileTypes: true })) {
+                if (!/^[a-f0-9]{40}\.json$/.test(file.name))
+                    continue;
+                if (!file.isFile() || file.isSymbolicLink())
+                    throw new Error('Unreadable conversation shard');
+                const envelope = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(root, bucket.name, file.name), 'utf8'));
+                if (envelope.version !== 2 || typeof envelope.conversation?.id !== 'string')
+                    throw new Error('Unknown conversation schema');
+                records.push({ bucket: bucket.name, record: envelope.conversation });
+            }
+        }
+        const complete = (record) => {
+            const state = record.reviewLifecycle;
+            if (state && state.version !== 1)
+                throw new Error('Unknown review version');
+            return state ? (0, review_lifecycle_1.projectReviewLifecycle)(state).displayState === 'complete'
+                : record.status === 'completed' && record.pauseReason === 'done';
+        };
+        const protect = (manifest, home) => {
+            if (!Array.isArray(manifest) || !home || !node_path_1.default.isAbsolute(home))
+                throw new Error('Unresolved input references');
+            for (const artifact of manifest) {
+                if (typeof artifact.locator !== 'string' || !artifact.locator)
+                    throw new Error('Unresolved artifact');
+                if (/^https?:\/\//i.test(artifact.locator))
+                    continue;
+                const target = node_path_1.default.resolve(home, artifact.locator);
+                paths.add(pathKey(target));
+                if (node_fs_1.default.existsSync(target))
+                    paths.add(pathKey(node_fs_1.default.realpathSync(target)));
+            }
+        };
+        for (const { bucket, record } of records) {
+            if (record.recommendationInput && !complete(record))
+                protect(record.recommendationInput.manifest, record.projectPath);
+            const state = record.reviewLifecycle;
+            if (!state)
+                continue;
+            if (state.version !== 1)
+                throw new Error('Unknown review version');
+            for (const review of Object.values(state.reviewsByJobInstance)) {
+                const job = state.jobs[review.jobInstanceId];
+                if (!job || (0, review_lifecycle_1.projectReviewLifecycle)({ ...state, activeJob: job }).displayState !== 'complete')
+                    protect(review.manifest, state.source.projectPath);
+            }
+            for (const operation of Object.values(state.operations)) {
+                if (operation.kind !== 'recommendation')
+                    continue;
+                const child = records.find(entry => entry.bucket === bucket && entry.record.id === operation.runId)?.record;
+                if (child && complete(child))
+                    continue;
+                const review = state.reviewsByJobInstance[operation.jobInstanceId];
+                const manifest = operation.input?.manifest || (review?.revisionId === operation.revisionId
+                    ? review.manifest : review?.history.find(previous => previous.revisionId === operation.revisionId)?.manifest);
+                protect(manifest, state.source.projectPath);
+            }
+        }
+        return { paths, unknown: false };
+    }
+    catch {
+        return { paths, unknown: true };
+    }
+}
+function reviewRetentionReason(candidate, references) {
+    if (references.unknown)
+        return 'Review input references are unavailable; retained until authority can be verified.';
+    try {
+        if (references.paths.has(pathKey(candidate.absolutePath))
+            || references.paths.has(pathKey(node_fs_1.default.realpathSync(candidate.absolutePath))))
+            return 'Active review or dependent assignment still requires this artifact.';
+    }
+    catch {
+        return 'Artifact location changed during cleanup; retained for a later pass.';
+    }
+    return undefined;
+}
 function contentRoot(workspaceRoot) {
     const packContent = node_path_1.default.join(workspaceRoot, 'personalized-employee');
     return node_fs_1.default.existsSync(packContent) ? packContent : node_path_1.default.join(workspaceRoot, 'fraim', 'personalized-employee');
@@ -424,6 +527,7 @@ function runArtifactCleanup(workspaceRoot, options) {
     const now = options.now ?? new Date();
     const retention = resolveArtifactRetentionConfig(workspaceRoot);
     const candidates = collectCandidates(workspaceRoot, options);
+    const reviewReferences = activeReviewReferences();
     const report = {
         generatedAt: now.toISOString(),
         apply: options.apply,
@@ -438,6 +542,9 @@ function runArtifactCleanup(workspaceRoot, options) {
             ? categoryValue === -1 || retention.values.feedback === -1 ? -1 : Math.max(categoryValue, retention.values.feedback)
             : categoryValue;
         let decision = shouldDelete(candidate, retentionValue, now);
+        const protectedReason = reviewRetentionReason(candidate, reviewReferences);
+        if (protectedReason)
+            decision = { delete: false, reason: protectedReason };
         let action;
         let error;
         if (!candidate.eligible) {
@@ -451,6 +558,10 @@ function runArtifactCleanup(workspaceRoot, options) {
         }
         else {
             try {
+                // A review or dependent assignment may have become active since planning.
+                const currentProtection = reviewRetentionReason(candidate, activeReviewReferences());
+                if (currentProtection)
+                    decision = { delete: false, reason: currentProtection };
                 if (candidate.recordHash && (!matchesConfiguredLocation(workspaceRoot, candidate) || !isConfinedRegularFile(workspaceRoot, candidate.absolutePath)
                     || recordHash(node_fs_1.default.readFileSync(candidate.absolutePath, 'utf8')) !== candidate.recordHash
                     || reservedSources(workspaceRoot).has(pathKey(candidate.absolutePath)))) {
@@ -468,7 +579,7 @@ function runArtifactCleanup(workspaceRoot, options) {
                         || current.sidecarPath !== candidate.sidecarPath) {
                         decision = { delete: false, reason: 'Archive changed or resumed after enumeration; retained for a later cleanup.' };
                     }
-                    else {
+                    else if (!currentProtection) {
                         decision = shouldDelete({ ...candidate, ...current }, retentionValue, now);
                     }
                 }

package/dist/src/local-mcp-server/stdio-server.js

@@ -1277,6 +1277,13 @@ class FraimLocalMCPServer {
         const temporary = `${path}.${(0, crypto_1.randomUUID)()}.tmp`;
         try {
             (0, fs_1.writeFileSync)(temporary, JSON.stringify(value), { encoding: 'utf8', mode: 0o600 });
+            const descriptor = (0, fs_1.openSync)(temporary, 'r+');
+            try {
+                (0, fs_1.fsyncSync)(descriptor);
+            }
+            finally {
+                (0, fs_1.closeSync)(descriptor);
+            }
             (0, fs_1.renameSync)(temporary, path);
         }
         finally {
@@ -1301,6 +1308,9 @@ class FraimLocalMCPServer {
             return;
         try {
             const root = this.getRunStateDir();
+            const hubRunId = process.env.FRAIM_HUB_RUN_ID;
+            const runPath = hubRunId ? (0, path_1.join)(root, 'runs', `${(0, run_recovery_state_1.safeRunStateKey)(hubRunId)}.json`) : undefined;
+            const previousPointer = runPath && (0, fs_1.existsSync)(runPath) ? JSON.parse((0, fs_1.readFileSync)(runPath, 'utf8')) : undefined;
             const jobId = typeof args.jobId === 'string' && args.jobId ? args.jobId : undefined;
             const stateFile = jobId ? `${(0, run_recovery_state_1.safeRunStateKey)(jobId)}.json`
                 : `anonymous-${(0, run_recovery_state_1.safeRunStateKey)(JSON.stringify([sessionId, args.jobName]))}.json`;
@@ -1338,13 +1348,27 @@ class FraimLocalMCPServer {
             }
             const timestamp = new Date().toISOString();
             const accepted = acceptedNext !== undefined;
+            const acceptedReceipts = previous?.acceptedReceipts || [];
+            let receipt = acceptedNext?.receipt;
+            let replay = false;
+            if (receipt) {
+                const existing = acceptedReceipts.find(item => item.acceptanceId === receipt.acceptanceId);
+                if (existing) {
+                    receipt = existing;
+                    replay = true;
+                }
+                else {
+                    receipt = { ...receipt, acceptedAt: timestamp, sequence: Math.max(previousPointer?.sequence || 0, acceptedReceipts[acceptedReceipts.length - 1]?.sequence || 0) + 1 };
+                    acceptedReceipts.push(receipt);
+                }
+            }
             const recoveringTerminalReview = previous?.status === 'waiting_review' && previous.currentPhase === null
                 && (args.status === 'starting' || args.status === 'incomplete');
             const currentPhase = recoveringTerminalReview ? null : accepted
                 ? (args.status === 'complete' ? acceptedNext.nextPhase : acceptedNext.nextPhase || args.currentPhase)
                 : previous ? previous.currentPhase : args.currentPhase;
             const completedPhases = previous?.completedPhases || [];
-            if (accepted && (args.status === 'complete' || args.status === 'failure')) {
+            if (accepted && !replay && (args.status === 'complete' || args.status === 'failure')) {
                 completedPhases.push({ phase: args.currentPhase, status: args.status, timestamp });
             }
             const parsedHandoff = [args.reviewHandoff, args.evidence?.reviewHandoff, args.findings?.reviewHandoff]
@@ -1372,24 +1396,111 @@ class FraimLocalMCPServer {
                 startedPhases: accepted && args.status === 'starting'
                     ? { ...previous?.startedPhases, [currentPhase || args.currentPhase]: timestamp }
                     : previous?.startedPhases || {},
-                completedPhases,
+                completedPhases, acceptedReceipts,
+                executionBinding: receipt?.revisionId ? {
+                    sourceRunId: receipt.sourceRunId, jobInstanceId: receipt.jobInstanceId, executionEpoch: receipt.executionEpoch,
+                    sessionId: receipt.sessionId, revisionId: receipt.revisionId, obligationSetDigest: receipt.obligationSetDigest,
+                } : previous?.executionBinding,
             };
-            this.writeRecoveryJson(statePath, state);
             const pointer = { jobId, sessionId, stateFile };
             this.writeRecoveryJson((0, path_1.join)(root, 'sessions', `${(0, run_recovery_state_1.safeRunStateKey)(sessionId)}.json`), pointer);
-            const hubRunId = process.env.FRAIM_HUB_RUN_ID;
-            if (hubRunId)
-                this.writeRecoveryJson((0, path_1.join)(root, 'runs', `${(0, run_recovery_state_1.safeRunStateKey)(hubRunId)}.json`), pointer);
+            if (runPath) {
+                const instanceId = jobId || `anonymous:${sessionId}:${args.jobName}`;
+                this.writeRecoveryJson(runPath, { ...pointer, sequence: Math.max(previousPointer?.sequence || 0, receipt?.sequence || 0), jobInstances: { ...previousPointer?.jobInstances, [instanceId]: pointer } });
+            }
+            // The receipt-bearing state is the commit point. Discovery writes may
+            // leave a missing/stale state on failure, but never an accepted receipt.
+            this.writeRecoveryJson(statePath, replay && previous ? previous : state);
+            return receipt;
         }
         catch (error) {
             this.log(`[phase-recovery] Could not persist recovery state: ${error.message}`);
+            if (acceptedNext?.receipt && process.env.FRAIM_HUB_RUN_ID)
+                throw new Error(`Accepted phase receipt could not be persisted: ${error.message}`);
         }
     }
+    /** Created only after the response has passed finalization, from runtime authority. */
+    persistAcceptedReceipt(args, sessionId, result, requestId) {
+        if (args.status === 'starting' && args.requestInstructions === true)
+            return undefined;
+        if (!result.outcome || result.outcome.kind === 'invalid' || !result.workflowDigest)
+            return undefined;
+        const binding = (0, run_recovery_state_1.parseReviewExecutionBinding)(process.env.FRAIM_REVIEW_BINDING);
+        const sourceRunId = binding?.sourceRunId || process.env.FRAIM_HUB_RUN_ID || '';
+        const jobInstanceId = args.jobId || `anonymous:${sessionId}:${args.jobName}`;
+        let ownBinding = binding?.jobInstanceId === jobInstanceId ? binding : undefined;
+        if (!ownBinding && binding && process.env.FRAIM_REVIEW_BINDINGS) {
+            let approved;
+            try {
+                approved = JSON.parse(process.env.FRAIM_REVIEW_BINDINGS);
+            }
+            catch {
+                throw new Error('Invalid Hub approved review bindings.');
+            }
+            const selected = approved && Object.prototype.hasOwnProperty.call(approved, jobInstanceId) ? approved[jobInstanceId] : undefined;
+            if (selected && typeof selected === 'object') {
+                const prior = (0, run_recovery_state_1.parseReviewExecutionBinding)(JSON.stringify({ ...selected, executionEpoch: binding.executionEpoch }));
+                if (prior && prior.jobInstanceId === jobInstanceId && prior.sourceRunId === binding.sourceRunId && prior.revisionId && prior.obligationSetDigest) {
+                    ownBinding = { sourceRunId: binding.sourceRunId, jobInstanceId, executionEpoch: binding.executionEpoch,
+                        revisionId: prior.revisionId, obligationSetDigest: prior.obligationSetDigest };
+                }
+            }
+        }
+        if (!ownBinding && binding && typeof args.jobId === 'string') {
+            // A later job can return to an already approved instance in this source.
+            // Recover only that instance's review identity; execution authority still
+            // comes from the current host epoch and the current MCP session.
+            try {
+                const state = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(this.getRunStateDir(), `${(0, run_recovery_state_1.safeRunStateKey)(args.jobId)}.json`), 'utf8'));
+                const prior = (0, run_recovery_state_1.parseReviewExecutionBinding)(JSON.stringify(state.executionBinding));
+                if (prior && state.jobId === jobInstanceId && state.currentJobName === args.jobName && prior.jobInstanceId === jobInstanceId
+                    && prior.sourceRunId === binding.sourceRunId && prior.revisionId && prior.obligationSetDigest) {
+                    ownBinding = { sourceRunId: binding.sourceRunId, jobInstanceId, executionEpoch: binding.executionEpoch,
+                        revisionId: prior.revisionId, obligationSetDigest: prior.obligationSetDigest };
+                }
+            }
+            catch { /* Missing owner history cannot supply approval authority. */ }
+        }
+        if (ownBinding?.sessionId && ownBinding.sessionId !== sessionId)
+            throw new Error('Review execution session does not match its Hub binding.');
+        if (!sessionId || sessionId === 'unknown') {
+            if (ownBinding)
+                throw new Error('Review execution requires an identifiable MCP session.');
+            return undefined;
+        }
+        const executionEpoch = binding?.executionEpoch || process.env.FRAIM_EXECUTION_EPOCH || sessionId;
+        const acceptanceId = (0, crypto_1.createHash)('sha256').update(JSON.stringify([sourceRunId, jobInstanceId, sessionId, executionEpoch, requestId, args.currentPhase, args.status, result.workflowDigest, result.outcome, ownBinding?.revisionId, ownBinding?.obligationSetDigest, args.evidence, args.findings])).digest('hex');
+        const parseStructured = (value) => {
+            if (typeof value !== 'string')
+                return value;
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const handoff = parseStructured(args.evidence?.reviewHandoff ?? args.findings?.reviewHandoff ?? args.reviewHandoff);
+        const recommendations = parseStructured(args.evidence?.nextJobRecommendations ?? args.findings?.nextJobRecommendations ?? args.nextJobRecommendations);
+        const receipt = {
+            version: 1, acceptanceId, acceptedAt: new Date().toISOString(), sequence: 0,
+            sourceRunId, jobInstanceId, jobName: args.jobName, workflowDigest: result.workflowDigest,
+            sessionId, executionEpoch, phaseId: args.currentPhase, requestedStatus: args.status,
+            outcome: result.outcome.kind, ...(result.nextPhase ? { nextPhase: result.nextPhase } : {}),
+            ...(ownBinding ? { revisionId: ownBinding.revisionId, obligationSetDigest: ownBinding.obligationSetDigest } : {}),
+            verifiedEvidenceRefs: [], ...(handoff ? { reviewHandoff: handoff } : {}),
+            ...(recommendations ? { nextJobRecommendations: recommendations } : {}),
+        };
+        if (Buffer.byteLength(JSON.stringify(receipt), 'utf8') > 262144)
+            throw new Error('Accepted phase receipt exceeds the 256 KiB limit.');
+        return this.recordRecoveryState(args, sessionId, { nextPhase: result.nextPhase, receipt });
+    }
     /** Called only after the response has passed every rejecting contract. */
-    acceptPhaseTracking(args, sessionId, nextPhase) {
+    acceptPhaseTracking(args, sessionId, nextPhase, recoveryRecorded = false) {
         if (args.status === 'starting' && args.requestInstructions === true)
             return '';
-        this.recordRecoveryState(args, sessionId, { nextPhase });
+        if (!recoveryRecorded)
+            this.recordRecoveryState(args, sessionId, { nextPhase });
         if (!sessionId || sessionId === 'unknown' || !args.jobName || !args.currentPhase) {
             return args.status === 'complete' || args.status === 'failure'
                 ? `Phase-start notice: phase ${args.currentPhase || '(unknown)'} cannot be matched to a run because its session or job identity is missing. Completion remains accepted.\n\n` : '';
@@ -2694,9 +2805,14 @@ class FraimLocalMCPServer {
                         };
                     }
                 }
+                let localWorkflowResolved = false;
                 try {
                     const mentor = this.getMentor(requestSessionId);
                     const tutoringResponse = await mentor.handleMentoringRequest(args);
+                    localWorkflowResolved = true;
+                    if (tutoringResponse.outcome?.kind === 'invalid') {
+                        return { jsonrpc: '2.0', id: request.id, result: { isError: true, content: [{ type: 'text', text: tutoringResponse.message }] } };
+                    }
                     this.log(`✅ Local seekMentoring succeeded for ${args.jobName}:${args.currentPhase}`);
                     // Quality enforcement (Issue #251).
                     //
@@ -2785,7 +2901,11 @@ class FraimLocalMCPServer {
                         phases: handoffPhaseMap,
                         repo: handoffRepoState,
                     });
-                    handoffErrors.push(...await this.validateNextJobRecommendationJobIds(args.evidence?.nextJobRecommendations, mentor));
+                    // Submission candidates are optional; the Hub filters unavailable jobs.
+                    // A malformed suggestion must not reject an otherwise valid review.
+                    if (!args.currentPhase.includes('submit') && !args.currentPhase.includes('submission')) {
+                        handoffErrors.push(...await this.validateNextJobRecommendationJobIds(args.evidence?.nextJobRecommendations, mentor));
+                    }
                     // Issue #1857: enforced on its own terms rather than folded into
                     // handoffErrors. `missingField` below reads handoffErrors[0], and the
                     // reviewHandoff escape hatch keys off that, so a reviewHandoff error in
@@ -2864,7 +2984,11 @@ class FraimLocalMCPServer {
                     const acceptedResponse = await this.finalizeLocalToolTextResponse(request, requestSessionId, requestId, tutoringResponse.message);
                     if (acceptedResponse.error || acceptedResponse.result?.isError)
                         return acceptedResponse;
-                    const phaseStartWarning = this.acceptPhaseTracking(args, requestSessionId, tutoringResponse.nextPhase);
+                    const acceptedReceipt = this.persistAcceptedReceipt(args, requestSessionId, tutoringResponse, request.id);
+                    const phaseStartWarning = this.acceptPhaseTracking(args, requestSessionId, tutoringResponse.nextPhase, !!acceptedReceipt);
+                    acceptedResponse.result.structuredContent = { ...acceptedResponse.result.structuredContent,
+                        phaseAccepted: true, nextPhase: tutoringResponse.nextPhase, outcome: tutoringResponse.outcome,
+                        workflowDigest: tutoringResponse.workflowDigest, ...(acceptedReceipt ? { acceptedReceipt } : {}) };
                     if (phaseStartWarning && acceptedResponse.result?.content?.[0]) {
                         acceptedResponse.result.content[0].text = phaseStartWarning + acceptedResponse.result.content[0].text;
                     }
@@ -2877,6 +3001,9 @@ class FraimLocalMCPServer {
                     return acceptedResponse;
                 }
                 catch (error) {
+                    if (localWorkflowResolved) {
+                        return { jsonrpc: '2.0', id: request.id, result: { isError: true, content: [{ type: 'text', text: `Phase acceptance failed: ${error.message}` }] } };
+                    }
                     this.log(`⚠️ Local seekMentoring failed: ${error.message}. Falling back to remote.`);
                     // If local fails, we continue to proxy to the remote server
                 }
@@ -2999,12 +3126,38 @@ class FraimLocalMCPServer {
         if (toolName === 'seekMentoring' && !processedResponse.error && !processedResponse.result?.isError
             && response.result?.structuredContent?.phaseAccepted === true) {
             const metadata = response.result.structuredContent;
+            let acceptedReceipt;
+            if (metadata.acceptedReceipt) {
+                const remote = metadata.acceptedReceipt;
+                if (remote.jobName !== args.jobName || remote.jobInstanceId !== (args.jobId || `anonymous:${requestSessionId}:${args.jobName}`)
+                    || remote.sessionId !== requestSessionId || remote.phaseId !== args.currentPhase || remote.requestedStatus !== args.status
+                    || !['next', 'terminal', 'recurring_wait', 'review_wait'].includes(remote.outcome)
+                    || typeof remote.workflowDigest !== 'string') {
+                    return { jsonrpc: '2.0', id: request.id, result: { isError: true, content: [{ type: 'text', text: 'Remote phase receipt did not match the executing request.' }] } };
+                }
+                try {
+                    acceptedReceipt = this.persistAcceptedReceipt(args, requestSessionId, {
+                        message: '', status: args.status, nextPhase: remote.nextPhase ?? null, workflowDigest: remote.workflowDigest,
+                        outcome: remote.outcome === 'next' ? { kind: 'next', phaseId: remote.nextPhase } : { kind: remote.outcome },
+                    }, request.id);
+                }
+                catch (error) {
+                    return { jsonrpc: '2.0', id: request.id, result: { isError: true, content: [{ type: 'text', text: `Phase acceptance failed: ${error.message}` }] } };
+                }
+                processedResponse.result.structuredContent = { ...processedResponse.result.structuredContent, ...(acceptedReceipt ? { acceptedReceipt } : {}) };
+            }
+            else if (process.env.FRAIM_REVIEW_BINDING && !(args.status === 'starting' && args.requestInstructions === true)) {
+                const binding = (0, run_recovery_state_1.parseReviewExecutionBinding)(process.env.FRAIM_REVIEW_BINDING);
+                if (binding?.revisionId && binding.jobInstanceId === args.jobId) {
+                    return { jsonrpc: '2.0', id: request.id, result: { isError: true, content: [{ type: 'text', text: 'Remote phase acceptance lacks a supported workflow receipt.' }] } };
+                }
+            }
             const textBlock = processedResponse.result?.content?.find((item) => item.type === 'text');
             if (textBlock) {
                 const remoteWarning = metadata.phaseStartWarning;
                 if (remoteWarning)
                     textBlock.text = textBlock.text.replace(remoteWarning, '');
-                textBlock.text = this.acceptPhaseTracking(args, requestSessionId, metadata.nextPhase) + textBlock.text;
+                textBlock.text = this.acceptPhaseTracking(args, requestSessionId, metadata.nextPhase, !!acceptedReceipt) + textBlock.text;
             }
         }
         this.log(`📤 ${injectedRequest.method} → ${processedResponse.error ? 'ERROR' : 'OK'}`);

package/dist/src/mcp/tool-schemas.js

@@ -369,7 +369,7 @@ Do not use this tool for other repositories or external project issue trackers.`
                     },
                     evidence: {
                         type: 'object',
-                        description: 'Structured evidence or data collected (e.g., prospect counts, test results). Submit phases should put review artifacts in evidence.reviewHandoff rather than printing raw JSON to the user. Retrospective phases may put follow-on job recommendations in evidence.nextJobRecommendations (array of { jobId, label, reason?, contextSummary? }, max 3) so the work surface can offer them as next steps.',
+                        description: 'Structured evidence or data collected (e.g., prospect counts, test results). Submit phases should put review artifacts in evidence.reviewHandoff rather than printing raw JSON to the user. Prepare optional follow-on candidates at submission in evidence.nextJobRecommendations (0-3 entries with jobId, label, reason?, contextSummary?, artifactIds?: string[], prerequisites?: {kind, reference}[]); Standalone jobs with an explicit recommendation step may emit there; the Hub retains submitted candidates through finalization. Prerequisite kinds: approved_artifact, delivered_artifact, selected_action_success, required_child_success, external_result. Reference actual artifacts/actions/children/provider evidence. Do not emit readiness or server-owned candidate/revision/source/start identities. Candidates are revealed only after persisted approval; selecting one prepares a draft, and only explicit Send starts a follow-on.',
                         additionalProperties: true
                     },
                     workingDirectory: {

package/dist/src/services/mcp-service.js

@@ -732,6 +732,8 @@ class McpService {
             findings: args.findings,
             requestInstructions: args.requestInstructions
         });
+        if (result.outcome?.kind === 'invalid')
+            return { isError: true, content: [{ type: 'text', text: result.message }] };
         // Handoff contract enforcement (Issue #916/#1157/#1276) fall-through
         // safety net, matching the quality-enforcement note just below.
         //
@@ -892,13 +894,26 @@ class McpService {
                 console.error(`❌ McpService: Failed to upsert executionMode:`, e);
             }
         }
-        return this.addRuleDelivery({
+        const finalized = await this.addRuleDelivery({
             content: [{
                     type: 'text',
                     text: trackingWarning + phaseStartWarning + result.message
                 }],
             structuredContent: { phaseAccepted: true, nextPhase: result.nextPhase, phaseStartWarning }
         }, args.jobName, args);
+        if (!finalized.isError && !restoringInstructions && result.outcome && result.workflowDigest && sessionId) {
+            // Remote-only execution has no trusted Hub binding. The executing local
+            // proxy verifies this envelope and supplies its own launch binding.
+            const acceptedReceipt = {
+                version: 1, acceptanceId: (0, crypto_1.randomUUID)(), acceptedAt: new Date().toISOString(), sequence: 0,
+                sourceRunId: '', jobInstanceId: args.jobId || `anonymous:${sessionId}:${args.jobName}`,
+                jobName: args.jobName, workflowDigest: result.workflowDigest, sessionId,
+                executionEpoch: sessionId, phaseId: args.currentPhase, requestedStatus: args.status,
+                outcome: result.outcome.kind, ...(result.nextPhase ? { nextPhase: result.nextPhase } : {}), verifiedEvidenceRefs: [],
+            };
+            finalized.structuredContent = { ...finalized.structuredContent, acceptedReceipt, outcome: result.outcome, workflowDigest: result.workflowDigest };
+        }
+        return finalized;
     }
     async addRuleDelivery(response, jobName, phaseArgs) {
         if (response.isError || response.personaLock)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim",
-  "version": "2.0.360-next.2",
+  "version": "2.0.360",
   "description": "FRAIM core CLI and MCP package.",
   "main": "index.js",
   "bin": {