From 8340d1d4d04ff55bcc72ace299d077bd0bc45789 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 01:09:23 +0000
Subject: [PATCH 01/19] fix(ai): Resolve issue #2594 - MCP: give operation
 receipts a readable lifecycle

Implemented by ProPR AI using gpt-5.6-sol model.

Implementation completed successfully.
---
 packages/api/mcp/operationLifecycle.ts        | 119 ++++++++++++++++++
 packages/api/mcp/operations.ts                |  86 ++++++++++++-
 packages/api/mcp/tools.ts                     |  26 +++-
 packages/api/test/mcpIntegration.test.ts      |   3 +-
 packages/api/test/mcpOperations.test.ts       |  97 +++++++++++++-
 packages/api/test/mcpTaskSubmissions.test.ts  |  24 +++-
 ...61001000000_add_mcp_operation_lifecycle.js |  33 +++++
 7 files changed, 377 insertions(+), 11 deletions(-)
 create mode 100644 packages/api/mcp/operationLifecycle.ts
 create mode 100644 packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
new file mode 100644
index 000000000..9e06f17e1
--- /dev/null
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -0,0 +1,119 @@
+import type { McpErrorEnvelope } from './errorEnvelope.js';
+import type { McpOperations, LifecycleOutcome, LifecycleState, Operation } from './operations.js';
+
+const startedTaskStates = new Set(['processing', 'claude_execution', 'post_processing']);
+const terminalStates = new Set<LifecycleOutcome>(['completed', 'failed', 'cancelled']);
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function positiveInteger(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    const number = Number(value);
+    if (Number.isSafeInteger(number) && number > 0) return number;
+  }
+  return undefined;
+}
+
+function nonEmptyString(...values: unknown[]): string | undefined {
+  return values.find(value => typeof value === 'string' && value.length > 0) as string | undefined;
+}
+
+function epochMilliseconds(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'string') return undefined;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+
+/** Translate the compatibility state into the persisted public lifecycle. */
+export function lifecycleFromLegacy(state: unknown): LifecycleState {
+  if (['running', 'accepted', 'posted', 'queued', 'browser_required'].includes(String(state))) return 'accepted';
+  if (['completed', 'failed', 'cancelled'].includes(String(state))) return String(state) as LifecycleState;
+  return 'unknown';
+}
+
+/** Collect stable output handles regardless of which legacy receipt layer exposed them. */
+export function artifactsFromReceipt(row: Operation, receipt: Record<string, unknown>): Record<string, unknown> {
+  const result = record(receipt.result) ?? {};
+  const continuation = record(result.continuation) ?? {};
+  const target = record(receipt.targetState) ?? {};
+  const targetIssues: Record<string, unknown>[] = Array.isArray(target.issues)
+    ? target.issues.map(record).filter((value): value is Record<string, unknown> => !!value) : [];
+  const artifacts: Record<string, unknown> = {};
+
+  const taskId = nonEmptyString(target.taskId, target.task_id, continuation.taskId, result.taskId,
+    ...targetIssues.flatMap(issue => [issue.taskId, issue.task_id]));
+  if (taskId) artifacts.taskId = taskId;
+
+  const repository = nonEmptyString(result.repository, row.repository);
+  const pullRequestNumber = positiveInteger(
+    result.pullRequest, result.pr_number, result.prNumber,
+    continuation.pullRequest, continuation.pr_number,
+    target.pullRequest, target.pr_number,
+    ...targetIssues.flatMap(issue => [issue.pullRequest, issue.pr_number]),
+  );
+  if (repository && pullRequestNumber) artifacts.pullRequest = {
+    repository,
+    number: pullRequestNumber,
+    url: `https://github.com/${repository}/pull/${pullRequestNumber}`,
+  };
+
+  const issueNumbers = new Set<number>();
+  for (const value of [result.issueNumber, result.issue_number, continuation.issueNumber, target.issueNumber, target.issue_number]) {
+    const number = positiveInteger(value);
+    if (number) issueNumbers.add(number);
+  }
+  if (Array.isArray(result.issues)) for (const value of result.issues) {
+    const number = positiveInteger(record(value)?.number, record(value)?.issueNumber, value);
+    if (number) issueNumbers.add(number);
+  }
+  for (const issue of targetIssues) {
+    const number = positiveInteger(issue.number, issue.issueNumber, issue.issue_number);
+    if (number) issueNumbers.add(number);
+  }
+  if (repository && issueNumbers.size) artifacts.issues = [...issueNumbers].map(number => ({
+    repository,
+    number,
+    url: `https://github.com/${repository}/issues/${number}`,
+  }));
+
+  const commentId = positiveInteger(result.commentId, continuation.commentId, target.commentId);
+  if (commentId) artifacts.commentId = commentId;
+  return artifacts;
+}
+
+/** Persist tracker observations without allowing stale concurrent polls to undo newer lifecycle facts. */
+export async function syncLifecycle(
+  operations: McpOperations,
+  row: Operation,
+  receipt: Record<string, unknown>,
+): Promise<void> {
+  const artifacts = artifactsFromReceipt(row, receipt);
+  if (Object.keys(artifacts).length) await operations.recordArtifacts(row.id, artifacts);
+
+  const target = record(receipt.targetState);
+  if (target) await operations.recordProgress(row.id, target);
+
+  const targetState = String(target?.state ?? '');
+  const receiptState = String(receipt.state ?? '');
+  if (startedTaskStates.has(targetState) || receiptState === 'running') {
+    await operations.markStarted(row.id, epochMilliseconds(target?.timestamp));
+  }
+
+  const outcome = terminalStates.has(receiptState as LifecycleOutcome)
+    ? receiptState as LifecycleOutcome
+    : row.tool !== 'run_ultrafix' && (target?.taskId || target?.task_id) && terminalStates.has(targetState as LifecycleOutcome)
+      ? targetState as LifecycleOutcome : undefined;
+  if (outcome) {
+    const result = record(receipt.result);
+    await operations.finish(row.id, outcome, record(result?.error) as McpErrorEnvelope | undefined);
+  }
+
+  if (row.tool === 'cancel_operation') {
+    const result = record(receipt.result);
+    const sourceId = nonEmptyString(result?.operationId);
+    if (sourceId && result?.cancellation === 'confirmed') await operations.finish(sourceId, 'cancelled');
+  }
+}
diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index 827ad39bb..b37283909 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -1,14 +1,19 @@
 import { randomUUID } from 'node:crypto';
 import type { Knex } from 'knex';
 import { McpError } from './config.js';
-import { classifyError } from './errorEnvelope.js';
+import { classifyError, type McpErrorEnvelope } from './errorEnvelope.js';
 import { digest } from './store.js';
 import type { McpPrincipal } from './policy.js';
+import { lifecycleFromLegacy } from './operationLifecycle.js';
 
 export interface OperationResult { status: number; data: unknown }
+export type LifecycleState = 'accepted' | 'running' | 'completed' | 'failed' | 'cancelled' | 'unknown';
+export type LifecycleOutcome = 'completed' | 'failed' | 'cancelled';
 export interface Operation {
   id: string; owner_id: string; grant_id: string; idempotency_key: string; tool: string; repository: string | null;
   state: string; result: string | null; created_at: number; updated_at: number; payload_hash: string;
+  lifecycle: LifecycleState; accepted_at: number | null; started_at: number | null; finished_at: number | null;
+  failure: string | null; artifacts: string | null; progress: string | null;
 }
 
 function canonical(value: unknown): string {
@@ -17,6 +22,25 @@ function canonical(value: unknown): string {
   return JSON.stringify(value);
 }
 
+function json(value: unknown): unknown {
+  if (typeof value !== 'string') return value ?? null;
+  try { return JSON.parse(value); } catch { return null; }
+}
+
+function iso(value: number | null | undefined): string | null {
+  if (value === null || value === undefined) return null;
+  const date = new Date(Number(value));
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function errorEnvelope(value: unknown): McpErrorEnvelope | undefined {
+  if (!value || typeof value !== 'object') return undefined;
+  const envelope = value as Partial<McpErrorEnvelope>;
+  return typeof envelope.code === 'string' && typeof envelope.message === 'string'
+    && typeof envelope.retryable === 'boolean' && typeof envelope.status === 'number'
+    ? envelope as McpErrorEnvelope : undefined;
+}
+
 export class McpOperations {
   constructor(readonly db: Knex) {}
 
@@ -33,8 +57,10 @@ export class McpOperations {
     const identity = { owner_id: principal.user.id, grant_id: principal.grant.id, idempotency_key: key };
     const payloadHash = digest(canonical({ tool, args }));
     const id = randomUUID();
+    const acceptedAt = Date.now();
     const inserted = await this.db('mcp_operations').insert({ ...identity, id, tool, repository: repository || null,
-      payload_hash: payloadHash, state: 'running', created_at: Date.now(), updated_at: Date.now() }).onConflict(['owner_id', 'grant_id', 'idempotency_key']).ignore().returning('id');
+      payload_hash: payloadHash, state: 'running', lifecycle: 'accepted', accepted_at: acceptedAt, artifacts: JSON.stringify({}),
+      created_at: acceptedAt, updated_at: acceptedAt }).onConflict(['owner_id', 'grant_id', 'idempotency_key']).ignore().returning('id');
     if (!inserted.length) {
       const previous = await this.db<Operation>('mcp_operations').where(identity).first();
       if (!previous || previous.payload_hash !== payloadHash) throw new McpError('IDEMPOTENCY_CONFLICT', 'This key was already used with different arguments.', 409);
@@ -45,12 +71,24 @@ export class McpOperations {
       const reported = (result.data as { state?: string })?.state;
       const state = reported === 'browser_required' ? reported : result.status === 202 && ['posted', 'queued', 'unknown', 'failed'].includes(reported || '') ? reported! : result.status === 202 ? 'accepted' : 'completed';
       await this.db('mcp_operations').where({ id }).update({ state, result: JSON.stringify(result.data), updated_at: Date.now() });
+      const lifecycle = lifecycleFromLegacy(state);
+      if (['completed', 'failed', 'cancelled'].includes(lifecycle)) {
+        const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error);
+        await this.finish(id, lifecycle as LifecycleOutcome, failure);
+      } else if (lifecycle === 'unknown') {
+        const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error);
+        await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'unknown'])
+          .update({ lifecycle: 'unknown', failure: failure ? JSON.stringify(failure) : null, updated_at: Date.now() });
+      }
     } catch (error) {
       // A transport failure can follow an external side effect. Never replay it
       // automatically or claim it was rolled back. The handle remains durable.
       const envelope = classifyError(error, { sideEffectsPossible: true });
-      await this.db('mcp_operations').where({ id }).update({ state: envelope.code === 'OUTCOME_UNKNOWN' ? 'unknown' : 'failed',
-        result: JSON.stringify({ error: envelope }), updated_at: Date.now() });
+      const state = envelope.code === 'OUTCOME_UNKNOWN' ? 'unknown' : 'failed';
+      await this.db('mcp_operations').where({ id }).update({ state, result: JSON.stringify({ error: envelope }), updated_at: Date.now() });
+      if (state === 'failed') await this.finish(id, 'failed', envelope);
+      else await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'unknown'])
+        .update({ lifecycle: 'unknown', failure: JSON.stringify(envelope), updated_at: Date.now() });
     }
     return this.project((await this.db<Operation>('mcp_operations').where({ id }).first())!);
   }
@@ -61,10 +99,48 @@ export class McpOperations {
     return row;
   }
 
+  async markStarted(id: string, at = Date.now()): Promise<void> {
+    await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'running', 'unknown']).update({
+      lifecycle: 'running',
+      started_at: this.db.raw('COALESCE(started_at, ?)', [at]),
+      updated_at: Date.now(),
+    });
+  }
+
+  async recordArtifacts(id: string, partial: Record<string, unknown>): Promise<void> {
+    if (!Object.keys(partial).length) return;
+    await this.db('mcp_operations').where({ id }).update({
+      artifacts: this.db.raw("json_patch(COALESCE(artifacts, '{}'), ?)", [JSON.stringify(partial)]),
+      updated_at: Date.now(),
+    });
+  }
+
+  async recordProgress(id: string, progress: unknown): Promise<void> {
+    await this.db('mcp_operations').where({ id }).update({ progress: JSON.stringify(progress), updated_at: Date.now() });
+  }
+
+  async finish(id: string, outcome: LifecycleOutcome, failure?: McpErrorEnvelope): Promise<void> {
+    const at = Date.now();
+    await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'running', 'unknown']).update({
+      lifecycle: outcome,
+      finished_at: at,
+      failure: failure ? JSON.stringify(failure) : null,
+      updated_at: at,
+    });
+  }
+
   project(row: Operation): Record<string, unknown> {
     const stale = row.state === 'running' && Date.now() - Number(row.updated_at) > 120_000;
     const state = stale ? 'unknown' : row.state;
-    return { operationId: row.id, tool: row.tool, state, result: row.result ? JSON.parse(row.result) : null,
+    return { operationId: row.id, tool: row.tool, state, result: json(row.result), lifecycle: {
+      state: row.lifecycle ?? lifecycleFromLegacy(row.state),
+      acceptedAt: iso(row.accepted_at ?? row.created_at),
+      startedAt: iso(row.started_at),
+      finishedAt: iso(row.finished_at),
+      failure: json(row.failure),
+      artifacts: json(row.artifacts) ?? {},
+      progress: json(row.progress),
+    },
       ...(['accepted', 'posted', 'queued', 'running'].includes(state) ? { retryAfterSeconds: 3 } : {}),
       ...(stale ? { message: 'Execution may have been interrupted. Inspect the target; this action will not be replayed automatically.' } : {}) };
   }
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index a8460c46f..b0404bbce 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -20,6 +20,7 @@ import { createAgentRuntimeRoutes } from '../routes/agentRuntimeRoutes.js';
 import { McpError, type McpScope } from './config.js';
 import { McpPolicy, type McpPrincipal } from './policy.js';
 import { McpOperations, type OperationResult, type Operation } from './operations.js';
+import { syncLifecycle } from './operationLifecycle.js';
 import { callWorkflow, type WorkflowHandler } from './adapter.js';
 import { addTaskSubmissionTools, trackTaskSubmission } from './toolsTaskSubmissions.js';
 import { addPlanningTools } from './toolsPlanning.js';
@@ -296,7 +297,7 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
   workflow(tools, { name: 'delete_task', description: 'Delete an exact inactive task and its persisted execution history. Active tasks must first be cancelled.', scope: 'execute', schema: z.object({ ...taskShape, ...mutationShape }).strict(), target: taskTarget }, tasks.deleteTask, args => ({ params: { taskId: args.taskId }, query: { force: 'false' } }));
 
   const operations = new McpOperations(db);
-  tools.push({ name: 'get_operation', description: 'Read a durable mutation receipt and honest acceptance/completion state. Poll no faster than retryAfterSeconds.', scope: 'read', readOnly: true, schema: z.object({ operationId: z.uuid() }).strict(), run: async ({ principal, args }) => {
+  tools.push({ name: 'get_operation', description: 'Read a durable mutation receipt and honest lifecycle. "accepted" means the request was recorded and handed to the backend; "running" means execution was observed; the loop/receipt is only "completed" when the backend reached a terminal success state. Poll no faster than retryAfterSeconds.', scope: 'read', readOnly: true, schema: z.object({ operationId: z.uuid() }).strict(), run: async ({ principal, args }) => {
     const row = await operations.get(principal, args.operationId);
     if (row.repository) await policy.repository(principal, row.repository, false, { includeDisabled: row.tool.endsWith('_repository_configuration'), allowUnconfigured: row.tool === 'remove_repository_configuration' });
     const original = tools.find(tool => tool.name === row.tool);
@@ -321,10 +322,33 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
       receipt.targetState = { issues };
       if (issues.length === result.issues.length && issues.every(issue => ['under_review', 'merged', 'closed'].includes(issue.status))) receipt.state = 'completed';
     }
+    await syncLifecycle(operations, row, receipt);
+    receipt.lifecycle = operations.project(await operations.get(principal, row.id)).lifecycle;
     if (['accepted', 'posted', 'queued', 'running'].includes(String(receipt.state))) receipt.retryAfterSeconds = 3;
     else delete receipt.retryAfterSeconds;
     return ok(receipt);
   } });
+  const operationLifecycleSchema = z.enum(['accepted', 'running', 'completed', 'failed', 'cancelled', 'unknown', 'active']);
+  tools.push({ name: 'list_operations', description: 'List durable mutation receipts newest first without refreshing backend trackers. "accepted" means the request was recorded and handed to the backend; "running" means execution was observed; the loop/receipt is only "completed" when the backend reached a terminal success state. Use refreshWith on an item when a live refresh is needed.', scope: 'read', readOnly: true,
+    schema: z.object({
+      tool: z.string().min(1).max(128).optional().describe('Exact tool name.'),
+      lifecycle: operationLifecycleSchema.optional(),
+      sinceMinutes: z.number().int().min(1).max(10080).default(1440),
+      repository: repositorySchema.optional(),
+      offset: z.number().int().min(0).max(100000).default(0),
+      limit: z.number().int().min(1).max(50).default(20),
+    }).strict(), run: async ({ principal, args }) => {
+      const query = db<Operation>('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
+        .whereRaw('COALESCE(accepted_at, created_at) >= ?', [Date.now() - args.sinceMinutes * 60_000]);
+      if (args.tool) query.where('tool', args.tool);
+      if (args.repository) query.where('repository', args.repository);
+      if (args.lifecycle === 'active') query.whereIn('lifecycle', ['accepted', 'running']);
+      else if (args.lifecycle) query.where('lifecycle', args.lifecycle);
+      const rows = await query.orderByRaw('COALESCE(accepted_at, created_at) DESC').orderBy('id', 'desc')
+        .offset(args.offset).limit(args.limit);
+      return ok({ operations: rows.map(row => ({ ...operations.project(row), refreshWith: 'get_operation' })),
+        nextOffset: rows.length === args.limit ? args.offset + args.limit : null });
+    } });
   tools.push({ name: 'cancel_operation', description: 'Request cancellation of an accepted plan generation, goal or task operation. Completed external effects cannot be undone.', scope: 'execute', schema: z.object({ ...mutationShape, operationId: z.uuid() }).strict(), run: async ({ principal, args }) => {
     const row = await operations.get(principal, args.operationId);
     if (row.repository) await policy.repository(principal, row.repository, true);
diff --git a/packages/api/test/mcpIntegration.test.ts b/packages/api/test/mcpIntegration.test.ts
index 4b98fc2cf..5db24855d 100644
--- a/packages/api/test/mcpIntegration.test.ts
+++ b/packages/api/test/mcpIntegration.test.ts
@@ -17,6 +17,7 @@ import { up as planIssues } from '../../core/src/db/migrations/20260120000000_ad
 import { up as planIssueTasks } from '../../core/src/db/migrations/20260121000000_add_task_id_to_plan_issues.js';
 import { up as taskPullRequests } from '../../core/src/db/migrations/20260216000000_add_pr_number_to_tasks.js';
 import { up as mcpMigration } from '../../core/src/db/migrations/20260910220000_add_mcp.js';
+import { up as operationLifecycleMigration } from '../../core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js';
 import { McpStore } from '../mcp/store.js';
 import { McpOAuthProvider } from '../mcp/oauth.js';
 import { McpError } from '../mcp/config.js';
@@ -29,7 +30,7 @@ after(async () => closeConnection());
 
 test('both official SDK protocol eras execute real draft/revision/publication/task transitions over the same HTTP endpoint', async () => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
-  await initial(db); await planIssues(db); await planIssueTasks(db); await taskPullRequests(db); await mcpMigration(db);
+  await initial(db); await planIssues(db); await planIssueTasks(db); await taskPullRequests(db); await mcpMigration(db); await operationLifecycleMigration(db);
   await db.schema.alterTable('task_drafts', table => table.boolean('paused').defaultTo(false));
   await db.schema.createTable('goals', table => {
     table.string('goal_id'); table.string('owner_id'); table.string('repository'); table.string('current_task_id');
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 112ce64a1..9602cb752 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -1,14 +1,20 @@
 import assert from 'node:assert/strict';
-import { test } from 'node:test';
+import { after, test } from 'node:test';
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import knex from 'knex';
+import { closeConnection } from '@propr/core';
 import { up } from '../../core/src/db/migrations/20260910220000_add_mcp.js';
+import { down as lifecycleDown, up as lifecycleUp } from '../../core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js';
 import { McpOperations } from '../mcp/operations.js';
 import { McpError } from '../mcp/config.js';
 import { callWorkflow } from '../mcp/adapter.js';
 import { parseClientMetadataDocument } from '../mcp/clients.js';
+import { createToolCatalog, type ToolDeps } from '../mcp/tools.js';
+import type { McpPrincipal } from '../mcp/policy.js';
+
+after(closeConnection);
 
 test('mutation deduplication survives concurrent callers and reopening the SQLite database', async () => {
   const root = await mkdtemp(path.join(tmpdir(), 'propr-mcp-'));
@@ -17,6 +23,7 @@ test('mutation deduplication survives concurrent callers and reopening the SQLit
   try {
     await db.schema.createTable('task_drafts', table => { table.string('draft_id').primary(); table.string('name'); });
     await up(db);
+    await lifecycleUp(db);
     const principal = { user: { id: '123' }, grant: { id: 'grant-1' } } as never;
     const args = { idempotencyKey: 'durable-key-1', value: 'payload' };
     let invoked = 0;
@@ -28,6 +35,9 @@ test('mutation deduplication survives concurrent callers and reopening the SQLit
     const restarted = new McpOperations(db);
     const result = await restarted.run(principal, { tool: 'fixture_action', args, repository: 'acme/repo' }, async () => { throw new Error('Must not replay'); });
     assert.equal(result.state, 'completed'); assert.deepEqual(result.result, { changed: true });
+    assert.equal((result.lifecycle as { state: string }).state, 'completed');
+    assert.match((result.lifecycle as { acceptedAt: string }).acceptedAt, /^\d{4}-\d\d-\d\dT/);
+    assert.ok((result.lifecycle as { finishedAt: string }).finishedAt);
     await assert.rejects(restarted.run(principal, { tool: 'fixture_action', args: { ...args, value: 'changed' }, repository: 'acme/repo' }, async () => ({ status: 200, data: {} })), /different arguments/);
     await assert.rejects(restarted.get({ user: { id: '999' }, grant: { id: 'grant-1' } } as never, String(result.operationId)), /not found/);
     const uncertain = await restarted.run(principal, { tool: 'external_action', args: { idempotencyKey: 'uncertain-key-1' }, repository: 'acme/repo' }, async () => { throw new Error('Network disconnected after possible side effect'); });
@@ -46,6 +56,7 @@ test('mutation deduplication survives concurrent callers and reopening the SQLit
     } });
     const rejected = await restarted.run(principal, { tool: 'guarded_action', args: { idempotencyKey: 'rejected-key-1' }, repository: 'acme/repo' }, async () => { throw new McpError('STALE_HEAD', 'Head changed', 409); });
     assert.equal(rejected.state, 'failed');
+    assert.deepEqual((rejected.lifecycle as { failure: unknown }).failure, rejected.result && (rejected.result as { error: unknown }).error);
     const workflowFailure = await restarted.run(principal, { tool: 'workflow_action', args: { idempotencyKey: 'workflow-failure-1' }, repository: 'acme/repo' }, async () =>
       callWorkflow(async (_req, res) => { res.status(500).json({ error: 'The workflow may have changed the target.' }); }, principal, {}));
     assert.equal(workflowFailure.state, 'unknown');
@@ -60,6 +71,90 @@ test('mutation deduplication survives concurrent callers and reopening the SQLit
   } finally { await db.destroy(); await rm(root, { recursive: true, force: true }); }
 });
 
+test('operation lifecycle transitions, artifacts and progress are durable and monotonic', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as never;
+  const receipt = await operations.run(principal, {
+    tool: 'run_ultrafix', args: { idempotencyKey: 'lifecycle-key-1' }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued', pullRequest: 42, commentId: 99 } }));
+  assert.equal((receipt.lifecycle as { state: string }).state, 'accepted');
+  assert.equal((receipt.lifecycle as { startedAt: unknown }).startedAt, null);
+
+  const id = String(receipt.operationId);
+  await operations.markStarted(id, 1_800_000_000_000);
+  await Promise.all([
+    operations.recordArtifacts(id, { taskId: 'task-1' }),
+    operations.recordArtifacts(id, { pullRequest: { repository: 'acme/repo', number: 42, url: 'https://github.com/acme/repo/pull/42' } }),
+  ]);
+  await operations.recordProgress(id, { taskId: 'task-1', state: 'processing' });
+  await Promise.all([operations.finish(id, 'completed'), operations.markStarted(id, 1_700_000_000_000)]);
+  await operations.finish(id, 'failed', { code: 'LATE_FAILURE', message: 'stale', stage: null, retryable: false, status: 500 });
+
+  const projected = operations.project(await operations.get(principal, id));
+  assert.equal((projected.lifecycle as { state: string }).state, 'completed');
+  assert.equal((projected.lifecycle as { startedAt: string }).startedAt, '2027-01-15T08:00:00.000Z');
+  assert.ok((projected.lifecycle as { finishedAt: string }).finishedAt);
+  assert.deepEqual((projected.lifecycle as { artifacts: unknown }).artifacts, {
+    taskId: 'task-1', pullRequest: { repository: 'acme/repo', number: 42, url: 'https://github.com/acme/repo/pull/42' },
+  });
+  assert.deepEqual((projected.lifecycle as { progress: unknown }).progress, { taskId: 'task-1', state: 'processing' });
+  assert.equal((projected.lifecycle as { failure: unknown }).failure, null);
+});
+
+test('list_operations filters active receipts by exact owner and grant without refreshing trackers', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const otherGrant = { user: { id: 'alice' }, grant: { id: 'grant-b' } } as McpPrincipal;
+  const accepted = async (actor: McpPrincipal, tool: string, key: string) => operations.run(actor, {
+    tool, args: { idempotencyKey: key }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued' } }));
+  await accepted(principal, 'run_ultrafix', 'active-ultrafix-1');
+  await accepted(principal, 'review_pull_request', 'active-review-0001');
+  await accepted(otherGrant, 'review_pull_request', 'other-grant-run1');
+  await operations.run(principal, { tool: 'run_ultrafix', args: { idempotencyKey: 'done-ultrafix-01' }, repository: 'acme/repo' },
+    async () => ({ status: 200, data: { changed: true } }));
+
+  const deps = { db, policy: {} as never, taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const tool = createToolCatalog(deps).find(candidate => candidate.name === 'list_operations')!;
+  const args = tool.schema.parse({ tool: 'run_ultrafix', lifecycle: 'active' });
+  const result = (await tool.run({ principal, args })).data as { operations: Array<Record<string, unknown>>; nextOffset: number | null };
+  assert.equal(result.operations.length, 1);
+  assert.equal(result.operations[0].tool, 'run_ultrafix');
+  assert.equal((result.operations[0].lifecycle as { state: string }).state, 'accepted');
+  assert.equal(result.operations[0].refreshWith, 'get_operation');
+  const hidden = (await tool.run({ principal: otherGrant, args: tool.schema.parse({ tool: 'run_ultrafix', lifecycle: 'active' }) })).data as { operations: unknown[] };
+  assert.deepEqual(hidden.operations, []);
+});
+
+test('operation lifecycle migration backfills and rolls back on SQLite', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db);
+  await db('mcp_operations').insert([
+    { id: 'completed', owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'completed-key', tool: 'fixture', payload_hash: 'a', state: 'completed', result: '{}', created_at: 10, updated_at: 20 },
+    { id: 'failed', owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'failed-key-01', tool: 'fixture', payload_hash: 'b', state: 'failed', result: JSON.stringify({ error: { code: 'BROKEN' } }), created_at: 30, updated_at: 40 },
+    { id: 'queued', owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'queued-key-01', tool: 'fixture', payload_hash: 'c', state: 'queued', result: '{}', created_at: 50, updated_at: 60 },
+  ]);
+  await lifecycleUp(db);
+  const rows = await db('mcp_operations').orderBy('created_at');
+  assert.deepEqual(rows.map(row => [row.lifecycle, row.accepted_at, row.finished_at]), [
+    ['completed', 10, 20], ['failed', 30, 40], ['accepted', 50, null],
+  ]);
+  assert.deepEqual(JSON.parse(rows[1].failure), { code: 'BROKEN' });
+  await lifecycleDown(db);
+  assert.equal(await db.schema.hasColumn('mcp_operations', 'lifecycle'), false);
+  assert.equal(await db.schema.hasColumn('mcp_operations', 'accepted_at'), false);
+});
+
 test('CIMD intersects plural supported methods with public PKCE instead of trusting a legacy preference', () => {
   const id = 'https://client.example/oauth/client.json';
   const document = { client_id: id, client_name: 'Test', redirect_uris: ['https://client.example/callback'], token_endpoint_auth_methods_supported: ['none', 'private_key_jwt'], token_endpoint_auth_method: 'private_key_jwt' };
diff --git a/packages/api/test/mcpTaskSubmissions.test.ts b/packages/api/test/mcpTaskSubmissions.test.ts
index f4a1ef3c1..bd5783ca7 100644
--- a/packages/api/test/mcpTaskSubmissions.test.ts
+++ b/packages/api/test/mcpTaskSubmissions.test.ts
@@ -5,6 +5,7 @@ import knex from 'knex';
 import { z } from 'zod';
 import { associateSubmissionTask, closeConnection } from '@propr/core';
 import { up as mcpMigration } from '../../core/src/db/migrations/20260910220000_add_mcp.js';
+import { up as operationLifecycleMigration } from '../../core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js';
 import { up as submissionMigration } from '../../core/src/db/migrations/20260922000000_add_task_submissions.js';
 import { up as identityMigration } from '../../core/src/db/migrations/20260922010000_preserve_task_submission_identity.js';
 import { createToolCatalog, executeTool, type ToolDeps } from '../mcp/tools.js';
@@ -27,12 +28,17 @@ interface Receipt {
   state: string;
   result: SubmissionData;
   retryAfterSeconds?: number;
+  lifecycle: {
+    state: string; acceptedAt: string; startedAt: string | null; finishedAt: string | null;
+    failure: unknown; artifacts: Record<string, unknown>; progress: unknown;
+  };
 }
 
 async function fixture() {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   await db.schema.createTable('task_drafts', table => { table.string('draft_id').primary(); });
   await mcpMigration(db);
+  await operationLifecycleMigration(db);
   await submissionMigration(db);
   await identityMigration(db);
   await db.schema.createTable('tasks', table => {
@@ -90,6 +96,8 @@ test('MCP launches ordinary issue work once and follows delayed task association
     const first = await f.call('create_task', args);
     const receipt = first.data as Receipt;
     assert.equal(receipt.state, 'queued');
+    assert.equal(receipt.lifecycle.state, 'accepted');
+    assert.ok(receipt.lifecycle.acceptedAt);
     assert.equal(receipt.result.taskId, null);
     assert.equal(receipt.result.issueUrl, 'https://github.com/owner/repo/issues/42');
     assert.deepEqual((await f.call('create_task', args)).data, first.data);
@@ -111,16 +119,26 @@ test('MCP launches ordinary issue work once and follows delayed task association
     await f.db('tasks').insert({ task_id: 'ordinary-task', repository: 'owner/repo', task_type: 'issue' });
     await f.db('task_submissions').update({ task_id: 'ordinary-task' });
     await f.db('task_history').insert({ task_id: 'ordinary-task', state: 'processing' });
-    assert.equal((await poll()).state, 'running');
+    const running = await poll();
+    assert.equal(running.state, 'running');
+    assert.equal(running.lifecycle.state, 'running');
+    assert.ok(running.lifecycle.startedAt);
     const status = await f.call('get_task_submission', { repository: 'owner/repo', submissionId: stored.id });
     assert.equal((status.data as SubmissionData).taskId, 'ordinary-task');
     assert.equal(status.links.ui, 'https://instance.example/tasks/ordinary-task');
     await f.db('task_history').insert({ task_id: 'ordinary-task', state: 'completed' });
-    const completed = await poll();
+    const [completed, concurrent] = await Promise.all([poll(), poll()]);
     assert.equal(completed.state, 'completed');
+    assert.equal(completed.lifecycle.state, 'completed');
+    assert.equal(concurrent.lifecycle.state, 'completed');
+    assert.ok(completed.lifecycle.finishedAt);
+    assert.equal(completed.lifecycle.artifacts.taskId, 'ordinary-task');
     assert.equal(completed.result.continuation.taskId, 'ordinary-task');
     assert.equal(completed.retryAfterSeconds, undefined);
-    assert.equal((await poll()).state, 'completed');
+    await f.db('task_history').where({ task_id: 'ordinary-task' }).delete();
+    const durable = await poll();
+    assert.equal(durable.lifecycle.state, 'completed');
+    assert.equal(durable.lifecycle.artifacts.taskId, 'ordinary-task');
   } finally { await f.db.destroy(); }
 });
 
diff --git a/packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js b/packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js
new file mode 100644
index 000000000..5999cb927
--- /dev/null
+++ b/packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js
@@ -0,0 +1,33 @@
+export async function up(knex) {
+  await knex.schema.alterTable('mcp_operations', table => {
+    table.string('lifecycle', 16).notNullable().defaultTo('accepted');
+    table.bigInteger('accepted_at').nullable();
+    table.bigInteger('started_at').nullable();
+    table.bigInteger('finished_at').nullable();
+    table.json('failure').nullable();
+    table.json('artifacts').notNullable().defaultTo('{}');
+    table.json('progress').nullable();
+    table.index(['owner_id', 'grant_id', 'accepted_at'], 'mcp_operations_owner_grant_accepted_idx');
+  });
+
+  await knex.raw(`UPDATE mcp_operations SET
+    lifecycle = CASE
+      WHEN state IN ('running', 'accepted', 'posted', 'queued', 'browser_required') THEN 'accepted'
+      WHEN state IN ('completed', 'failed', 'cancelled') THEN state
+      ELSE 'unknown'
+    END,
+    accepted_at = created_at,
+    finished_at = CASE WHEN state IN ('completed', 'failed', 'cancelled') THEN updated_at ELSE NULL END,
+    failure = CASE
+      WHEN result IS NOT NULL AND json_valid(result) THEN json_extract(result, '$.error')
+      ELSE NULL
+    END,
+    artifacts = '{}'`);
+}
+
+export async function down(knex) {
+  await knex.schema.alterTable('mcp_operations', table => {
+    table.dropIndex([], 'mcp_operations_owner_grant_accepted_idx');
+    table.dropColumns('lifecycle', 'accepted_at', 'started_at', 'finished_at', 'failure', 'artifacts', 'progress');
+  });
+}

From f97faa818f6d3b977ca120f2f207cb595972e2e1 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 01:15:43 +0000
Subject: [PATCH 02/19] feat(ai): Fixed the `Validate Changes` CI failure.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixed the `Validate Changes` CI failure.

- Refactored lifecycle outcome/cancellation logic in [operationLifecycle.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T01-11-33/packages/api/mcp/operationLifecycle.ts).
- Extracted operation-state resolution in [operations.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T01-11-33/packages/api/mcp/operations.ts).
- Preserved existing behavior while bringing both functions below ESLint’s complexity limit.

Validation passed:

- API strict lint (`--max-warnings 0`)
- API typecheck
- Focused operation tests: 6/6
- Full MCP suite: 114/114
- `git diff --check`

No visual preview was created because this is an internal API refactor with no user-visible changes.

PR: #2613
Comment by: @propr-dev[bot] (ID: 5881718524)
Comment by: @github-actions[bot] (ID: 5881718710)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts | 33 +++++++++++++++++++-------
 packages/api/mcp/operations.ts         | 10 ++++++--
 2 files changed, 32 insertions(+), 11 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index 9e06f17e1..ea7e92de6 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -84,6 +84,28 @@ export function artifactsFromReceipt(row: Operation, receipt: Record<string, unk
   return artifacts;
 }
 
+function lifecycleOutcome(
+  row: Operation,
+  target: Record<string, unknown> | undefined,
+  receiptState: string,
+  targetState: string,
+): LifecycleOutcome | undefined {
+  if (terminalStates.has(receiptState as LifecycleOutcome)) return receiptState as LifecycleOutcome;
+  if (row.tool === 'run_ultrafix' || (!target?.taskId && !target?.task_id)) return undefined;
+  return terminalStates.has(targetState as LifecycleOutcome) ? targetState as LifecycleOutcome : undefined;
+}
+
+async function syncCancellation(
+  operations: McpOperations,
+  row: Operation,
+  receipt: Record<string, unknown>,
+): Promise<void> {
+  if (row.tool !== 'cancel_operation') return;
+  const result = record(receipt.result);
+  const sourceId = nonEmptyString(result?.operationId);
+  if (sourceId && result?.cancellation === 'confirmed') await operations.finish(sourceId, 'cancelled');
+}
+
 /** Persist tracker observations without allowing stale concurrent polls to undo newer lifecycle facts. */
 export async function syncLifecycle(
   operations: McpOperations,
@@ -102,18 +124,11 @@ export async function syncLifecycle(
     await operations.markStarted(row.id, epochMilliseconds(target?.timestamp));
   }
 
-  const outcome = terminalStates.has(receiptState as LifecycleOutcome)
-    ? receiptState as LifecycleOutcome
-    : row.tool !== 'run_ultrafix' && (target?.taskId || target?.task_id) && terminalStates.has(targetState as LifecycleOutcome)
-      ? targetState as LifecycleOutcome : undefined;
+  const outcome = lifecycleOutcome(row, target, receiptState, targetState);
   if (outcome) {
     const result = record(receipt.result);
     await operations.finish(row.id, outcome, record(result?.error) as McpErrorEnvelope | undefined);
   }
 
-  if (row.tool === 'cancel_operation') {
-    const result = record(receipt.result);
-    const sourceId = nonEmptyString(result?.operationId);
-    if (sourceId && result?.cancellation === 'confirmed') await operations.finish(sourceId, 'cancelled');
-  }
+  await syncCancellation(operations, row, receipt);
 }
diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index b37283909..a7e9db4e8 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -41,6 +41,13 @@ function errorEnvelope(value: unknown): McpErrorEnvelope | undefined {
     ? envelope as McpErrorEnvelope : undefined;
 }
 
+function operationState(result: OperationResult): string {
+  const reported = (result.data as { state?: string })?.state;
+  if (reported === 'browser_required') return reported;
+  if (result.status !== 202) return 'completed';
+  return ['posted', 'queued', 'unknown', 'failed'].includes(reported || '') ? reported! : 'accepted';
+}
+
 export class McpOperations {
   constructor(readonly db: Knex) {}
 
@@ -68,8 +75,7 @@ export class McpOperations {
     }
     try {
       const result = await invoke(id);
-      const reported = (result.data as { state?: string })?.state;
-      const state = reported === 'browser_required' ? reported : result.status === 202 && ['posted', 'queued', 'unknown', 'failed'].includes(reported || '') ? reported! : result.status === 202 ? 'accepted' : 'completed';
+      const state = operationState(result);
       await this.db('mcp_operations').where({ id }).update({ state, result: JSON.stringify(result.data), updated_at: Date.now() });
       const lifecycle = lifecycleFromLegacy(state);
       if (['completed', 'failed', 'cancelled'].includes(lifecycle)) {

From db338430f1e73962f5c51258d7690b4ba92bc1b4 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 01:40:05 +0000
Subject: [PATCH 03/19] =?UTF-8?q?feat(ai):=20Implemented=20F1=E2=80=93F5?=
 =?UTF-8?q?=20only.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implemented F1–F5 only.

- `list_operations` now revalidates repository, tool permission, and cancellation-source authorization before pagination.
- Initial receipts remain `accepted` until backend execution is observed.
- Initial mutation artifacts are persisted before returning and survive replay.
- Tracker task/review failures populate durable error envelopes.
- Tracker `unknown` states persist, preserve timestamps and terminal outcomes, and can resolve from later evidence.
- Added focused authorization, pagination, concurrency, artifact, failure, and uncertainty regressions.

Validation:

- API typecheck passed.
- Focused operation tests: 10/10 passed.
- Full MCP suite: 118/118 passed.
- `git diff --check` passed.
- No visual preview needed.
- Independent discoveries: none.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts  |  46 ++++++-
 packages/api/mcp/operations.ts          |  32 ++++-
 packages/api/mcp/tools.ts               |  78 +++++++++--
 packages/api/test/mcpOperations.test.ts | 170 +++++++++++++++++++++++-
 4 files changed, 298 insertions(+), 28 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index ea7e92de6..402b62a03 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -1,4 +1,4 @@
-import type { McpErrorEnvelope } from './errorEnvelope.js';
+import { redactSecrets, type McpErrorEnvelope } from './errorEnvelope.js';
 import type { McpOperations, LifecycleOutcome, LifecycleState, Operation } from './operations.js';
 
 const startedTaskStates = new Set(['processing', 'claude_execution', 'post_processing']);
@@ -35,7 +35,7 @@ export function lifecycleFromLegacy(state: unknown): LifecycleState {
 }
 
 /** Collect stable output handles regardless of which legacy receipt layer exposed them. */
-export function artifactsFromReceipt(row: Operation, receipt: Record<string, unknown>): Record<string, unknown> {
+export function artifactsFromReceipt(row: Pick<Operation, 'repository'>, receipt: Record<string, unknown>): Record<string, unknown> {
   const result = record(receipt.result) ?? {};
   const continuation = record(result.continuation) ?? {};
   const target = record(receipt.targetState) ?? {};
@@ -84,6 +84,34 @@ export function artifactsFromReceipt(row: Operation, receipt: Record<string, unk
   return artifacts;
 }
 
+function publicFailure(code: string, message: string, details?: Record<string, unknown>): McpErrorEnvelope {
+  return { code, message: redactSecrets(message), stage: 'internal', retryable: false, status: 500, ...(details ? { details } : {}) };
+}
+
+/** Normalize durable backend failure evidence into the public error envelope. */
+export function failureFromReceipt(receipt: Record<string, unknown>): McpErrorEnvelope | undefined {
+  const result = record(receipt.result);
+  const resultError = record(result?.error);
+  if (resultError && typeof resultError.code === 'string' && typeof resultError.message === 'string'
+    && typeof resultError.retryable === 'boolean' && typeof resultError.status === 'number') {
+    return resultError as unknown as McpErrorEnvelope;
+  }
+
+  const target = record(receipt.targetState);
+  const reviewResults = Array.isArray(target?.reviewResults) ? target.reviewResults
+    : Array.isArray(result?.reviewResults) ? result.reviewResults : [];
+  const failedReviews = reviewResults.map(record).filter((review): review is Record<string, unknown> => review?.success === false);
+  if (failedReviews.length && failedReviews.length === reviewResults.length) {
+    const reasons = failedReviews.flatMap(review => typeof review.error === 'string' && review.error.length ? [review.error] : []);
+    return publicFailure('REVIEW_FAILED', reasons.length ? reasons.join('; ') : 'Every requested review failed.', {
+      failedReviewCount: failedReviews.length,
+    });
+  }
+
+  const reason = nonEmptyString(target?.reason, result?.reason);
+  return reason ? publicFailure('EXECUTION_FAILED', reason) : undefined;
+}
+
 function lifecycleOutcome(
   row: Operation,
   target: Record<string, unknown> | undefined,
@@ -120,14 +148,22 @@ export async function syncLifecycle(
 
   const targetState = String(target?.state ?? '');
   const receiptState = String(receipt.state ?? '');
-  if (startedTaskStates.has(targetState) || receiptState === 'running') {
+  const result = record(receipt.result);
+  const loop = record(result?.loop);
+  const observedStart = startedTaskStates.has(targetState) || target?.queueState === 'active' || loop?.active === true;
+  if (observedStart) {
     await operations.markStarted(row.id, epochMilliseconds(target?.timestamp));
   }
 
   const outcome = lifecycleOutcome(row, target, receiptState, targetState);
   if (outcome) {
-    const result = record(receipt.result);
-    await operations.finish(row.id, outcome, record(result?.error) as McpErrorEnvelope | undefined);
+    await operations.finish(row.id, outcome, outcome === 'failed' ? failureFromReceipt(receipt) : undefined);
+  } else if (receiptState === 'unknown') {
+    await operations.markUnknown(row.id);
+  } else if (receiptState === 'queued' && target) {
+    // A task or queue can appear after an earlier timeout. Resolve pre-start
+    // uncertainty without erasing evidence that execution had already begun.
+    await operations.markAccepted(row.id);
   }
 
   await syncCancellation(operations, row, receipt);
diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index a7e9db4e8..6872119a2 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -4,7 +4,7 @@ import { McpError } from './config.js';
 import { classifyError, type McpErrorEnvelope } from './errorEnvelope.js';
 import { digest } from './store.js';
 import type { McpPrincipal } from './policy.js';
-import { lifecycleFromLegacy } from './operationLifecycle.js';
+import { artifactsFromReceipt, failureFromReceipt, lifecycleFromLegacy } from './operationLifecycle.js';
 
 export interface OperationResult { status: number; data: unknown }
 export type LifecycleState = 'accepted' | 'running' | 'completed' | 'failed' | 'cancelled' | 'unknown';
@@ -66,7 +66,7 @@ export class McpOperations {
     const id = randomUUID();
     const acceptedAt = Date.now();
     const inserted = await this.db('mcp_operations').insert({ ...identity, id, tool, repository: repository || null,
-      payload_hash: payloadHash, state: 'running', lifecycle: 'accepted', accepted_at: acceptedAt, artifacts: JSON.stringify({}),
+      payload_hash: payloadHash, state: 'accepted', lifecycle: 'accepted', accepted_at: acceptedAt, artifacts: JSON.stringify({}),
       created_at: acceptedAt, updated_at: acceptedAt }).onConflict(['owner_id', 'grant_id', 'idempotency_key']).ignore().returning('id');
     if (!inserted.length) {
       const previous = await this.db<Operation>('mcp_operations').where(identity).first();
@@ -77,9 +77,11 @@ export class McpOperations {
       const result = await invoke(id);
       const state = operationState(result);
       await this.db('mcp_operations').where({ id }).update({ state, result: JSON.stringify(result.data), updated_at: Date.now() });
+      const receipt = { state, result: result.data };
+      await this.recordArtifacts(id, artifactsFromReceipt({ repository: repository || null }, receipt));
       const lifecycle = lifecycleFromLegacy(state);
       if (['completed', 'failed', 'cancelled'].includes(lifecycle)) {
-        const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error);
+        const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error) ?? failureFromReceipt(receipt);
         await this.finish(id, lifecycle as LifecycleOutcome, failure);
       } else if (lifecycle === 'unknown') {
         const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error);
@@ -113,6 +115,20 @@ export class McpOperations {
     });
   }
 
+  async markUnknown(id: string): Promise<void> {
+    await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'running', 'unknown']).update({
+      lifecycle: 'unknown',
+      updated_at: Date.now(),
+    });
+  }
+
+  async markAccepted(id: string): Promise<void> {
+    await this.db('mcp_operations').where({ id, lifecycle: 'unknown' }).whereNull('started_at').update({
+      lifecycle: 'accepted',
+      updated_at: Date.now(),
+    });
+  }
+
   async recordArtifacts(id: string, partial: Record<string, unknown>): Promise<void> {
     if (!Object.keys(partial).length) return;
     await this.db('mcp_operations').where({ id }).update({
@@ -127,10 +143,14 @@ export class McpOperations {
 
   async finish(id: string, outcome: LifecycleOutcome, failure?: McpErrorEnvelope): Promise<void> {
     const at = Date.now();
-    await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'running', 'unknown']).update({
+    const eligible = this.db('mcp_operations').where({ id }).andWhere(builder => {
+      builder.whereIn('lifecycle', ['accepted', 'running', 'unknown']);
+      if (outcome === 'failed' && failure) builder.orWhere(nested => nested.where({ lifecycle: 'failed' }).whereNull('failure'));
+    });
+    await eligible.update({
       lifecycle: outcome,
-      finished_at: at,
-      failure: failure ? JSON.stringify(failure) : null,
+      finished_at: this.db.raw('COALESCE(finished_at, ?)', [at]),
+      failure: failure ? this.db.raw('COALESCE(failure, ?)', [JSON.stringify(failure)]) : null,
       updated_at: at,
     });
   }
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index b0404bbce..502ac127a 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -297,19 +297,47 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
   workflow(tools, { name: 'delete_task', description: 'Delete an exact inactive task and its persisted execution history. Active tasks must first be cancelled.', scope: 'execute', schema: z.object({ ...taskShape, ...mutationShape }).strict(), target: taskTarget }, tasks.deleteTask, args => ({ params: { taskId: args.taskId }, query: { force: 'false' } }));
 
   const operations = new McpOperations(db);
-  tools.push({ name: 'get_operation', description: 'Read a durable mutation receipt and honest lifecycle. "accepted" means the request was recorded and handed to the backend; "running" means execution was observed; the loop/receipt is only "completed" when the backend reached a terminal success state. Poll no faster than retryAfterSeconds.', scope: 'read', readOnly: true, schema: z.object({ operationId: z.uuid() }).strict(), run: async ({ principal, args }) => {
-    const row = await operations.get(principal, args.operationId);
-    if (row.repository) await policy.repository(principal, row.repository, false, { includeDisabled: row.tool.endsWith('_repository_configuration'), allowUnconfigured: row.tool === 'remove_repository_configuration' });
+  const operationResult = (row: Operation): Record<string, unknown> => {
+    if (!row.result) return {};
+    try { return JSON.parse(row.result); } catch { return {}; }
+  };
+  const authorizeStoredTool = async (
+    row: Operation,
+    principal: McpPrincipal,
+    repositories?: Map<string, Promise<void>>,
+  ): Promise<void> => {
+    if (row.repository) {
+      const options = { includeDisabled: row.tool.endsWith('_repository_configuration'), allowUnconfigured: row.tool === 'remove_repository_configuration' };
+      const key = `${row.repository}\0${Number(options.includeDisabled)}${Number(options.allowUnconfigured)}`;
+      let authorization = repositories?.get(key);
+      if (!authorization) {
+        authorization = policy.repository(principal, row.repository, false, options);
+        repositories?.set(key, authorization);
+      }
+      await authorization;
+    }
     const original = tools.find(tool => tool.name === row.tool);
     if (original?.permission) policy.requirePermission(principal, original.permission);
-    if (row.tool === 'cancel_operation' && row.result && JSON.parse(row.result).operationId) {
-      const source = await operations.get(principal, JSON.parse(row.result).operationId);
-      if (source.repository) await policy.repository(principal, source.repository);
-      row.repository = source.repository;
-    }
+  };
+  const authorizeOperation = async (
+    row: Operation,
+    principal: McpPrincipal,
+    repositories?: Map<string, Promise<void>>,
+  ): Promise<void> => {
+    await authorizeStoredTool(row, principal, repositories);
+    const sourceId = row.tool === 'cancel_operation' ? operationResult(row).operationId : undefined;
+    if (typeof sourceId !== 'string') return;
+    const source = await operations.get(principal, sourceId);
+    await authorizeStoredTool(source, principal, repositories);
+    row.repository = source.repository;
+  };
+  tools.push({ name: 'get_operation', description: 'Read a durable mutation receipt and honest lifecycle. "accepted" means the request was recorded and handed to the backend; "running" means execution was observed; the loop/receipt is only "completed" when the backend reached a terminal success state. Poll no faster than retryAfterSeconds.', scope: 'read', readOnly: true, schema: z.object({ operationId: z.uuid() }).strict(), run: async ({ principal, args }) => {
+    const row = await operations.get(principal, args.operationId);
+    await authorizeOperation(row, principal);
     const receipt = operations.project(row);
-    const result = row.result ? JSON.parse(row.result) : {};
-    const continuation = result.continuation || result;
+    const result = operationResult(row);
+    const continuation = result.continuation && typeof result.continuation === 'object' && !Array.isArray(result.continuation)
+      ? result.continuation as Record<string, unknown> : result;
     if (continuation.planId) receipt.targetState = await db('task_drafts').where({ draft_id: continuation.planId, user_id: principal.user.id }).first('status', 'paused', 'mcp_revision');
     if (continuation.goalId) receipt.targetState = await db('goals').where({ goal_id: continuation.goalId, owner_id: principal.user.id }).first('desired_state', 'result_state', 'current_task_id');
     if (continuation.taskId) receipt.targetState = await db('task_history').where({ task_id: continuation.taskId }).orderBy('history_id', 'desc').first('state', 'timestamp');
@@ -344,10 +372,32 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
       if (args.repository) query.where('repository', args.repository);
       if (args.lifecycle === 'active') query.whereIn('lifecycle', ['accepted', 'running']);
       else if (args.lifecycle) query.where('lifecycle', args.lifecycle);
-      const rows = await query.orderByRaw('COALESCE(accepted_at, created_at) DESC').orderBy('id', 'desc')
-        .offset(args.offset).limit(args.limit);
-      return ok({ operations: rows.map(row => ({ ...operations.project(row), refreshWith: 'get_operation' })),
-        nextOffset: rows.length === args.limit ? args.offset + args.limit : null });
+      const ordered = query.orderByRaw('COALESCE(accepted_at, created_at) DESC').orderBy('id', 'desc');
+      const authorized: Operation[] = [];
+      const repositoryAuthorizations = new Map<string, Promise<void>>();
+      const wanted = args.offset + args.limit + 1;
+      const batchSize = Math.max(50, args.limit);
+      let databaseOffset = 0;
+      while (authorized.length < wanted) {
+        const rows = await ordered.clone().offset(databaseOffset).limit(batchSize);
+        if (!rows.length) break;
+        databaseOffset += rows.length;
+        for (const row of rows) {
+          try {
+            await authorizeOperation(row, principal, repositoryAuthorizations);
+            authorized.push(row);
+          } catch (error) {
+            // Discovery is a filtered view: current authorization failures do
+            // not reveal that a matching receipt exists.
+            if (!(error instanceof McpError) || ![403, 404].includes(error.status)) throw error;
+          }
+          if (authorized.length >= wanted) break;
+        }
+        if (rows.length < batchSize) break;
+      }
+      const page = authorized.slice(args.offset, args.offset + args.limit);
+      return ok({ operations: page.map(row => ({ ...operations.project(row), refreshWith: 'get_operation' })),
+        nextOffset: authorized.length > args.offset + args.limit ? args.offset + args.limit : null });
     } });
   tools.push({ name: 'cancel_operation', description: 'Request cancellation of an accepted plan generation, goal or task operation. Completed external effects cannot be undone.', scope: 'execute', schema: z.object({ ...mutationShape, operationId: z.uuid() }).strict(), run: async ({ principal, args }) => {
     const row = await operations.get(principal, args.operationId);
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 9602cb752..6abfd7050 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -7,12 +7,13 @@ import knex from 'knex';
 import { closeConnection } from '@propr/core';
 import { up } from '../../core/src/db/migrations/20260910220000_add_mcp.js';
 import { down as lifecycleDown, up as lifecycleUp } from '../../core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js';
-import { McpOperations } from '../mcp/operations.js';
+import { McpOperations, type Operation } from '../mcp/operations.js';
 import { McpError } from '../mcp/config.js';
 import { callWorkflow } from '../mcp/adapter.js';
 import { parseClientMetadataDocument } from '../mcp/clients.js';
 import { createToolCatalog, type ToolDeps } from '../mcp/tools.js';
 import type { McpPrincipal } from '../mcp/policy.js';
+import { syncLifecycle } from '../mcp/operationLifecycle.js';
 
 after(closeConnection);
 
@@ -83,6 +84,13 @@ test('operation lifecycle transitions, artifacts and progress are durable and mo
   }, async () => ({ status: 202, data: { state: 'queued', pullRequest: 42, commentId: 99 } }));
   assert.equal((receipt.lifecycle as { state: string }).state, 'accepted');
   assert.equal((receipt.lifecycle as { startedAt: unknown }).startedAt, null);
+  assert.deepEqual((receipt.lifecycle as { artifacts: unknown }).artifacts, {
+    pullRequest: { repository: 'acme/repo', number: 42, url: 'https://github.com/acme/repo/pull/42' }, commentId: 99,
+  });
+  const replay = await operations.run(principal, {
+    tool: 'run_ultrafix', args: { idempotencyKey: 'lifecycle-key-1' }, repository: 'acme/repo',
+  }, async () => { throw new Error('Must not invoke on replay'); });
+  assert.deepEqual((replay.lifecycle as { artifacts: unknown }).artifacts, (receipt.lifecycle as { artifacts: unknown }).artifacts);
 
   const id = String(receipt.operationId);
   await operations.markStarted(id, 1_800_000_000_000);
@@ -99,12 +107,117 @@ test('operation lifecycle transitions, artifacts and progress are durable and mo
   assert.equal((projected.lifecycle as { startedAt: string }).startedAt, '2027-01-15T08:00:00.000Z');
   assert.ok((projected.lifecycle as { finishedAt: string }).finishedAt);
   assert.deepEqual((projected.lifecycle as { artifacts: unknown }).artifacts, {
-    taskId: 'task-1', pullRequest: { repository: 'acme/repo', number: 42, url: 'https://github.com/acme/repo/pull/42' },
+    taskId: 'task-1', pullRequest: { repository: 'acme/repo', number: 42, url: 'https://github.com/acme/repo/pull/42' }, commentId: 99,
   });
   assert.deepEqual((projected.lifecycle as { progress: unknown }).progress, { taskId: 'task-1', state: 'processing' });
   assert.equal((projected.lifecycle as { failure: unknown }).failure, null);
 });
 
+test('polling an accepted wrapper does not fabricate backend execution start', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  let finishInvocation!: (result: { status: number; data: unknown }) => void;
+  let invocationStarted!: () => void;
+  const started = new Promise<void>(resolve => { invocationStarted = resolve; });
+  const pending = operations.run(principal, {
+    tool: 'review_pull_request', args: { idempotencyKey: 'pending-wrapper-1' }, repository: 'acme/repo',
+  }, async () => {
+    invocationStarted();
+    return new Promise(resolve => { finishInvocation = resolve; });
+  });
+  await started;
+
+  const row = await db('mcp_operations').first() as Operation;
+  const polled = operations.project(row);
+  assert.equal(polled.state, 'accepted');
+  await syncLifecycle(operations, row, polled);
+  const unchanged = operations.project(await operations.get(principal, row.id));
+  assert.equal((unchanged.lifecycle as { state: string }).state, 'accepted');
+  assert.equal((unchanged.lifecycle as { startedAt: unknown }).startedAt, null);
+
+  finishInvocation({ status: 202, data: { state: 'queued' } });
+  const queued = await pending;
+  assert.equal(queued.state, 'queued');
+  assert.equal((queued.lifecycle as { state: string }).state, 'accepted');
+  assert.equal((queued.lifecycle as { startedAt: unknown }).startedAt, null);
+});
+
+test('tracker uncertainty resolves from later evidence and preserves observed timestamps and terminal outcomes', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const receipt = await operations.run(principal, {
+    tool: 'send_task_followup', args: { idempotencyKey: 'tracker-unknown-1' }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued' } }));
+  const id = String(receipt.operationId);
+  const row = await operations.get(principal, id);
+
+  await syncLifecycle(operations, row, { ...receipt, state: 'unknown' });
+  assert.equal((operations.project(await operations.get(principal, id)).lifecycle as { state: string }).state, 'unknown');
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const list = createToolCatalog(deps).find(tool => tool.name === 'list_operations')!;
+  const unknown = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'unknown' }) })).data as { operations: unknown[] };
+  const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: unknown[] };
+  assert.equal(unknown.operations.length, 1);
+  assert.deepEqual(active.operations, []);
+  await syncLifecycle(operations, row, { ...receipt, state: 'queued', targetState: { taskId: 'task-1', state: 'pending' } });
+  assert.equal((operations.project(await operations.get(principal, id)).lifecycle as { state: string }).state, 'accepted');
+
+  const observedAt = 1_800_000_000_000;
+  await syncLifecycle(operations, row, { ...receipt, state: 'running', targetState: { taskId: 'task-1', state: 'processing', timestamp: observedAt } });
+  await syncLifecycle(operations, row, { ...receipt, state: 'unknown' });
+  let lifecycle = operations.project(await operations.get(principal, id)).lifecycle as { state: string; startedAt: string | null };
+  assert.equal(lifecycle.state, 'unknown');
+  assert.equal(lifecycle.startedAt, '2027-01-15T08:00:00.000Z');
+  await syncLifecycle(operations, row, { ...receipt, state: 'running', targetState: { taskId: 'task-1', state: 'processing' } });
+  lifecycle = operations.project(await operations.get(principal, id)).lifecycle as typeof lifecycle;
+  assert.equal(lifecycle.state, 'running');
+  assert.equal(lifecycle.startedAt, '2027-01-15T08:00:00.000Z');
+  await operations.finish(id, 'completed');
+  await syncLifecycle(operations, row, { ...receipt, state: 'unknown' });
+  assert.equal((operations.project(await operations.get(principal, id)).lifecycle as { state: string }).state, 'completed');
+});
+
+test('tracker task and review failures populate and can enrich the durable failure envelope', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const create = (tool: string, key: string) => operations.run(principal, {
+    tool, args: { idempotencyKey: key }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued' } }));
+
+  const task = await create('send_task_followup', 'tracker-failure-1');
+  const taskRow = await operations.get(principal, String(task.operationId));
+  await syncLifecycle(operations, taskRow, { ...task, state: 'failed', targetState: { taskId: 'task-1', state: 'failed' } });
+  assert.equal((operations.project(await operations.get(principal, taskRow.id)).lifecycle as { failure: unknown }).failure, null);
+  await syncLifecycle(operations, taskRow, { ...task, state: 'failed', targetState: { taskId: 'task-1', state: 'failed', reason: 'Agent stopped' } });
+  assert.deepEqual((operations.project(await operations.get(principal, taskRow.id)).lifecycle as { failure: unknown }).failure, {
+    code: 'EXECUTION_FAILED', message: 'Agent stopped', stage: 'internal', retryable: false, status: 500,
+  });
+
+  const review = await create('review_pull_request', 'review-failure-01');
+  const reviewRow = await operations.get(principal, String(review.operationId));
+  await syncLifecycle(operations, reviewRow, { ...review, state: 'failed', targetState: {
+    taskId: 'review-task', state: 'completed', reason: 'Review processing completed successfully',
+    reviewResults: [{ success: false, error: 'Reviewer unavailable' }, { success: false, error: 'Model timed out' }],
+  } });
+  assert.deepEqual((operations.project(await operations.get(principal, reviewRow.id)).lifecycle as { failure: unknown }).failure, {
+    code: 'REVIEW_FAILED', message: 'Reviewer unavailable; Model timed out', stage: 'internal', retryable: false, status: 500,
+    details: { failedReviewCount: 2 },
+  });
+});
+
 test('list_operations filters active receipts by exact owner and grant without refreshing trackers', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
@@ -122,7 +235,8 @@ test('list_operations filters active receipts by exact owner and grant without r
   await operations.run(principal, { tool: 'run_ultrafix', args: { idempotencyKey: 'done-ultrafix-01' }, repository: 'acme/repo' },
     async () => ({ status: 200, data: { changed: true } }));
 
-  const deps = { db, policy: {} as never, taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
   const tool = createToolCatalog(deps).find(candidate => candidate.name === 'list_operations')!;
   const args = tool.schema.parse({ tool: 'run_ultrafix', lifecycle: 'active' });
   const result = (await tool.run({ principal, args })).data as { operations: Array<Record<string, unknown>>; nextOffset: number | null };
@@ -134,6 +248,56 @@ test('list_operations filters active receipts by exact owner and grant without r
   assert.deepEqual(hidden.operations, []);
 });
 
+test('list_operations filters current repository, tool permission and cancellation-source authorization before paging', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' }, authorization: { permissions: [] } } as unknown as McpPrincipal;
+  const run = (tool: string, key: string, repository?: string, data: Record<string, unknown> = {}) => operations.run(principal, {
+    tool, args: { idempotencyKey: key }, repository,
+  }, async () => ({ status: 200, data }));
+  const forbiddenPermission = await run('update_execution_settings', 'permission-hidden-1', undefined, { secret: 'permission-secret' });
+  const forbiddenRepository = await run('run_ultrafix', 'repository-hidden1', 'acme/forbidden', { secret: 'repository-secret' });
+  const firstAllowed = await run('run_ultrafix', 'allowed-operation1', 'acme/allowed', { marker: 'first' });
+  const secondAllowed = await run('review_pull_request', 'allowed-operation2', 'acme/allowed', { marker: 'second' });
+  const source = await run('review_pull_request', 'cancel-source-key', 'acme/forbidden', { marker: 'source' });
+  const cancellation = await run('cancel_operation', 'cancel-receipt-01', undefined, { operationId: source.operationId, cancellation: 'requested' });
+  const now = Date.now();
+  for (const [receipt, acceptedAt] of [[forbiddenPermission, now], [forbiddenRepository, now - 1], [firstAllowed, now - 2], [secondAllowed, now - 3], [source, now - 4], [cancellation, now - 5]] as const) {
+    await db('mcp_operations').where({ id: receipt.operationId }).update({ accepted_at: acceptedAt, created_at: acceptedAt });
+  }
+
+  const policy = {
+    config: {},
+    repository: async (_actor: McpPrincipal, repository: string) => {
+      if (repository === 'acme/forbidden') throw new McpError('REPOSITORY_FORBIDDEN', 'No current access', 403);
+    },
+    requirePermission: (actor: McpPrincipal, permission: string) => {
+      if (!actor.authorization.permissions.includes(permission as never)) throw new McpError('INSUFFICIENT_INSTANCE_PERMISSION', 'Permission removed', 403);
+    },
+  };
+  const deps = { db, policy, taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as unknown as ToolDeps;
+  const catalog = createToolCatalog(deps);
+  const list = catalog.find(tool => tool.name === 'list_operations')!;
+  const get = catalog.find(tool => tool.name === 'get_operation')!;
+
+  const pageOne = (await list.run({ principal, args: list.schema.parse({ limit: 1 }) })).data as { operations: Array<Record<string, unknown>>; nextOffset: number | null };
+  assert.deepEqual(pageOne.operations.map(item => item.operationId), [firstAllowed.operationId]);
+  assert.equal(pageOne.nextOffset, 1);
+  assert.doesNotMatch(JSON.stringify(pageOne), /permission-secret|repository-secret/);
+  const pageTwo = (await list.run({ principal, args: list.schema.parse({ offset: 1, limit: 1 }) })).data as { operations: Array<Record<string, unknown>>; nextOffset: number | null };
+  assert.deepEqual(pageTwo.operations.map(item => item.operationId), [secondAllowed.operationId]);
+  assert.equal(pageTwo.nextOffset, null);
+  const cancellations = (await list.run({ principal, args: list.schema.parse({ tool: 'cancel_operation' }) })).data as { operations: unknown[] };
+  assert.deepEqual(cancellations.operations, []);
+
+  await assert.rejects(get.run({ principal, args: get.schema.parse({ operationId: forbiddenPermission.operationId }) }), /Permission removed/);
+  await assert.rejects(get.run({ principal, args: get.schema.parse({ operationId: forbiddenRepository.operationId }) }), /No current access/);
+  await assert.rejects(get.run({ principal, args: get.schema.parse({ operationId: cancellation.operationId }) }), /No current access/);
+});
+
 test('operation lifecycle migration backfills and rolls back on SQLite', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());

From e518a560a7f04c694347a28b63e72d455840cb30 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 01:44:16 +0000
Subject: [PATCH 04/19] feat(ai): Fixed the `Validate Changes` failure by
 adding the repository-standard documented `max-lines` exemption to the
 centralized MCP tool catalog in
 [tools.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T01-41-50/packages/api/mcp/tools.ts:1).

Fixed the `Validate Changes` failure by adding the repository-standard documented `max-lines` exemption to the centralized MCP tool catalog in [tools.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T01-41-50/packages/api/mcp/tools.ts:1).

Validation passed:

- API lint with `--max-warnings 0`
- API TypeScript build
- `git diff --check`

No visual preview was generated because this is a lint-only, non-visual change.

PR: #2613
Comment by: @propr-dev[bot] (ID: 5882022708)
Comment by: @github-actions[bot] (ID: 5882023203)
Model: gpt-5.6-sol
---
 packages/api/mcp/tools.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index 502ac127a..f485a5e9a 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -1,3 +1,4 @@
+/* eslint-disable max-lines -- MCP tool registration stays centralized so authorization and dispatch remain auditable */
 import { assertPlannerCancellationIdentity, cancellationTarget, cancellationOutcome, trackCancellation, trackExecution } from './operationTracking.js';
 import { z } from 'zod';
 import packageInfo from '../package.json' with { type: 'json' };

From 855dc778f89fc5692c2703f655b3be3528d13dd1 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 02:04:58 +0000
Subject: [PATCH 05/19] feat(ai): Implemented F6 only.

Implemented F6 only.

- Stale `accepted` receipts with no result now become durably `unknown` after 120 seconds using stable `accepted_at`.
- Replay, `get_operation`, projection, and `list_operations` consistently reflect interruption.
- Acknowledged queued operations remain active.
- Late authoritative invocation results resolve the timeout race correctly.
- Added focused regression coverage in [mcpOperations.test.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T01-58-26/packages/api/test/mcpOperations.test.ts:149).

Validation passed:

- Focused operation tests: 11/11
- Full MCP suite: 119/119
- API typecheck
- API lint
- `git diff --check`

No visual preview was created because this is backend-only. No independent issues discovered.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operations.ts          | 32 ++++++++++--
 packages/api/mcp/tools.ts               |  1 +
 packages/api/test/mcpOperations.test.ts | 65 +++++++++++++++++++++++++
 3 files changed, 95 insertions(+), 3 deletions(-)

diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index 6872119a2..fba616143 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -6,6 +6,8 @@ import { digest } from './store.js';
 import type { McpPrincipal } from './policy.js';
 import { artifactsFromReceipt, failureFromReceipt, lifecycleFromLegacy } from './operationLifecycle.js';
 
+const interruptionTimeoutMs = 120_000;
+
 export interface OperationResult { status: number; data: unknown }
 export type LifecycleState = 'accepted' | 'running' | 'completed' | 'failed' | 'cancelled' | 'unknown';
 export type LifecycleOutcome = 'completed' | 'failed' | 'cancelled';
@@ -48,13 +50,22 @@ function operationState(result: OperationResult): string {
   return ['posted', 'queued', 'unknown', 'failed'].includes(reported || '') ? reported! : 'accepted';
 }
 
+function invocationInterrupted(row: Operation, now = Date.now()): boolean {
+  const invokedAt = Number(row.accepted_at ?? row.created_at);
+  return row.state === 'accepted' && row.result === null && Number.isFinite(invokedAt)
+    && now - invokedAt > interruptionTimeoutMs;
+}
+
 export class McpOperations {
   constructor(readonly db: Knex) {}
 
   async replay(principal: McpPrincipal, tool: string, args: Record<string, unknown>): Promise<Record<string, unknown> | undefined> {
-    const previous = await this.db<Operation>('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id, idempotency_key: String(args.idempotencyKey) }).first();
+    const identity = { owner_id: principal.user.id, grant_id: principal.grant.id, idempotency_key: String(args.idempotencyKey) };
+    let previous = await this.db<Operation>('mcp_operations').where(identity).first();
     if (!previous) return undefined;
     if (previous.payload_hash !== digest(canonical({ tool, args }))) throw new McpError('IDEMPOTENCY_CONFLICT', 'This key was already used with different arguments.', 409);
+    await this.markInterruptedInvocations(principal, previous.id);
+    previous = (await this.db<Operation>('mcp_operations').where(identity).first())!;
     return this.project(previous);
   }
 
@@ -87,6 +98,10 @@ export class McpOperations {
         const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error);
         await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'unknown'])
           .update({ lifecycle: 'unknown', failure: failure ? JSON.stringify(failure) : null, updated_at: Date.now() });
+      } else if (lifecycle === 'accepted') {
+        // A live invocation result is authoritative if a concurrent poll had
+        // already classified its previously result-less receipt as interrupted.
+        await this.markAccepted(id);
       }
     } catch (error) {
       // A transport failure can follow an external side effect. Never replay it
@@ -102,11 +117,21 @@ export class McpOperations {
   }
 
   async get(principal: McpPrincipal, id: string): Promise<Operation> {
+    await this.markInterruptedInvocations(principal, id);
     const row = await this.db<Operation>('mcp_operations').where({ id, owner_id: principal.user.id, grant_id: principal.grant.id }).first();
     if (!row) throw new McpError('NOT_FOUND', 'Operation not found.', 404);
     return row;
   }
 
+  async markInterruptedInvocations(principal: McpPrincipal, id?: string): Promise<void> {
+    const now = Date.now();
+    const query = this.db('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id, state: 'accepted' })
+      .whereNull('result').whereIn('lifecycle', ['accepted', 'running', 'unknown'])
+      .whereRaw('COALESCE(accepted_at, created_at) < ?', [now - interruptionTimeoutMs]);
+    if (id) query.andWhere({ id });
+    await query.update({ state: 'unknown', lifecycle: 'unknown', updated_at: now });
+  }
+
   async markStarted(id: string, at = Date.now()): Promise<void> {
     await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'running', 'unknown']).update({
       lifecycle: 'running',
@@ -156,10 +181,11 @@ export class McpOperations {
   }
 
   project(row: Operation): Record<string, unknown> {
-    const stale = row.state === 'running' && Date.now() - Number(row.updated_at) > 120_000;
+    const interrupted = invocationInterrupted(row);
+    const stale = interrupted || (row.state === 'running' && Date.now() - Number(row.updated_at) > interruptionTimeoutMs);
     const state = stale ? 'unknown' : row.state;
     return { operationId: row.id, tool: row.tool, state, result: json(row.result), lifecycle: {
-      state: row.lifecycle ?? lifecycleFromLegacy(row.state),
+      state: interrupted ? 'unknown' : row.lifecycle ?? lifecycleFromLegacy(row.state),
       acceptedAt: iso(row.accepted_at ?? row.created_at),
       startedAt: iso(row.started_at),
       finishedAt: iso(row.finished_at),
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index f485a5e9a..3d08ad8bb 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -367,6 +367,7 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
       offset: z.number().int().min(0).max(100000).default(0),
       limit: z.number().int().min(1).max(50).default(20),
     }).strict(), run: async ({ principal, args }) => {
+      await operations.markInterruptedInvocations(principal);
       const query = db<Operation>('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
         .whereRaw('COALESCE(accepted_at, created_at) >= ?', [Date.now() - args.sinceMinutes * 60_000]);
       if (args.tool) query.where('tool', args.tool);
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 6abfd7050..b27c27e36 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -146,6 +146,71 @@ test('polling an accepted wrapper does not fabricate backend execution start', a
   assert.equal((queued.lifecycle as { startedAt: unknown }).startedAt, null);
 });
 
+test('interrupted accepted invocations become durable unknown while acknowledged queues remain active', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  let finishInvocation!: (result: { status: number; data: unknown }) => void;
+  let invocationStarted!: () => void;
+  const started = new Promise<void>(resolve => { invocationStarted = resolve; });
+  const args = { idempotencyKey: 'interrupted-wrapper-1' };
+  const pending = operations.run(principal, { tool: 'review_pull_request', args, repository: 'acme/repo' }, async () => {
+    invocationStarted();
+    return new Promise(resolve => { finishInvocation = resolve; });
+  });
+  await started;
+
+  const interrupted = await db<Operation>('mcp_operations').where({ idempotency_key: args.idempotencyKey }).first();
+  const invokedAt = Date.now() - 120_001;
+  await db('mcp_operations').where({ id: interrupted!.id }).update({ accepted_at: invokedAt, created_at: invokedAt, updated_at: Date.now() });
+  const projected = operations.project((await db<Operation>('mcp_operations').where({ id: interrupted!.id }).first())!);
+  assert.equal(projected.state, 'unknown');
+  assert.equal((projected.lifecycle as { state: string }).state, 'unknown');
+  assert.equal(projected.retryAfterSeconds, undefined);
+  assert.match(String(projected.message), /may have been interrupted/);
+
+  const queued = await operations.run(principal, {
+    tool: 'review_pull_request', args: { idempotencyKey: 'acknowledged-queue-1' }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued', commentId: 42 } }));
+  await db('mcp_operations').where({ id: queued.operationId }).update({ accepted_at: invokedAt, created_at: invokedAt, updated_at: Date.now() });
+
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const catalog = createToolCatalog(deps);
+  const list = catalog.find(tool => tool.name === 'list_operations')!;
+  const get = catalog.find(tool => tool.name === 'get_operation')!;
+  const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: Array<Record<string, unknown>> };
+  const unknown = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'unknown' }) })).data as { operations: Array<Record<string, unknown>> };
+  assert.deepEqual(active.operations.map(row => row.operationId), [queued.operationId]);
+  assert.deepEqual(unknown.operations.map(row => row.operationId), [interrupted!.id]);
+
+  const refreshed = (await get.run({ principal, args: get.schema.parse({ operationId: interrupted!.id }) })).data as Record<string, unknown>;
+  assert.equal(refreshed.state, 'unknown');
+  assert.equal((refreshed.lifecycle as { state: string }).state, 'unknown');
+  let replayed = false;
+  const replay = await operations.run(principal, { tool: 'review_pull_request', args, repository: 'acme/repo' }, async () => {
+    replayed = true;
+    return { status: 200, data: {} };
+  });
+  assert.equal(replayed, false);
+  assert.equal(replay.state, 'unknown');
+  assert.equal((replay.lifecycle as { state: string }).state, 'unknown');
+
+  const queuedRow = await operations.get(principal, String(queued.operationId));
+  assert.equal(queuedRow.state, 'queued');
+  assert.equal(queuedRow.lifecycle, 'accepted');
+
+  // If the original process is merely slow rather than gone, its fresh result
+  // remains authoritative and resolves the unavoidable timeout race.
+  finishInvocation({ status: 202, data: { state: 'queued', commentId: 99 } });
+  const resolved = await pending;
+  assert.equal(resolved.state, 'queued');
+  assert.equal((resolved.lifecycle as { state: string }).state, 'accepted');
+});
+
 test('tracker uncertainty resolves from later evidence and preserves observed timestamps and terminal outcomes', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());

From 44e71e6212512d1d8e821a6b26a9e0d1259c5de6 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 02:26:39 +0000
Subject: [PATCH 06/19] feat(ai): Implemented F7 only.

Implemented F7 only.

- Legacy result-less `running` receipts now share the interruption predicate with `accepted` receipts and are durably transitioned to compatibility/lifecycle `unknown` ([operations.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T02-18-39/packages/api/mcp/operations.ts:53), [operations.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T02-18-39/packages/api/mcp/operations.ts:126)).
- Added a migration regression covering backfill, active/unknown filtering, repeated polling, retry-hint removal, and persisted state ([mcpOperations.test.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T02-18-39/packages/api/test/mcpOperations.test.ts:388)).

Validation:

- Focused operation suite: 12/12 passed.
- API typecheck passed.
- Affected-file lint and `git diff --check` passed.
- Broader MCP glob encountered unrelated Node 22 incompatibilities where existing tests require `mock.module`; the affected operation suite passed within that run.

No visual preview was generated because this is API/database-only behavior. No additional defects were changed.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operations.ts          |  6 ++--
 packages/api/test/mcpOperations.test.ts | 41 +++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index fba616143..5805b87d2 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -52,7 +52,7 @@ function operationState(result: OperationResult): string {
 
 function invocationInterrupted(row: Operation, now = Date.now()): boolean {
   const invokedAt = Number(row.accepted_at ?? row.created_at);
-  return row.state === 'accepted' && row.result === null && Number.isFinite(invokedAt)
+  return ['accepted', 'running'].includes(row.state) && row.result === null && Number.isFinite(invokedAt)
     && now - invokedAt > interruptionTimeoutMs;
 }
 
@@ -125,8 +125,8 @@ export class McpOperations {
 
   async markInterruptedInvocations(principal: McpPrincipal, id?: string): Promise<void> {
     const now = Date.now();
-    const query = this.db('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id, state: 'accepted' })
-      .whereNull('result').whereIn('lifecycle', ['accepted', 'running', 'unknown'])
+    const query = this.db('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
+      .whereIn('state', ['accepted', 'running']).whereNull('result').whereIn('lifecycle', ['accepted', 'running', 'unknown'])
       .whereRaw('COALESCE(accepted_at, created_at) < ?', [now - interruptionTimeoutMs]);
     if (id) query.andWhere({ id });
     await query.update({ state: 'unknown', lifecycle: 'unknown', updated_at: now });
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index b27c27e36..854214449 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -1,3 +1,4 @@
+/* eslint-disable max-lines -- MCP operation and migration regressions share one database fixture. */
 import assert from 'node:assert/strict';
 import { after, test } from 'node:test';
 import { mkdtemp, rm } from 'node:fs/promises';
@@ -384,6 +385,46 @@ test('operation lifecycle migration backfills and rolls back on SQLite', async t
   assert.equal(await db.schema.hasColumn('mcp_operations', 'accepted_at'), false);
 });
 
+test('migration reconciles an interrupted legacy running receipt across filters and repeated polls', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db);
+  const operationId = '00000000-0000-4000-8000-000000000007';
+  const invokedAt = Date.now() - 120_001;
+  await db('mcp_operations').insert({
+    id: operationId, owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'legacy-running-1',
+    tool: 'fixture', payload_hash: 'legacy', state: 'running', result: null,
+    created_at: invokedAt, updated_at: invokedAt,
+  });
+  await lifecycleUp(db);
+  assert.deepEqual(await db('mcp_operations').where({ id: operationId }).first('state', 'lifecycle', 'accepted_at'), {
+    state: 'running', lifecycle: 'accepted', accepted_at: invokedAt,
+  });
+
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const catalog = createToolCatalog(deps);
+  const list = catalog.find(tool => tool.name === 'list_operations')!;
+  const get = catalog.find(tool => tool.name === 'get_operation')!;
+
+  const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: Array<Record<string, unknown>> };
+  const unknown = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'unknown' }) })).data as { operations: Array<Record<string, unknown>> };
+  assert.deepEqual(active.operations, []);
+  assert.deepEqual(unknown.operations.map(row => row.operationId), [operationId]);
+
+  for (let poll = 0; poll < 2; poll++) {
+    const receipt = (await get.run({ principal, args: get.schema.parse({ operationId }) })).data as Record<string, unknown>;
+    assert.equal(receipt.state, 'unknown');
+    assert.equal((receipt.lifecycle as { state: string }).state, 'unknown');
+    assert.equal(receipt.retryAfterSeconds, undefined);
+  }
+  assert.deepEqual(await db('mcp_operations').where({ id: operationId }).first('state', 'lifecycle'), {
+    state: 'unknown', lifecycle: 'unknown',
+  });
+});
+
 test('CIMD intersects plural supported methods with public PKCE instead of trusting a legacy preference', () => {
   const id = 'https://client.example/oauth/client.json';
   const document = { client_id: id, client_name: 'Test', redirect_uris: ['https://client.example/callback'], token_endpoint_auth_methods_supported: ['none', 'private_key_jwt'], token_endpoint_auth_method: 'private_key_jwt' };

From 1feab91fd1128041d46836acc0b5b4cf7358350d Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 02:46:30 +0000
Subject: [PATCH 07/19] feat(ai): Implemented F8 only.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implemented F8 only.

- Reconciles persisted terminal receipts with lifecycle state before replay, duplicate dispatch, lookup, and lifecycle-filtered listing.
- Preserves the terminal receipt’s persisted timestamp as `finished_at`.
- Added interruption regressions for synchronous invocation completion and tracker completion.
- Updated [operations.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T02-39-56/packages/api/mcp/operations.ts:61), [tools.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T02-39-56/packages/api/mcp/tools.ts:361), and [mcpOperations.test.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T02-39-56/packages/api/test/mcpOperations.test.ts:117).

Validation:

- API typecheck passed.
- API lint passed.
- Full MCP suite passed: 122 tests.
- No visual preview generated; this is non-visual persistence behavior.
- No independent findings.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operations.ts          | 20 ++++++-
 packages/api/mcp/tools.ts               |  1 +
 packages/api/test/mcpOperations.test.ts | 71 +++++++++++++++++++++++++
 3 files changed, 91 insertions(+), 1 deletion(-)

diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index 5805b87d2..f31b2f3b8 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -64,6 +64,7 @@ export class McpOperations {
     let previous = await this.db<Operation>('mcp_operations').where(identity).first();
     if (!previous) return undefined;
     if (previous.payload_hash !== digest(canonical({ tool, args }))) throw new McpError('IDEMPOTENCY_CONFLICT', 'This key was already used with different arguments.', 409);
+    await this.reconcileTerminalLifecycles(principal, previous.id);
     await this.markInterruptedInvocations(principal, previous.id);
     previous = (await this.db<Operation>('mcp_operations').where(identity).first())!;
     return this.project(previous);
@@ -80,8 +81,10 @@ export class McpOperations {
       payload_hash: payloadHash, state: 'accepted', lifecycle: 'accepted', accepted_at: acceptedAt, artifacts: JSON.stringify({}),
       created_at: acceptedAt, updated_at: acceptedAt }).onConflict(['owner_id', 'grant_id', 'idempotency_key']).ignore().returning('id');
     if (!inserted.length) {
-      const previous = await this.db<Operation>('mcp_operations').where(identity).first();
+      let previous = await this.db<Operation>('mcp_operations').where(identity).first();
       if (!previous || previous.payload_hash !== payloadHash) throw new McpError('IDEMPOTENCY_CONFLICT', 'This key was already used with different arguments.', 409);
+      await this.reconcileTerminalLifecycles(principal, previous.id);
+      previous = (await this.db<Operation>('mcp_operations').where(identity).first())!;
       return this.project(previous);
     }
     try {
@@ -117,12 +120,27 @@ export class McpOperations {
   }
 
   async get(principal: McpPrincipal, id: string): Promise<Operation> {
+    await this.reconcileTerminalLifecycles(principal, id);
     await this.markInterruptedInvocations(principal, id);
     const row = await this.db<Operation>('mcp_operations').where({ id, owner_id: principal.user.id, grant_id: principal.grant.id }).first();
     if (!row) throw new McpError('NOT_FOUND', 'Operation not found.', 404);
     return row;
   }
 
+  /** Repair a process interruption after its terminal receipt write but before lifecycle synchronization. */
+  async reconcileTerminalLifecycles(principal: McpPrincipal, id?: string): Promise<void> {
+    const query = this.db('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
+      .whereIn('state', ['completed', 'failed', 'cancelled'])
+      .whereIn('lifecycle', ['accepted', 'running', 'unknown']);
+    if (id) query.andWhere({ id });
+    await query.update({
+      lifecycle: this.db.raw('state'),
+      // The receipt update time is the strongest durable evidence of when the
+      // terminal outcome was persisted; recovery itself must not move it.
+      finished_at: this.db.raw('COALESCE(finished_at, updated_at, ?)', [Date.now()]),
+    });
+  }
+
   async markInterruptedInvocations(principal: McpPrincipal, id?: string): Promise<void> {
     const now = Date.now();
     const query = this.db('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index 3d08ad8bb..126ce6436 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -367,6 +367,7 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
       offset: z.number().int().min(0).max(100000).default(0),
       limit: z.number().int().min(1).max(50).default(20),
     }).strict(), run: async ({ principal, args }) => {
+      await operations.reconcileTerminalLifecycles(principal);
       await operations.markInterruptedInvocations(principal);
       const query = db<Operation>('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
         .whereRaw('COALESCE(accepted_at, created_at) >= ?', [Date.now() - args.sinceMinutes * 60_000]);
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 854214449..580cb20c6 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -114,6 +114,77 @@ test('operation lifecycle transitions, artifacts and progress are durable and mo
   assert.equal((projected.lifecycle as { failure: unknown }).failure, null);
 });
 
+test('replay reconciles an invocation interrupted after its terminal receipt was persisted', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const operations = new McpOperations(db);
+  const args = { idempotencyKey: 'interrupted-success-1' };
+  const receipt = await operations.run(principal, { tool: 'fixture_action', args, repository: 'acme/repo' },
+    async () => ({ status: 202, data: { state: 'queued' } }));
+  const persistedAt = Date.now() - 500;
+  await db('mcp_operations').where({ id: receipt.operationId }).update({
+    state: 'completed', result: JSON.stringify({ changed: true }), updated_at: persistedAt,
+  });
+  assert.deepEqual(await db('mcp_operations').where({ id: receipt.operationId }).first('state', 'lifecycle', 'finished_at'), {
+    state: 'completed', lifecycle: 'accepted', finished_at: null,
+  });
+
+  const restarted = new McpOperations(db);
+  const replay = await restarted.replay(principal, 'fixture_action', args);
+  assert.equal(replay?.state, 'completed');
+  assert.deepEqual(replay?.result, { changed: true });
+  assert.deepEqual(replay?.lifecycle, {
+    state: 'completed', acceptedAt: (receipt.lifecycle as { acceptedAt: string }).acceptedAt,
+    startedAt: null, finishedAt: new Date(persistedAt).toISOString(), failure: null,
+    artifacts: {}, progress: null,
+  });
+
+  // Ordinary duplicate dispatch has the same recovery boundary as explicit replay.
+  await db('mcp_operations').where({ id: receipt.operationId }).update({ lifecycle: 'accepted', finished_at: null });
+  let invoked = false;
+  const duplicate = await restarted.run(principal, { tool: 'fixture_action', args, repository: 'acme/repo' }, async () => {
+    invoked = true;
+    return { status: 200, data: {} };
+  });
+  assert.equal(invoked, false);
+  assert.equal((duplicate.lifecycle as { state: string }).state, 'completed');
+});
+
+test('list_operations reconciles a tracker interruption before lifecycle filtering', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const operations = new McpOperations(db);
+  const receipt = await operations.run(principal, {
+    tool: 'send_task_followup', args: { idempotencyKey: 'tracker-interrupt-1' }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued', continuation: { taskId: 'task-1' } } }));
+  const persistedAt = Date.now() - 500;
+  // This is the tracker write immediately before get_operation would normally
+  // call syncLifecycle; a stopped process leaves exactly this durable row.
+  await db('mcp_operations').where({ id: receipt.operationId }).update({
+    state: 'completed', result: JSON.stringify({ state: 'queued', continuation: { taskId: 'task-1' }, executionResolved: true }),
+    updated_at: persistedAt,
+  });
+
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const list = createToolCatalog(deps).find(tool => tool.name === 'list_operations')!;
+  const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: Array<Record<string, unknown>> };
+  const completed = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'completed' }) })).data as { operations: Array<Record<string, unknown>> };
+  assert.deepEqual(active.operations, []);
+  assert.deepEqual(completed.operations.map(row => row.operationId), [receipt.operationId]);
+  assert.equal((completed.operations[0].lifecycle as { state: string }).state, 'completed');
+  assert.equal((completed.operations[0].lifecycle as { finishedAt: string }).finishedAt, new Date(persistedAt).toISOString());
+  assert.deepEqual(await db('mcp_operations').where({ id: receipt.operationId }).first('state', 'lifecycle', 'finished_at'), {
+    state: 'completed', lifecycle: 'completed', finished_at: persistedAt,
+  });
+});
+
 test('polling an accepted wrapper does not fabricate backend execution start', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());

From e26aa70467de9ecbdee7192ed0fa84b9ce8cb561 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 03:08:05 +0000
Subject: [PATCH 08/19] feat(ai): Implemented F9 and F10.

Implemented F9 and F10.

- Terminal recovery now restores receipt-derived artifacts and failure metadata with stale-receipt guards.
- Repository-filtered listings resolve cancellation source repositories before filtering and pagination.
- Added regressions for replay/list recovery and cancellation filtering.
- No independent defects discovered.
- No visual preview generated; changes are API/database-only.

Validation:

- MCP operations tests: 14/14 passed
- Full MCP suite: 122/122 passed
- API typecheck passed
- API lint passed
- `git diff --check` passed

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operations.ts          | 46 ++++++++++++++++++----
 packages/api/mcp/tools.ts               |  3 +-
 packages/api/test/mcpOperations.test.ts | 51 +++++++++++++++++++++----
 3 files changed, 83 insertions(+), 17 deletions(-)

diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index f31b2f3b8..f57d71cb8 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -130,15 +130,45 @@ export class McpOperations {
   /** Repair a process interruption after its terminal receipt write but before lifecycle synchronization. */
   async reconcileTerminalLifecycles(principal: McpPrincipal, id?: string): Promise<void> {
     const query = this.db('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
-      .whereIn('state', ['completed', 'failed', 'cancelled'])
-      .whereIn('lifecycle', ['accepted', 'running', 'unknown']);
+      .whereIn('state', ['completed', 'failed', 'cancelled']);
     if (id) query.andWhere({ id });
-    await query.update({
-      lifecycle: this.db.raw('state'),
-      // The receipt update time is the strongest durable evidence of when the
-      // terminal outcome was persisted; recovery itself must not move it.
-      finished_at: this.db.raw('COALESCE(finished_at, updated_at, ?)', [Date.now()]),
-    });
+    const rows = await query.select<Operation[]>();
+    for (const row of rows) {
+      const receipt = { state: row.state, result: json(row.result) };
+      const artifacts = artifactsFromReceipt(row, receipt);
+      const storedArtifacts = json(row.artifacts);
+      const artifactRecord = storedArtifacts && typeof storedArtifacts === 'object' && !Array.isArray(storedArtifacts)
+        ? storedArtifacts as Record<string, unknown> : {};
+      const missingArtifacts = Object.fromEntries(Object.entries(artifacts)
+        .filter(([key, value]) => canonical(artifactRecord[key]) !== canonical(value)));
+      const failure = row.state === 'failed' ? failureFromReceipt(receipt) : undefined;
+      const lifecycleMissing = ['accepted', 'running', 'unknown'].includes(row.lifecycle) || row.finished_at === null;
+      if (!lifecycleMissing && !Object.keys(missingArtifacts).length && !(failure && row.failure === null)) continue;
+
+      const update: Record<string, unknown> = { updated_at: Date.now() };
+      if (lifecycleMissing) {
+        update.lifecycle = row.state;
+        // The receipt update time is the strongest durable evidence of when
+        // the terminal outcome was persisted; recovery itself must not move it.
+        update.finished_at = this.db.raw('COALESCE(finished_at, ?, ?)', [row.updated_at, Date.now()]);
+      }
+      if (Object.keys(missingArtifacts).length) {
+        update.artifacts = this.db.raw("json_patch(COALESCE(artifacts, '{}'), ?)", [JSON.stringify(missingArtifacts)]);
+      }
+      if (failure && row.failure === null) {
+        update.failure = this.db.raw('COALESCE(failure, ?)', [JSON.stringify(failure)]);
+      }
+
+      // Do not attach metadata derived from a receipt that changed after the
+      // read. A later reconciliation will use the newer durable evidence.
+      const eligible = this.db('mcp_operations').where({
+        id: row.id, owner_id: row.owner_id, grant_id: row.grant_id,
+        state: row.state, lifecycle: row.lifecycle,
+      });
+      if (row.result === null) eligible.whereNull('result');
+      else eligible.andWhere('result', row.result);
+      await eligible.update(update);
+    }
   }
 
   async markInterruptedInvocations(principal: McpPrincipal, id?: string): Promise<void> {
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index 126ce6436..b56f9ef01 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -372,7 +372,7 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
       const query = db<Operation>('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
         .whereRaw('COALESCE(accepted_at, created_at) >= ?', [Date.now() - args.sinceMinutes * 60_000]);
       if (args.tool) query.where('tool', args.tool);
-      if (args.repository) query.where('repository', args.repository);
+      if (args.repository) query.andWhere(builder => builder.where('repository', args.repository).orWhere('tool', 'cancel_operation'));
       if (args.lifecycle === 'active') query.whereIn('lifecycle', ['accepted', 'running']);
       else if (args.lifecycle) query.where('lifecycle', args.lifecycle);
       const ordered = query.orderByRaw('COALESCE(accepted_at, created_at) DESC').orderBy('id', 'desc');
@@ -388,6 +388,7 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
         for (const row of rows) {
           try {
             await authorizeOperation(row, principal, repositoryAuthorizations);
+            if (args.repository && row.repository !== args.repository) continue;
             authorized.push(row);
           } catch (error) {
             // Discovery is a filtered view: current authorization failures do
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 580cb20c6..5d1d11440 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -114,7 +114,7 @@ test('operation lifecycle transitions, artifacts and progress are durable and mo
   assert.equal((projected.lifecycle as { failure: unknown }).failure, null);
 });
 
-test('replay reconciles an invocation interrupted after its terminal receipt was persisted', async t => {
+test('replay recovers terminal lifecycle, artifacts and failure from durable receipts', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
@@ -126,7 +126,7 @@ test('replay reconciles an invocation interrupted after its terminal receipt was
     async () => ({ status: 202, data: { state: 'queued' } }));
   const persistedAt = Date.now() - 500;
   await db('mcp_operations').where({ id: receipt.operationId }).update({
-    state: 'completed', result: JSON.stringify({ changed: true }), updated_at: persistedAt,
+    state: 'completed', result: JSON.stringify({ changed: true, taskId: 'task-recovered' }), updated_at: persistedAt,
   });
   assert.deepEqual(await db('mcp_operations').where({ id: receipt.operationId }).first('state', 'lifecycle', 'finished_at'), {
     state: 'completed', lifecycle: 'accepted', finished_at: null,
@@ -135,15 +135,16 @@ test('replay reconciles an invocation interrupted after its terminal receipt was
   const restarted = new McpOperations(db);
   const replay = await restarted.replay(principal, 'fixture_action', args);
   assert.equal(replay?.state, 'completed');
-  assert.deepEqual(replay?.result, { changed: true });
+  assert.deepEqual(replay?.result, { changed: true, taskId: 'task-recovered' });
   assert.deepEqual(replay?.lifecycle, {
     state: 'completed', acceptedAt: (receipt.lifecycle as { acceptedAt: string }).acceptedAt,
     startedAt: null, finishedAt: new Date(persistedAt).toISOString(), failure: null,
-    artifacts: {}, progress: null,
+    artifacts: { taskId: 'task-recovered' }, progress: null,
   });
 
-  // Ordinary duplicate dispatch has the same recovery boundary as explicit replay.
-  await db('mcp_operations').where({ id: receipt.operationId }).update({ lifecycle: 'accepted', finished_at: null });
+  // Repeat entry points also repair rows left terminal by the older
+  // lifecycle-only reconciliation.
+  await db('mcp_operations').where({ id: receipt.operationId }).update({ artifacts: JSON.stringify({}) });
   let invoked = false;
   const duplicate = await restarted.run(principal, { tool: 'fixture_action', args, repository: 'acme/repo' }, async () => {
     invoked = true;
@@ -151,9 +152,21 @@ test('replay reconciles an invocation interrupted after its terminal receipt was
   });
   assert.equal(invoked, false);
   assert.equal((duplicate.lifecycle as { state: string }).state, 'completed');
+  assert.deepEqual((duplicate.lifecycle as { artifacts: unknown }).artifacts, { taskId: 'task-recovered' });
+
+  const failedArgs = { idempotencyKey: 'interrupted-failure-1' };
+  const failed = await operations.run(principal, { tool: 'fixture_action', args: failedArgs, repository: 'acme/repo' },
+    async () => ({ status: 202, data: { state: 'queued' } }));
+  const failure = { code: 'WORKFLOW_FAILED', message: 'The durable workflow failed.', stage: 'internal', retryable: false, status: 500 };
+  await db('mcp_operations').where({ id: failed.operationId }).update({
+    state: 'failed', result: JSON.stringify({ error: failure }), updated_at: persistedAt,
+  });
+  const failedReplay = await restarted.replay(principal, 'fixture_action', failedArgs);
+  assert.equal((failedReplay?.lifecycle as { state: string }).state, 'failed');
+  assert.deepEqual((failedReplay?.lifecycle as { failure: unknown }).failure, failure);
 });
 
-test('list_operations reconciles a tracker interruption before lifecycle filtering', async t => {
+test('list_operations recovers terminal lifecycle, artifacts and failure before filtering', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
@@ -162,7 +175,10 @@ test('list_operations reconciles a tracker interruption before lifecycle filteri
   const operations = new McpOperations(db);
   const receipt = await operations.run(principal, {
     tool: 'send_task_followup', args: { idempotencyKey: 'tracker-interrupt-1' }, repository: 'acme/repo',
-  }, async () => ({ status: 202, data: { state: 'queued', continuation: { taskId: 'task-1' } } }));
+  }, async () => ({ status: 202, data: { state: 'queued' } }));
+  const failed = await operations.run(principal, {
+    tool: 'send_task_followup', args: { idempotencyKey: 'tracker-failure-02' }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued' } }));
   const persistedAt = Date.now() - 500;
   // This is the tracker write immediately before get_operation would normally
   // call syncLifecycle; a stopped process leaves exactly this durable row.
@@ -170,16 +186,24 @@ test('list_operations reconciles a tracker interruption before lifecycle filteri
     state: 'completed', result: JSON.stringify({ state: 'queued', continuation: { taskId: 'task-1' }, executionResolved: true }),
     updated_at: persistedAt,
   });
+  const failure = { code: 'TASK_FAILED', message: 'Task execution failed.', stage: 'internal', retryable: false, status: 500 };
+  await db('mcp_operations').where({ id: failed.operationId }).update({
+    state: 'failed', result: JSON.stringify({ error: failure }), updated_at: persistedAt,
+  });
 
   const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
     taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
   const list = createToolCatalog(deps).find(tool => tool.name === 'list_operations')!;
   const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: Array<Record<string, unknown>> };
   const completed = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'completed' }) })).data as { operations: Array<Record<string, unknown>> };
+  const failures = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'failed' }) })).data as { operations: Array<Record<string, unknown>> };
   assert.deepEqual(active.operations, []);
   assert.deepEqual(completed.operations.map(row => row.operationId), [receipt.operationId]);
   assert.equal((completed.operations[0].lifecycle as { state: string }).state, 'completed');
   assert.equal((completed.operations[0].lifecycle as { finishedAt: string }).finishedAt, new Date(persistedAt).toISOString());
+  assert.deepEqual((completed.operations[0].lifecycle as { artifacts: unknown }).artifacts, { taskId: 'task-1' });
+  assert.deepEqual(failures.operations.map(row => row.operationId), [failed.operationId]);
+  assert.deepEqual((failures.operations[0].lifecycle as { failure: unknown }).failure, failure);
   assert.deepEqual(await db('mcp_operations').where({ id: receipt.operationId }).first('state', 'lifecycle', 'finished_at'), {
     state: 'completed', lifecycle: 'completed', finished_at: persistedAt,
   });
@@ -430,6 +454,17 @@ test('list_operations filters current repository, tool permission and cancellati
   const cancellations = (await list.run({ principal, args: list.schema.parse({ tool: 'cancel_operation' }) })).data as { operations: unknown[] };
   assert.deepEqual(cancellations.operations, []);
 
+  const allowedSource = await run('review_pull_request', 'allowed-cancel-src', 'acme/allowed', { marker: 'allowed-source' });
+  const allowedCancellation = await run('cancel_operation', 'allowed-cancel-rct', undefined,
+    { operationId: allowedSource.operationId, cancellation: 'requested' });
+  const otherSource = await run('review_pull_request', 'other-cancel-src-1', 'acme/other', { marker: 'other-source' });
+  await run('cancel_operation', 'other-cancel-rct1', undefined,
+    { operationId: otherSource.operationId, cancellation: 'requested' });
+  const repositoryCancellations = (await list.run({ principal, args: list.schema.parse({
+    tool: 'cancel_operation', repository: 'acme/allowed', limit: 1,
+  }) })).data as { operations: Array<Record<string, unknown>> };
+  assert.deepEqual(repositoryCancellations.operations.map(item => item.operationId), [allowedCancellation.operationId]);
+
   await assert.rejects(get.run({ principal, args: get.schema.parse({ operationId: forbiddenPermission.operationId }) }), /Permission removed/);
   await assert.rejects(get.run({ principal, args: get.schema.parse({ operationId: forbiddenRepository.operationId }) }), /No current access/);
   await assert.rejects(get.run({ principal, args: get.schema.parse({ operationId: cancellation.operationId }) }), /No current access/);

From f1490799b27ace506286c89cc6981b2a6ad29ea4 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 03:30:48 +0000
Subject: [PATCH 09/19] feat(ai): Implemented F11 and F12 only.

Implemented F11 and F12 only.

- Goal operations now use their current task history as execution evidence, including already-completed/failed tasks, while terminality remains tied to the goal result. [tools.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T03-21-04/packages/api/mcp/tools.ts:343) [operationLifecycle.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T03-21-04/packages/api/mcp/operationLifecycle.ts:143)
- Failed ultrafix loops now prioritize their own completion reason over successful task reasons, with an `Ultrafix loop failed.` fallback. [operationLifecycle.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T03-21-04/packages/api/mcp/operationLifecycle.ts:92)
- Added focused persistence and end-to-end regressions for both paths. [mcpOperations.test.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T03-21-04/packages/api/test/mcpOperations.test.ts:350) [mcpWorkflows.test.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T03-21-04/packages/api/test/mcpWorkflows.test.ts:246)

Validation:

- API TypeScript check passed.
- API lint completed successfully.
- Full MCP suite passed: 122 tests.
- No visual preview generated; changes are backend-only.
- Independent discoveries: none.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts  | 13 +++++++++++--
 packages/api/mcp/tools.ts               | 11 ++++++++++-
 packages/api/test/mcpOperations.test.ts | 17 ++++++++++++++++-
 packages/api/test/mcpWorkflows.test.ts  | 24 +++++++++++++++++-------
 4 files changed, 54 insertions(+), 11 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index 402b62a03..aaea963ff 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -2,6 +2,7 @@ import { redactSecrets, type McpErrorEnvelope } from './errorEnvelope.js';
 import type { McpOperations, LifecycleOutcome, LifecycleState, Operation } from './operations.js';
 
 const startedTaskStates = new Set(['processing', 'claude_execution', 'post_processing']);
+const executedGoalTaskStates = new Set([...startedTaskStates, 'completed', 'failed']);
 const terminalStates = new Set<LifecycleOutcome>(['completed', 'failed', 'cancelled']);
 
 function record(value: unknown): Record<string, unknown> | undefined {
@@ -97,6 +98,11 @@ export function failureFromReceipt(receipt: Record<string, unknown>): McpErrorEn
     return resultError as unknown as McpErrorEnvelope;
   }
 
+  const loop = record(result?.loop);
+  if (loop?.completionStatus === 'failed') {
+    return publicFailure('EXECUTION_FAILED', nonEmptyString(loop.completionReason) ?? 'Ultrafix loop failed.');
+  }
+
   const target = record(receipt.targetState);
   const reviewResults = Array.isArray(target?.reviewResults) ? target.reviewResults
     : Array.isArray(result?.reviewResults) ? result.reviewResults : [];
@@ -150,9 +156,12 @@ export async function syncLifecycle(
   const receiptState = String(receipt.state ?? '');
   const result = record(receipt.result);
   const loop = record(result?.loop);
-  const observedStart = startedTaskStates.has(targetState) || target?.queueState === 'active' || loop?.active === true;
+  const currentTask = record(target?.currentTask);
+  const currentTaskState = String(currentTask?.state ?? '');
+  const observedStart = startedTaskStates.has(targetState) || executedGoalTaskStates.has(currentTaskState)
+    || target?.queueState === 'active' || loop?.active === true;
   if (observedStart) {
-    await operations.markStarted(row.id, epochMilliseconds(target?.timestamp));
+    await operations.markStarted(row.id, epochMilliseconds(currentTask?.timestamp) ?? epochMilliseconds(target?.timestamp));
   }
 
   const outcome = lifecycleOutcome(row, target, receiptState, targetState);
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index b56f9ef01..0ff95099c 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -340,7 +340,16 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
     const continuation = result.continuation && typeof result.continuation === 'object' && !Array.isArray(result.continuation)
       ? result.continuation as Record<string, unknown> : result;
     if (continuation.planId) receipt.targetState = await db('task_drafts').where({ draft_id: continuation.planId, user_id: principal.user.id }).first('status', 'paused', 'mcp_revision');
-    if (continuation.goalId) receipt.targetState = await db('goals').where({ goal_id: continuation.goalId, owner_id: principal.user.id }).first('desired_state', 'result_state', 'current_task_id');
+    if (continuation.goalId) {
+      const goal = await db('goals').where({ goal_id: continuation.goalId, owner_id: principal.user.id })
+        .first('desired_state', 'result_state', 'current_task_id');
+      if (goal) {
+        const currentTask = typeof goal.current_task_id === 'string'
+          ? await db('task_history').where({ task_id: goal.current_task_id }).orderBy('history_id', 'desc').first('state', 'timestamp')
+          : undefined;
+        receipt.targetState = { ...goal, ...(currentTask ? { currentTask: { taskId: goal.current_task_id, ...currentTask } } : {}) };
+      }
+    }
     if (continuation.taskId) receipt.targetState = await db('task_history').where({ task_id: continuation.taskId }).orderBy('history_id', 'desc').first('state', 'timestamp');
     updateReceiptState(row, receipt);
     await trackTaskSubmission(deps, row, principal, receipt);
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 5d1d11440..d34cc7eae 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -14,7 +14,7 @@ import { callWorkflow } from '../mcp/adapter.js';
 import { parseClientMetadataDocument } from '../mcp/clients.js';
 import { createToolCatalog, type ToolDeps } from '../mcp/tools.js';
 import type { McpPrincipal } from '../mcp/policy.js';
-import { syncLifecycle } from '../mcp/operationLifecycle.js';
+import { failureFromReceipt, syncLifecycle } from '../mcp/operationLifecycle.js';
 
 after(closeConnection);
 
@@ -377,6 +377,21 @@ test('tracker task and review failures populate and can enrich the durable failu
     code: 'REVIEW_FAILED', message: 'Reviewer unavailable; Model timed out', stage: 'internal', retryable: false, status: 500,
     details: { failedReviewCount: 2 },
   });
+
+  const ultrafix = await create('run_ultrafix', 'ultrafix-failure-1');
+  const ultrafixRow = await operations.get(principal, String(ultrafix.operationId));
+  await syncLifecycle(operations, ultrafixRow, { ...ultrafix, state: 'failed',
+    targetState: { taskId: 'ultrafix-task', state: 'completed', reason: 'Task completed successfully' },
+    result: { loop: { completionStatus: 'failed', completionReason: 'Maximum cycles reached without resolving the findings.' } },
+  });
+  assert.deepEqual((operations.project(await operations.get(principal, ultrafixRow.id)).lifecycle as { failure: unknown }).failure, {
+    code: 'EXECUTION_FAILED', message: 'Maximum cycles reached without resolving the findings.',
+    stage: 'internal', retryable: false, status: 500,
+  });
+  assert.equal(failureFromReceipt({
+    targetState: { state: 'completed', reason: 'Task completed successfully' },
+    result: { loop: { completionStatus: 'failed' } },
+  })?.message, 'Ultrafix loop failed.');
 });
 
 test('list_operations filters active receipts by exact owner and grant without refreshing trackers', async t => {
diff --git a/packages/api/test/mcpWorkflows.test.ts b/packages/api/test/mcpWorkflows.test.ts
index dc195dda0..28c592e40 100644
--- a/packages/api/test/mcpWorkflows.test.ts
+++ b/packages/api/test/mcpWorkflows.test.ts
@@ -246,8 +246,17 @@ test('both SDK eras drive persisted goal, TODO, notification, settings and guard
         const created = await call('create_goal', { repository, objective: 'Improve reliability', agentId: agent.config.id, model: 'fixture-model', launchStrategy: 'direct' }, true);
         assert.equal(created.state, 'accepted', JSON.stringify(created));
         const goalId = created.result.continuation.goalId;
-        assert.equal((await db('goals').where({ goal_id: goalId }).first()).desired_state, 'running');
+        const createdGoal = await db('goals').where({ goal_id: goalId }).first();
+        assert.equal(createdGoal.desired_state, 'running');
         assert.ok(jobs.some(job => job.goalId === goalId));
+        await db('tasks').insert({ task_id: createdGoal.current_task_id, repository, task_type: 'goal' });
+        await db('task_history').insert({ task_id: createdGoal.current_task_id, state: 'processing' });
+        await db('task_history').insert({ task_id: createdGoal.current_task_id, state: 'completed', reason: 'Goal task completed successfully' });
+        const runningGoal = await call('get_operation', { operationId: created.operationId });
+        assert.equal(runningGoal.lifecycle.state, 'running');
+        assert.ok(runningGoal.lifecycle.startedAt);
+        const runningOperations = await call('list_operations', { lifecycle: 'running' });
+        assert.ok(runningOperations.operations.some((operation: { operationId: string }) => operation.operationId === created.operationId));
         const input = await call('send_goal_input', { repository, goalId, message: 'Add error handling' }, true); assert.equal(input.state, 'completed', JSON.stringify(input));
         assert.ok(await db('goal_inputs').where({ goal_id: goalId, message: 'Add error handling' }).first());
         await call('pause_goal', { repository, goalId }, true); assert.equal((await db('goals').where({ goal_id: goalId }).first()).desired_state, 'paused');
@@ -316,19 +325,20 @@ test('both SDK eras drive persisted goal, TODO, notification, settings and guard
         const ultrafix = await call('run_ultrafix', pr, true); assert.equal(ultrafix.state, 'posted');
         const loopTask = `ultrafix-start-${modern}`, workEpoch = modern ? 1 : 2;
         await pendingTask(loopTask, ultrafix.result.commentId, modern ? 'review' : 'fix', workEpoch);
-        await db('task_history').insert({ task_id: loopTask, state: 'completed' });
+        await db('task_history').insert({ task_id: loopTask, state: 'completed', reason: 'Task completed successfully' });
         const loop = { active: true, workEpoch, cycleCount: 0, completionStatus: null as string | null, completionReason: null as string | null };
         redisValues.set('ultrafix:state:acme:repo:42', JSON.stringify(loop));
         assert.equal((await call('get_operation', { operationId: ultrafix.operationId })).state, 'running');
-        loop.active = false; loop.completionStatus = 'succeeded'; loop.completionReason = 'Goal reached';
+        loop.active = false; loop.completionStatus = modern ? 'succeeded' : 'failed';
+        loop.completionReason = modern ? 'Goal reached' : 'Maximum cycles reached without resolving the findings.';
         redisValues.set('ultrafix:state:acme:repo:42', JSON.stringify(loop));
         const completedLoop = await call('get_operation', { operationId: ultrafix.operationId });
-        assert.equal(completedLoop.state, 'completed');
-        assert.equal(completedLoop.result.loop.workEpoch, workEpoch);
-        assert.equal(completedLoop.result.loop.completionStatus, 'succeeded');
+        assert.equal(completedLoop.state, modern ? 'completed' : 'failed');
+        assert.equal(completedLoop.result.loop.workEpoch, workEpoch); assert.equal(completedLoop.result.loop.completionStatus, loop.completionStatus);
+        if (!modern) assert.equal(completedLoop.lifecycle.failure.message, loop.completionReason);
         assert.equal(completedLoop.result.continuation.sourceTaskId, loopTask);
         redisValues.set('ultrafix:state:acme:repo:42', JSON.stringify({ ...loop, workEpoch: workEpoch + 1, active: true, completionStatus: null }));
-        assert.equal((await call('get_operation', { operationId: ultrafix.operationId })).state, 'completed');
+        assert.equal((await call('get_operation', { operationId: ultrafix.operationId })).state, modern ? 'completed' : 'failed');
         const lostIntake = await call('review_pull_request', pr, true);
         await db('mcp_operations').where({ id: lostIntake.operationId }).update({ created_at: Date.now() - 180000 });
         assert.equal((await call('get_operation', { operationId: lostIntake.operationId })).state, 'unknown');

From eeda18435c613e053338b0457e457684d2c2bbbf Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 03:38:53 +0000
Subject: [PATCH 10/19] feat(ai): Fixed the `Validate Changes` failure.

Fixed the `Validate Changes` failure.

- Refactored lifecycle failure/start detection into focused helpers, resolving both complexity warnings.
- Added the repository-standard documented `max-lines` exemption for the shared MCP workflow fixture.
- Confirmed the `ubuntu-latest` migration message was unrelated.

Validation passed:

- API lint with `--max-warnings 0`
- API typecheck
- Full MCP suite: 122/122 tests
- `git diff --check`

No visual preview was needed because this is CI/internal logic only.

PR: #2613
Comment by: @propr-dev[bot] (ID: 5883101945)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts | 41 +++++++++++++++++---------
 packages/api/test/mcpWorkflows.test.ts |  1 +
 2 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index aaea963ff..05b2d3ba0 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -89,9 +89,7 @@ function publicFailure(code: string, message: string, details?: Record<string, u
   return { code, message: redactSecrets(message), stage: 'internal', retryable: false, status: 500, ...(details ? { details } : {}) };
 }
 
-/** Normalize durable backend failure evidence into the public error envelope. */
-export function failureFromReceipt(receipt: Record<string, unknown>): McpErrorEnvelope | undefined {
-  const result = record(receipt.result);
+function resultFailure(result: Record<string, unknown> | undefined): McpErrorEnvelope | undefined {
   const resultError = record(result?.error);
   if (resultError && typeof resultError.code === 'string' && typeof resultError.message === 'string'
     && typeof resultError.retryable === 'boolean' && typeof resultError.status === 'number') {
@@ -99,9 +97,16 @@ export function failureFromReceipt(receipt: Record<string, unknown>): McpErrorEn
   }
 
   const loop = record(result?.loop);
-  if (loop?.completionStatus === 'failed') {
-    return publicFailure('EXECUTION_FAILED', nonEmptyString(loop.completionReason) ?? 'Ultrafix loop failed.');
-  }
+  return loop?.completionStatus === 'failed'
+    ? publicFailure('EXECUTION_FAILED', nonEmptyString(loop.completionReason) ?? 'Ultrafix loop failed.')
+    : undefined;
+}
+
+/** Normalize durable backend failure evidence into the public error envelope. */
+export function failureFromReceipt(receipt: Record<string, unknown>): McpErrorEnvelope | undefined {
+  const result = record(receipt.result);
+  const backendFailure = resultFailure(result);
+  if (backendFailure) return backendFailure;
 
   const target = record(receipt.targetState);
   const reviewResults = Array.isArray(target?.reviewResults) ? target.reviewResults
@@ -140,6 +145,20 @@ async function syncCancellation(
   if (sourceId && result?.cancellation === 'confirmed') await operations.finish(sourceId, 'cancelled');
 }
 
+function observedStartTimestamp(
+  target: Record<string, unknown> | undefined,
+  result: Record<string, unknown> | undefined,
+  targetState: string,
+): number | null | undefined {
+  const loop = record(result?.loop);
+  const currentTask = record(target?.currentTask);
+  const currentTaskState = String(currentTask?.state ?? '');
+  const observedStart = startedTaskStates.has(targetState) || executedGoalTaskStates.has(currentTaskState)
+    || target?.queueState === 'active' || loop?.active === true;
+  if (!observedStart) return null;
+  return epochMilliseconds(currentTask?.timestamp) ?? epochMilliseconds(target?.timestamp);
+}
+
 /** Persist tracker observations without allowing stale concurrent polls to undo newer lifecycle facts. */
 export async function syncLifecycle(
   operations: McpOperations,
@@ -155,14 +174,8 @@ export async function syncLifecycle(
   const targetState = String(target?.state ?? '');
   const receiptState = String(receipt.state ?? '');
   const result = record(receipt.result);
-  const loop = record(result?.loop);
-  const currentTask = record(target?.currentTask);
-  const currentTaskState = String(currentTask?.state ?? '');
-  const observedStart = startedTaskStates.has(targetState) || executedGoalTaskStates.has(currentTaskState)
-    || target?.queueState === 'active' || loop?.active === true;
-  if (observedStart) {
-    await operations.markStarted(row.id, epochMilliseconds(currentTask?.timestamp) ?? epochMilliseconds(target?.timestamp));
-  }
+  const startedAt = observedStartTimestamp(target, result, targetState);
+  if (startedAt !== null) await operations.markStarted(row.id, startedAt);
 
   const outcome = lifecycleOutcome(row, target, receiptState, targetState);
   if (outcome) {
diff --git a/packages/api/test/mcpWorkflows.test.ts b/packages/api/test/mcpWorkflows.test.ts
index 28c592e40..a8a244473 100644
--- a/packages/api/test/mcpWorkflows.test.ts
+++ b/packages/api/test/mcpWorkflows.test.ts
@@ -1,3 +1,4 @@
+/* eslint-disable max-lines -- both MCP SDK eras share one end-to-end workflow fixture */
 import assert from 'node:assert/strict';
 import { test, mock } from 'node:test';
 import { randomBytes, randomUUID } from 'node:crypto';

From 4e16610d5a51bc6f216d80e0727501f44135d5fe Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 04:01:10 +0000
Subject: [PATCH 11/19] feat(ai): Implemented F13 and F14 only.

Implemented F13 and F14 only.

- Goal polling now captures `failure_reason`, task failure reasons, `current_task_id`, and `final_pr_number`.
- Lifecycle normalization persists goal/task failures and task/PR artifacts.
- Terminal task receipts can be enriched when `tasks.pr_number` arrives after completion, closing the avoidable stale-state window.
- Added regressions proving failure/artifact durability after backend rows are removed.
- Updated the task-submission fixture to match the production schema.

Validation:

- API TypeScript check passed.
- Full MCP suite passed: 123/123 tests.
- `git diff --check` passed.
- No visual preview generated; changes are API/database-only.

Independent discoveries: none.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts       |   9 +-
 packages/api/mcp/operationTracking.ts        |  25 +++--
 packages/api/mcp/tools.ts                    |   4 +-
 packages/api/test/mcpOperations.test.ts      | 103 ++++++++++++++++++-
 packages/api/test/mcpTaskSubmissions.test.ts |   2 +-
 5 files changed, 130 insertions(+), 13 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index 05b2d3ba0..7cde6b876 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -40,11 +40,13 @@ export function artifactsFromReceipt(row: Pick<Operation, 'repository'>, receipt
   const result = record(receipt.result) ?? {};
   const continuation = record(result.continuation) ?? {};
   const target = record(receipt.targetState) ?? {};
+  const currentTask = record(target.currentTask) ?? {};
   const targetIssues: Record<string, unknown>[] = Array.isArray(target.issues)
     ? target.issues.map(record).filter((value): value is Record<string, unknown> => !!value) : [];
   const artifacts: Record<string, unknown> = {};
 
-  const taskId = nonEmptyString(target.taskId, target.task_id, continuation.taskId, result.taskId,
+  const taskId = nonEmptyString(target.taskId, target.task_id, target.current_task_id, currentTask.taskId,
+    currentTask.task_id, continuation.taskId, result.taskId,
     ...targetIssues.flatMap(issue => [issue.taskId, issue.task_id]));
   if (taskId) artifacts.taskId = taskId;
 
@@ -52,7 +54,7 @@ export function artifactsFromReceipt(row: Pick<Operation, 'repository'>, receipt
   const pullRequestNumber = positiveInteger(
     result.pullRequest, result.pr_number, result.prNumber,
     continuation.pullRequest, continuation.pr_number,
-    target.pullRequest, target.pr_number,
+    target.pullRequest, target.pr_number, target.final_pr_number,
     ...targetIssues.flatMap(issue => [issue.pullRequest, issue.pr_number]),
   );
   if (repository && pullRequestNumber) artifacts.pullRequest = {
@@ -119,7 +121,8 @@ export function failureFromReceipt(receipt: Record<string, unknown>): McpErrorEn
     });
   }
 
-  const reason = nonEmptyString(target?.reason, result?.reason);
+  const currentTask = record(target?.currentTask);
+  const reason = nonEmptyString(target?.failure_reason, currentTask?.reason, target?.reason, result?.reason);
   return reason ? publicFailure('EXECUTION_FAILED', reason) : undefined;
 }
 
diff --git a/packages/api/mcp/operationTracking.ts b/packages/api/mcp/operationTracking.ts
index 81dc2ac74..6429f6ad6 100644
--- a/packages/api/mcp/operationTracking.ts
+++ b/packages/api/mcp/operationTracking.ts
@@ -73,10 +73,18 @@ export async function trackCancellation(deps: ToolDeps, row: Operation, principa
 export async function trackExecution(deps: ToolDeps, row: Operation, principal: McpPrincipal, receipt: Record<string, unknown>): Promise<void> {
   if (!trackedTools.includes(row.tool) || !row.result) return;
   const { db } = deps;
-  const result = JSON.parse(row.result);
+  const result = JSON.parse(row.result) as ExecutionResult & Record<string, unknown>;
   if (['create_task', 'retry_task_submission'].includes(row.tool) && !result.continuation?.taskId) return;
-  if (result.error || (result.executionResolved && terminalStates.includes(row.state))) return;
+  if (result.error) return;
   const task = row.tool === 'index_repository' ? undefined : await findExecutionTask(deps, row, result);
+  if (result.executionResolved && terminalStates.includes(row.state)) {
+    const persistedTarget = result.targetState ?? {};
+    if (task || Object.keys(persistedTarget).length) receipt.targetState = {
+      ...persistedTarget,
+      ...(task ? { taskId: task.task_id, pr_number: task.pr_number } : {}),
+    };
+    return;
+  }
   if (task) await trackTask(deps, row, { task, result, receipt });
   else if (result.jobId) await trackQueuedJob(row, result.jobId, receipt);
   else if (Date.now() - Number(row.created_at) > 120000) receipt.state = 'unknown';
@@ -86,7 +94,10 @@ export async function trackExecution(deps: ToolDeps, row: Operation, principal:
     result.currentHead = pr.head.sha;
     result.results = { tool: 'get_pull_request_discussion', repository: row.repository, pullRequest: result.pullRequest, taskId: result.continuation?.taskId };
   }
-  if (terminalStates.includes(String(receipt.state))) result.executionResolved = true;
+  if (terminalStates.includes(String(receipt.state))) {
+    result.executionResolved = true;
+    result.targetState = receipt.targetState as Record<string, unknown> | undefined;
+  }
   receipt.result = result;
   if (receipt.state === 'unknown') receipt.message = 'Execution cannot yet be confirmed. Inspect the linked comment/job; polling can still resolve it. Do not blindly resubmit.';
   await db('mcp_operations').where({ id: row.id }).update({ state: receipt.state, result: JSON.stringify(result), updated_at: Date.now() });
@@ -95,11 +106,12 @@ export async function trackExecution(deps: ToolDeps, row: Operation, principal:
 interface ExecutionResult {
   jobId?: string; commentId?: number; pullRequest?: number;
   continuation?: { taskId?: string; jobId?: string; sourceTaskId?: string };
+  targetState?: Record<string, unknown>;
   reviewResults?: Array<{ success: boolean; commentId?: number; commentUrl?: string }>;
   loop?: { completionStatus?: string | null } & Record<string, unknown>;
 }
 interface TrackingContext {
-  task: { task_id: string; initial_job_data: unknown };
+  task: { task_id: string; pr_number: number | null; initial_job_data: unknown };
   result: ExecutionResult; receipt: Record<string, unknown>;
 }
 
@@ -134,14 +146,15 @@ async function findExecutionTask(deps: ToolDeps, row: Operation, result: Executi
   } else {
     query.andWhere(builder => builder.where('task_id', result.jobId || continuation.taskId).orWhere('job_id', result.jobId || continuation.jobId));
   }
-  return query.orderBy('created_at', 'desc').first('task_id', 'initial_job_data');
+  return query.orderBy('created_at', 'desc').first('task_id', 'pr_number', 'initial_job_data');
 }
 
 async function trackTask(deps: ToolDeps, row: Operation, { task, result, receipt }: TrackingContext): Promise<void> {
   result.continuation = { ...result.continuation, taskId: task.task_id };
   const event = await deps.db('task_history').where({ task_id: task.task_id }).orderBy('history_id', 'desc').first('state', 'timestamp', 'reason', 'metadata');
   const metadata = typeof event?.metadata === 'string' ? JSON.parse(event.metadata) : event?.metadata;
-  receipt.targetState = { taskId: task.task_id, state: event?.state, timestamp: event?.timestamp, reason: event?.reason, reviewResults: metadata?.reviewResults };
+  receipt.targetState = { taskId: task.task_id, pr_number: task.pr_number, state: event?.state,
+    timestamp: event?.timestamp, reason: event?.reason, reviewResults: metadata?.reviewResults };
   if (metadata?.reviewResults) result.reviewResults = metadata.reviewResults;
   receipt.state = terminalStates.includes(event?.state) ? event.state : !event || event.state === 'pending' ? 'queued' : 'running';
   if (event?.state === 'completed' && result.reviewResults?.length && result.reviewResults.every(review => !review.success)) receipt.state = 'failed';
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index 0ff95099c..0d64682db 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -342,10 +342,10 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
     if (continuation.planId) receipt.targetState = await db('task_drafts').where({ draft_id: continuation.planId, user_id: principal.user.id }).first('status', 'paused', 'mcp_revision');
     if (continuation.goalId) {
       const goal = await db('goals').where({ goal_id: continuation.goalId, owner_id: principal.user.id })
-        .first('desired_state', 'result_state', 'current_task_id');
+        .first('desired_state', 'result_state', 'current_task_id', 'final_pr_number', 'failure_reason');
       if (goal) {
         const currentTask = typeof goal.current_task_id === 'string'
-          ? await db('task_history').where({ task_id: goal.current_task_id }).orderBy('history_id', 'desc').first('state', 'timestamp')
+          ? await db('task_history').where({ task_id: goal.current_task_id }).orderBy('history_id', 'desc').first('state', 'timestamp', 'reason')
           : undefined;
         receipt.targetState = { ...goal, ...(currentTask ? { currentTask: { taskId: goal.current_task_id, ...currentTask } } : {}) };
       }
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index d34cc7eae..fbbeb778e 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -14,7 +14,7 @@ import { callWorkflow } from '../mcp/adapter.js';
 import { parseClientMetadataDocument } from '../mcp/clients.js';
 import { createToolCatalog, type ToolDeps } from '../mcp/tools.js';
 import type { McpPrincipal } from '../mcp/policy.js';
-import { failureFromReceipt, syncLifecycle } from '../mcp/operationLifecycle.js';
+import { artifactsFromReceipt, failureFromReceipt, syncLifecycle } from '../mcp/operationLifecycle.js';
 
 after(closeConnection);
 
@@ -392,6 +392,107 @@ test('tracker task and review failures populate and can enrich the durable failu
     targetState: { state: 'completed', reason: 'Task completed successfully' },
     result: { loop: { completionStatus: 'failed' } },
   })?.message, 'Ultrafix loop failed.');
+  assert.equal(failureFromReceipt({ targetState: { currentTask: { reason: 'Nested goal task failed' } } })?.message,
+    'Nested goal task failed');
+  assert.deepEqual(artifactsFromReceipt({ repository: 'acme/repo' }, {
+    targetState: { currentTask: { taskId: 'nested-goal-task' }, final_pr_number: 64 },
+  }), {
+    taskId: 'nested-goal-task',
+    pullRequest: { repository: 'acme/repo', number: 64, url: 'https://github.com/acme/repo/pull/64' },
+  });
+});
+
+test('goal failures and generated task pull requests remain durable after backend history is removed', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await db.schema.createTable('goals', table => {
+    table.string('goal_id').primary(); table.string('owner_id'); table.string('repository');
+    table.string('desired_state'); table.string('result_state'); table.string('current_task_id');
+    table.integer('final_pr_number'); table.text('failure_reason');
+  });
+  await db.schema.createTable('tasks', table => {
+    table.string('task_id').primary(); table.string('job_id'); table.string('repository'); table.string('task_type');
+    table.integer('pr_number'); table.text('initial_job_data'); table.timestamp('created_at').defaultTo(db.fn.now());
+  });
+  await db.schema.createTable('task_history', table => {
+    table.increments('history_id').primary(); table.string('task_id'); table.string('state');
+    table.timestamp('timestamp').defaultTo(db.fn.now()); table.text('reason'); table.text('metadata');
+  });
+  await db.schema.createTable('task_submissions', table => {
+    table.string('id').primary(); table.string('user_id'); table.string('submission_key'); table.string('payload_hash');
+    table.string('repository'); table.text('payload'); table.text('attachments'); table.string('state');
+    table.integer('issue_number'); table.text('issue_url'); table.string('task_id'); table.string('retry_event_id');
+    table.boolean('dispatch_complete'); table.text('error'); table.timestamp('created_at').defaultTo(db.fn.now());
+  });
+  await up(db); await lifecycleUp(db);
+
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const operations = new McpOperations(db);
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const catalog = createToolCatalog(deps);
+  const get = catalog.find(tool => tool.name === 'get_operation')!;
+  const list = catalog.find(tool => tool.name === 'list_operations')!;
+
+  const goalArgs = { idempotencyKey: 'durable-goal-output-1' };
+  const goalId = 'goal-output-1';
+  const goalTaskId = 'goal-task-output-1';
+  const goalReceipt = await operations.run(principal, { tool: 'create_goal', args: goalArgs, repository: 'acme/repo' },
+    async () => ({ status: 202, data: { state: 'accepted', continuation: { goalId } } }));
+  await db('tasks').insert({ task_id: goalTaskId, repository: 'acme/repo', task_type: 'goal' });
+  await db('task_history').insert({ task_id: goalTaskId, state: 'failed', reason: 'Backing task stopped' });
+  await db('goals').insert({ goal_id: goalId, owner_id: 'alice', repository: 'acme/repo', desired_state: 'running',
+    result_state: 'failed', current_task_id: goalTaskId, final_pr_number: 61, failure_reason: 'Provider exhausted its retry budget' });
+
+  const failedGoal = (await get.run({ principal, args: get.schema.parse({ operationId: goalReceipt.operationId }) })).data as Record<string, unknown>;
+  assert.deepEqual(failedGoal.lifecycle, {
+    state: 'failed', acceptedAt: (goalReceipt.lifecycle as { acceptedAt: string }).acceptedAt,
+    startedAt: (failedGoal.lifecycle as { startedAt: string }).startedAt,
+    finishedAt: (failedGoal.lifecycle as { finishedAt: string }).finishedAt,
+    failure: { code: 'EXECUTION_FAILED', message: 'Provider exhausted its retry budget', stage: 'internal', retryable: false, status: 500 },
+    artifacts: { taskId: goalTaskId, pullRequest: { repository: 'acme/repo', number: 61, url: 'https://github.com/acme/repo/pull/61' } },
+    progress: (failedGoal.lifecycle as { progress: unknown }).progress,
+  });
+
+  const submissionId = 'submission-output-1';
+  const taskId = 'ordinary-task-output-1';
+  const taskArgs = { idempotencyKey: 'durable-task-output-1' };
+  const taskReceipt = await operations.run(principal, { tool: 'create_task', args: taskArgs, repository: 'acme/repo' }, async () => ({
+    status: 202, data: { id: submissionId, submissionId, submissionState: 'queued', state: 'queued',
+      continuation: { submissionId, taskId } },
+  }));
+  await db('task_submissions').insert({ id: submissionId, user_id: 'alice', submission_key: 'submission-key', payload_hash: 'hash',
+    repository: 'acme/repo', payload: '{}', attachments: '[]', state: 'queued', task_id: taskId, dispatch_complete: true });
+  await db('tasks').insert({ task_id: taskId, repository: 'acme/repo', task_type: 'issue' });
+  await db('task_history').insert({ task_id: taskId, state: 'completed', reason: 'Task completed successfully' });
+
+  const completedWithoutPr = (await get.run({ principal, args: get.schema.parse({ operationId: taskReceipt.operationId }) })).data as Record<string, unknown>;
+  assert.deepEqual((completedWithoutPr.lifecycle as { artifacts: unknown }).artifacts, { taskId });
+  // Task completion is published before tasks.pr_number, so a later poll must
+  // still enrich the already-terminal durable receipt.
+  await db('tasks').where({ task_id: taskId }).update({ pr_number: 73 });
+  const completedWithPr = (await get.run({ principal, args: get.schema.parse({ operationId: taskReceipt.operationId }) })).data as Record<string, unknown>;
+  assert.deepEqual((completedWithPr.lifecycle as { artifacts: unknown }).artifacts, {
+    taskId, pullRequest: { repository: 'acme/repo', number: 73, url: 'https://github.com/acme/repo/pull/73' },
+  });
+
+  await db('task_history').delete();
+  await db('goals').delete();
+  await db('tasks').delete();
+  await db('task_submissions').delete();
+
+  const durableGoal = (await get.run({ principal, args: get.schema.parse({ operationId: goalReceipt.operationId }) })).data as Record<string, unknown>;
+  assert.deepEqual((durableGoal.lifecycle as { failure: unknown }).failure,
+    { code: 'EXECUTION_FAILED', message: 'Provider exhausted its retry budget', stage: 'internal', retryable: false, status: 500 });
+  assert.deepEqual((durableGoal.lifecycle as { artifacts: unknown }).artifacts,
+    { taskId: goalTaskId, pullRequest: { repository: 'acme/repo', number: 61, url: 'https://github.com/acme/repo/pull/61' } });
+  const durableTask = await operations.replay(principal, 'create_task', taskArgs);
+  assert.deepEqual((durableTask?.lifecycle as { artifacts: unknown }).artifacts,
+    { taskId, pullRequest: { repository: 'acme/repo', number: 73, url: 'https://github.com/acme/repo/pull/73' } });
+  const listed = (await list.run({ principal, args: list.schema.parse({}) })).data as { operations: Array<Record<string, unknown>> };
+  assert.equal(listed.operations.length, 2);
+  assert.ok(listed.operations.every(operation => Object.keys((operation.lifecycle as { artifacts: object }).artifacts).length > 0));
 });
 
 test('list_operations filters active receipts by exact owner and grant without refreshing trackers', async t => {
diff --git a/packages/api/test/mcpTaskSubmissions.test.ts b/packages/api/test/mcpTaskSubmissions.test.ts
index bd5783ca7..dd31ddb91 100644
--- a/packages/api/test/mcpTaskSubmissions.test.ts
+++ b/packages/api/test/mcpTaskSubmissions.test.ts
@@ -43,7 +43,7 @@ async function fixture() {
   await identityMigration(db);
   await db.schema.createTable('tasks', table => {
     table.string('task_id').primary(); table.string('repository'); table.string('task_type');
-    table.string('initial_job_data'); table.timestamp('created_at').defaultTo(db.fn.now());
+    table.integer('pr_number'); table.string('initial_job_data'); table.timestamp('created_at').defaultTo(db.fn.now());
   });
   await db.schema.createTable('task_history', table => {
     table.increments('history_id'); table.string('task_id'); table.string('state');

From 038528ce7ef8ec965061c08a6efdb57918339283 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 04:07:41 +0000
Subject: [PATCH 12/19] feat(ai): Fixed the `Validate Changes` CI failure.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixed the `Validate Changes` CI failure.

Root cause: two API functions exceeded ESLint’s complexity limit by one. I extracted the new normalization logic into focused helpers in:

- [operationLifecycle.ts](/home/node/workspace/packages/api/mcp/operationLifecycle.ts)
- [operationTracking.ts](/home/node/workspace/packages/api/mcp/operationTracking.ts)

The Ubuntu migration message was informational, not the failure.

Validation passed:

- API ESLint with `--max-warnings 0`
- API TypeScript build
- Full MCP suite: 123 tests passed
- `git diff --check`

No visual preview was created because this is an internal refactor with no UI impact.

PR: #2613
Comment by: @propr-dev[bot] (ID: 5883403398)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts | 17 +++++++++++++----
 packages/api/mcp/operationTracking.ts  | 18 +++++++++++++-----
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index 7cde6b876..3b16ffbe3 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -28,6 +28,18 @@ function epochMilliseconds(value: unknown): number | undefined {
   return Number.isNaN(parsed) ? undefined : parsed;
 }
 
+function taskIdFromReceipt(
+  target: Record<string, unknown>,
+  continuation: Record<string, unknown>,
+  result: Record<string, unknown>,
+  targetIssues: Record<string, unknown>[],
+): string | undefined {
+  const currentTask = record(target.currentTask) ?? {};
+  return nonEmptyString(target.taskId, target.task_id, target.current_task_id, currentTask.taskId,
+    currentTask.task_id, continuation.taskId, result.taskId,
+    ...targetIssues.flatMap(issue => [issue.taskId, issue.task_id]));
+}
+
 /** Translate the compatibility state into the persisted public lifecycle. */
 export function lifecycleFromLegacy(state: unknown): LifecycleState {
   if (['running', 'accepted', 'posted', 'queued', 'browser_required'].includes(String(state))) return 'accepted';
@@ -40,14 +52,11 @@ export function artifactsFromReceipt(row: Pick<Operation, 'repository'>, receipt
   const result = record(receipt.result) ?? {};
   const continuation = record(result.continuation) ?? {};
   const target = record(receipt.targetState) ?? {};
-  const currentTask = record(target.currentTask) ?? {};
   const targetIssues: Record<string, unknown>[] = Array.isArray(target.issues)
     ? target.issues.map(record).filter((value): value is Record<string, unknown> => !!value) : [];
   const artifacts: Record<string, unknown> = {};
 
-  const taskId = nonEmptyString(target.taskId, target.task_id, target.current_task_id, currentTask.taskId,
-    currentTask.task_id, continuation.taskId, result.taskId,
-    ...targetIssues.flatMap(issue => [issue.taskId, issue.task_id]));
+  const taskId = taskIdFromReceipt(target, continuation, result, targetIssues);
   if (taskId) artifacts.taskId = taskId;
 
   const repository = nonEmptyString(result.repository, row.repository);
diff --git a/packages/api/mcp/operationTracking.ts b/packages/api/mcp/operationTracking.ts
index 6429f6ad6..bba1c6cba 100644
--- a/packages/api/mcp/operationTracking.ts
+++ b/packages/api/mcp/operationTracking.ts
@@ -69,6 +69,18 @@ export async function trackCancellation(deps: ToolDeps, row: Operation, principa
   await deps.db('mcp_operations').where({ id: row.id }).whereNotIn('state', terminalStates).update({ state: receipt.state, result: JSON.stringify(result), updated_at: Date.now() });
 }
 
+function restoreResolvedTarget(
+  receipt: Record<string, unknown>,
+  result: ExecutionResult,
+  task: TrackingContext['task'] | undefined,
+): void {
+  const persistedTarget = result.targetState ?? {};
+  if (task || Object.keys(persistedTarget).length) receipt.targetState = {
+    ...persistedTarget,
+    ...(task ? { taskId: task.task_id, pr_number: task.pr_number } : {}),
+  };
+}
+
 /** Resolve the execution from the actual job or the exact triggering comment. */
 export async function trackExecution(deps: ToolDeps, row: Operation, principal: McpPrincipal, receipt: Record<string, unknown>): Promise<void> {
   if (!trackedTools.includes(row.tool) || !row.result) return;
@@ -78,11 +90,7 @@ export async function trackExecution(deps: ToolDeps, row: Operation, principal:
   if (result.error) return;
   const task = row.tool === 'index_repository' ? undefined : await findExecutionTask(deps, row, result);
   if (result.executionResolved && terminalStates.includes(row.state)) {
-    const persistedTarget = result.targetState ?? {};
-    if (task || Object.keys(persistedTarget).length) receipt.targetState = {
-      ...persistedTarget,
-      ...(task ? { taskId: task.task_id, pr_number: task.pr_number } : {}),
-    };
+    restoreResolvedTarget(receipt, result, task);
     return;
   }
   if (task) await trackTask(deps, row, { task, result, receipt });

From 4838782f3f469914fac0be4537f9ed7ede6c1630 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 04:12:09 +0000
Subject: [PATCH 13/19] feat(ai): Implemented the follow-up lint fixes:

Implemented the follow-up lint fixes:

- Extracted receipt issue-number collection in [operationLifecycle.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T04-09-20/packages/api/mcp/operationLifecycle.ts).
- Extracted pull-request context refresh in [operationTracking.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T04-09-20/packages/api/mcp/operationTracking.ts).
- Preserved existing lifecycle and receipt behavior.

Validation passed:

- API lint with zero warnings
- API TypeScript typecheck
- 15/15 focused MCP operation tests
- `git diff --check`

No visual preview was generated because this is a backend-only refactor.

PR: #2613
Comment by: @github-actions[bot] (ID: 5883403478)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts | 39 +++++++++++++++++---------
 packages/api/mcp/operationTracking.ts  | 24 ++++++++++++----
 2 files changed, 43 insertions(+), 20 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index 3b16ffbe3..d54c6a30e 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -40,6 +40,29 @@ function taskIdFromReceipt(
     ...targetIssues.flatMap(issue => [issue.taskId, issue.task_id]));
 }
 
+function issueNumbersFromReceipt(
+  result: Record<string, unknown>,
+  continuation: Record<string, unknown>,
+  target: Record<string, unknown>,
+  targetIssues: Record<string, unknown>[],
+): number[] {
+  const issueNumbers = new Set<number>();
+  for (const value of [result.issueNumber, result.issue_number, continuation.issueNumber, target.issueNumber, target.issue_number]) {
+    const number = positiveInteger(value);
+    if (number) issueNumbers.add(number);
+  }
+  if (Array.isArray(result.issues)) for (const value of result.issues) {
+    const issue = record(value);
+    const number = positiveInteger(issue?.number, issue?.issueNumber, value);
+    if (number) issueNumbers.add(number);
+  }
+  for (const issue of targetIssues) {
+    const number = positiveInteger(issue.number, issue.issueNumber, issue.issue_number);
+    if (number) issueNumbers.add(number);
+  }
+  return [...issueNumbers];
+}
+
 /** Translate the compatibility state into the persisted public lifecycle. */
 export function lifecycleFromLegacy(state: unknown): LifecycleState {
   if (['running', 'accepted', 'posted', 'queued', 'browser_required'].includes(String(state))) return 'accepted';
@@ -72,20 +95,8 @@ export function artifactsFromReceipt(row: Pick<Operation, 'repository'>, receipt
     url: `https://github.com/${repository}/pull/${pullRequestNumber}`,
   };
 
-  const issueNumbers = new Set<number>();
-  for (const value of [result.issueNumber, result.issue_number, continuation.issueNumber, target.issueNumber, target.issue_number]) {
-    const number = positiveInteger(value);
-    if (number) issueNumbers.add(number);
-  }
-  if (Array.isArray(result.issues)) for (const value of result.issues) {
-    const number = positiveInteger(record(value)?.number, record(value)?.issueNumber, value);
-    if (number) issueNumbers.add(number);
-  }
-  for (const issue of targetIssues) {
-    const number = positiveInteger(issue.number, issue.issueNumber, issue.issue_number);
-    if (number) issueNumbers.add(number);
-  }
-  if (repository && issueNumbers.size) artifacts.issues = [...issueNumbers].map(number => ({
+  const issueNumbers = issueNumbersFromReceipt(result, continuation, target, targetIssues);
+  if (repository && issueNumbers.length) artifacts.issues = issueNumbers.map(number => ({
     repository,
     number,
     url: `https://github.com/${repository}/issues/${number}`,
diff --git a/packages/api/mcp/operationTracking.ts b/packages/api/mcp/operationTracking.ts
index bba1c6cba..8466c6f22 100644
--- a/packages/api/mcp/operationTracking.ts
+++ b/packages/api/mcp/operationTracking.ts
@@ -81,6 +81,23 @@ function restoreResolvedTarget(
   };
 }
 
+async function refreshPullRequestContext(
+  row: Operation,
+  principal: McpPrincipal,
+  result: ExecutionResult & Record<string, unknown>,
+): Promise<void> {
+  if (!result.pullRequest) return;
+  const [owner, repo] = String(row.repository).split('/');
+  const { data: pr } = await principal.github.request('GET /repos/{owner}/{repo}/pulls/{pull_number}', {
+    owner, repo, pull_number: result.pullRequest,
+  });
+  result.currentHead = pr.head.sha;
+  result.results = {
+    tool: 'get_pull_request_discussion', repository: row.repository,
+    pullRequest: result.pullRequest, taskId: result.continuation?.taskId,
+  };
+}
+
 /** Resolve the execution from the actual job or the exact triggering comment. */
 export async function trackExecution(deps: ToolDeps, row: Operation, principal: McpPrincipal, receipt: Record<string, unknown>): Promise<void> {
   if (!trackedTools.includes(row.tool) || !row.result) return;
@@ -96,12 +113,7 @@ export async function trackExecution(deps: ToolDeps, row: Operation, principal:
   if (task) await trackTask(deps, row, { task, result, receipt });
   else if (result.jobId) await trackQueuedJob(row, result.jobId, receipt);
   else if (Date.now() - Number(row.created_at) > 120000) receipt.state = 'unknown';
-  if (result.pullRequest) {
-    const [owner, repo] = String(row.repository).split('/');
-    const { data: pr } = await principal.github.request('GET /repos/{owner}/{repo}/pulls/{pull_number}', { owner, repo, pull_number: result.pullRequest });
-    result.currentHead = pr.head.sha;
-    result.results = { tool: 'get_pull_request_discussion', repository: row.repository, pullRequest: result.pullRequest, taskId: result.continuation?.taskId };
-  }
+  await refreshPullRequestContext(row, principal, result);
   if (terminalStates.includes(String(receipt.state))) {
     result.executionResolved = true;
     result.targetState = receipt.targetState as Record<string, unknown> | undefined;

From 0402f20441d8f4fea4b93ad1422b1159cbed482b Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 04:32:54 +0000
Subject: [PATCH 14/19] feat(ai): Implemented F15 only.

Implemented F15 only.

- Recovery now promotes persisted `result.targetState` into the reconciliation receipt.
- Missing failure, PR/task artifacts, and progress are restored without overwriting newer progress.
- Added regression coverage using a real tracker-shaped terminal write, followed by listing and idempotency replay without live refresh.

Changed:

- [operations.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T04-26-15/packages/api/mcp/operations.ts)
- [mcpOperations.test.ts](/tmp/git-processor/worktrees/integry/propr/pr-2613-followup-2026-09-29T04-26-15/packages/api/test/mcpOperations.test.ts)

Validation passed:

- API typecheck
- Focused operation tests: 15/15
- Full MCP suite: 123/123
- ESLint and diff checks

No independent discoveries or visual changes.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operations.ts          | 19 ++++++++-
 packages/api/test/mcpOperations.test.ts | 53 ++++++++++++++++++++-----
 2 files changed, 60 insertions(+), 12 deletions(-)

diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index f57d71cb8..79fa19d78 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -29,6 +29,16 @@ function json(value: unknown): unknown {
   try { return JSON.parse(value); } catch { return null; }
 }
 
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function recoveryReceipt(row: Pick<Operation, 'state' | 'result'>) {
+  const result = json(row.result);
+  const targetState = record(record(result)?.targetState);
+  return { state: row.state, result, ...(targetState ? { targetState } : {}) };
+}
+
 function iso(value: number | null | undefined): string | null {
   if (value === null || value === undefined) return null;
   const date = new Date(Number(value));
@@ -134,7 +144,8 @@ export class McpOperations {
     if (id) query.andWhere({ id });
     const rows = await query.select<Operation[]>();
     for (const row of rows) {
-      const receipt = { state: row.state, result: json(row.result) };
+      const receipt = recoveryReceipt(row);
+      const targetState = receipt.targetState;
       const artifacts = artifactsFromReceipt(row, receipt);
       const storedArtifacts = json(row.artifacts);
       const artifactRecord = storedArtifacts && typeof storedArtifacts === 'object' && !Array.isArray(storedArtifacts)
@@ -143,7 +154,8 @@ export class McpOperations {
         .filter(([key, value]) => canonical(artifactRecord[key]) !== canonical(value)));
       const failure = row.state === 'failed' ? failureFromReceipt(receipt) : undefined;
       const lifecycleMissing = ['accepted', 'running', 'unknown'].includes(row.lifecycle) || row.finished_at === null;
-      if (!lifecycleMissing && !Object.keys(missingArtifacts).length && !(failure && row.failure === null)) continue;
+      const progressMissing = row.progress === null && targetState !== undefined;
+      if (!lifecycleMissing && !Object.keys(missingArtifacts).length && !(failure && row.failure === null) && !progressMissing) continue;
 
       const update: Record<string, unknown> = { updated_at: Date.now() };
       if (lifecycleMissing) {
@@ -158,6 +170,9 @@ export class McpOperations {
       if (failure && row.failure === null) {
         update.failure = this.db.raw('COALESCE(failure, ?)', [JSON.stringify(failure)]);
       }
+      if (progressMissing) {
+        update.progress = this.db.raw('COALESCE(progress, ?)', [JSON.stringify(targetState)]);
+      }
 
       // Do not attach metadata derived from a receipt that changed after the
       // read. A later reconciliation will use the newer durable evidence.
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index fbbeb778e..f9bc09cc3 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -15,6 +15,7 @@ import { parseClientMetadataDocument } from '../mcp/clients.js';
 import { createToolCatalog, type ToolDeps } from '../mcp/tools.js';
 import type { McpPrincipal } from '../mcp/policy.js';
 import { artifactsFromReceipt, failureFromReceipt, syncLifecycle } from '../mcp/operationLifecycle.js';
+import { trackExecution } from '../mcp/operationTracking.js';
 
 after(closeConnection);
 
@@ -170,29 +171,49 @@ test('list_operations recovers terminal lifecycle, artifacts and failure before
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await db.schema.createTable('tasks', table => {
+    table.string('task_id').primary(); table.string('job_id'); table.string('repository'); table.string('task_type');
+    table.integer('pr_number'); table.text('initial_job_data'); table.timestamp('created_at').defaultTo(db.fn.now());
+  });
+  await db.schema.createTable('task_history', table => {
+    table.increments('history_id').primary(); table.string('task_id'); table.string('state');
+    table.timestamp('timestamp'); table.text('reason'); table.text('metadata');
+  });
   await up(db); await lifecycleUp(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const operations = new McpOperations(db);
   const receipt = await operations.run(principal, {
     tool: 'send_task_followup', args: { idempotencyKey: 'tracker-interrupt-1' }, repository: 'acme/repo',
   }, async () => ({ status: 202, data: { state: 'queued' } }));
+  const failedArgs = { idempotencyKey: 'tracker-failure-02' };
   const failed = await operations.run(principal, {
-    tool: 'send_task_followup', args: { idempotencyKey: 'tracker-failure-02' }, repository: 'acme/repo',
-  }, async () => ({ status: 202, data: { state: 'queued' } }));
+    tool: 'send_task_followup', args: failedArgs, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued', jobId: 'job-failed', continuation: { taskId: 'task-failed' } } }));
   const persistedAt = Date.now() - 500;
-  // This is the tracker write immediately before get_operation would normally
-  // call syncLifecycle; a stopped process leaves exactly this durable row.
+  // Keep coverage for a legacy terminal receipt whose identifiers are directly
+  // in the result alongside the tracker-shaped receipt below.
   await db('mcp_operations').where({ id: receipt.operationId }).update({
     state: 'completed', result: JSON.stringify({ state: 'queued', continuation: { taskId: 'task-1' }, executionResolved: true }),
     updated_at: persistedAt,
   });
-  const failure = { code: 'TASK_FAILED', message: 'Task execution failed.', stage: 'internal', retryable: false, status: 500 };
-  await db('mcp_operations').where({ id: failed.operationId }).update({
-    state: 'failed', result: JSON.stringify({ error: failure }), updated_at: persistedAt,
-  });
-
   const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
     taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const observedAt = '2026-09-29T03:00:00.000Z';
+  await db('tasks').insert({ task_id: 'task-failed', job_id: 'job-failed', repository: 'acme/repo', task_type: 'issue', pr_number: 73 });
+  await db('task_history').insert({ task_id: 'task-failed', state: 'failed', timestamp: observedAt, reason: 'Agent stopped after tests failed.' });
+  const failedRow = await db<Operation>('mcp_operations').where({ id: failed.operationId }).first();
+  // Stop immediately after the awaited tracker write, before syncLifecycle can
+  // project its nested targetState into lifecycle columns.
+  await trackExecution(deps, failedRow!, principal, operations.project(failedRow!));
+  const trackerWrite = await db<Operation>('mcp_operations').where({ id: failed.operationId }).first();
+  assert.equal(trackerWrite?.state, 'failed');
+  assert.equal(trackerWrite?.lifecycle, 'accepted');
+  assert.equal(trackerWrite?.failure, null);
+  assert.equal(trackerWrite?.progress, null);
+  assert.deepEqual(JSON.parse(trackerWrite!.result!).targetState, {
+    taskId: 'task-failed', pr_number: 73, state: 'failed', timestamp: observedAt, reason: 'Agent stopped after tests failed.',
+  });
+
   const list = createToolCatalog(deps).find(tool => tool.name === 'list_operations')!;
   const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: Array<Record<string, unknown>> };
   const completed = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'completed' }) })).data as { operations: Array<Record<string, unknown>> };
@@ -203,7 +224,19 @@ test('list_operations recovers terminal lifecycle, artifacts and failure before
   assert.equal((completed.operations[0].lifecycle as { finishedAt: string }).finishedAt, new Date(persistedAt).toISOString());
   assert.deepEqual((completed.operations[0].lifecycle as { artifacts: unknown }).artifacts, { taskId: 'task-1' });
   assert.deepEqual(failures.operations.map(row => row.operationId), [failed.operationId]);
-  assert.deepEqual((failures.operations[0].lifecycle as { failure: unknown }).failure, failure);
+  const recoveredLifecycle = failures.operations[0].lifecycle as Record<string, unknown>;
+  assert.deepEqual(recoveredLifecycle.failure, {
+    code: 'EXECUTION_FAILED', message: 'Agent stopped after tests failed.', stage: 'internal', retryable: false, status: 500,
+  });
+  assert.deepEqual(recoveredLifecycle.artifacts, {
+    taskId: 'task-failed',
+    pullRequest: { repository: 'acme/repo', number: 73, url: 'https://github.com/acme/repo/pull/73' },
+  });
+  assert.deepEqual(recoveredLifecycle.progress, {
+    taskId: 'task-failed', pr_number: 73, state: 'failed', timestamp: observedAt, reason: 'Agent stopped after tests failed.',
+  });
+  const replay = await operations.replay(principal, 'send_task_followup', failedArgs);
+  assert.deepEqual(replay?.lifecycle, recoveredLifecycle);
   assert.deepEqual(await db('mcp_operations').where({ id: receipt.operationId }).first('state', 'lifecycle', 'finished_at'), {
     state: 'completed', lifecycle: 'completed', finished_at: persistedAt,
   });

From ba281cdbf63000e94077f9ca2214f247253eae2e Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 04:54:37 +0000
Subject: [PATCH 15/19] feat(ai): Implemented F16 only.

Implemented F16 only.

- Terminal reconciliation now reapplies durable confirmed cancellation receipts to their source operations.
- Source updates are owner/grant-scoped, revalidate persisted evidence, preserve terminal outcomes, and use the confirmation timestamp.
- Added regressions for interrupted tracker writes followed by replay and listing, plus grant isolation and terminal guards.
- Updated live synchronization to use the same guarded propagation path.

Validation:

- Full MCP suite: 124 tests passed.
- API TypeScript check passed.
- Focused ESLint passed.
- `git diff --check` passed.
- No visual preview generated; this is backend-only.
- No independent findings.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts  |  2 +-
 packages/api/mcp/operations.ts          | 32 +++++++++++
 packages/api/test/mcpOperations.test.ts | 72 ++++++++++++++++++++++++-
 3 files changed, 104 insertions(+), 2 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index d54c6a30e..e2187a598 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -165,7 +165,7 @@ async function syncCancellation(
   if (row.tool !== 'cancel_operation') return;
   const result = record(receipt.result);
   const sourceId = nonEmptyString(result?.operationId);
-  if (sourceId && result?.cancellation === 'confirmed') await operations.finish(sourceId, 'cancelled');
+  if (sourceId && result?.cancellation === 'confirmed') await operations.finishCancellationSource(row, sourceId);
 }
 
 function observedStartTimestamp(
diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index 79fa19d78..ec2a4ab78 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -39,6 +39,12 @@ function recoveryReceipt(row: Pick<Operation, 'state' | 'result'>) {
   return { state: row.state, result, ...(targetState ? { targetState } : {}) };
 }
 
+function confirmedCancellationSource(row: Pick<Operation, 'tool'>, receipt: ReturnType<typeof recoveryReceipt>): string | undefined {
+  const result = record(receipt.result);
+  return row.tool === 'cancel_operation' && result?.cancellation === 'confirmed'
+    && typeof result.operationId === 'string' && result.operationId.length > 0 ? result.operationId : undefined;
+}
+
 function iso(value: number | null | undefined): string | null {
   if (value === null || value === undefined) return null;
   const date = new Date(Number(value));
@@ -145,6 +151,8 @@ export class McpOperations {
     const rows = await query.select<Operation[]>();
     for (const row of rows) {
       const receipt = recoveryReceipt(row);
+      const cancellationSourceId = confirmedCancellationSource(row, receipt);
+      await this.finishCancellationSource(row, cancellationSourceId);
       const targetState = receipt.targetState;
       const artifacts = artifactsFromReceipt(row, receipt);
       const storedArtifacts = json(row.artifacts);
@@ -243,6 +251,30 @@ export class McpOperations {
     });
   }
 
+  /** Apply durable cancellation evidence only to the receipt owner's source operation. */
+  async finishCancellationSource(
+    cancellation: Pick<Operation, 'id' | 'owner_id' | 'grant_id'>,
+    sourceId: string | undefined,
+  ): Promise<void> {
+    if (!sourceId) return;
+    const durable = await this.db<Operation>('mcp_operations').where({
+      id: cancellation.id, owner_id: cancellation.owner_id, grant_id: cancellation.grant_id, tool: 'cancel_operation',
+    }).whereIn('state', ['completed', 'failed', 'cancelled']).first('result', 'updated_at');
+    const result = record(json(durable?.result));
+    if (result?.cancellation !== 'confirmed' || result.operationId !== sourceId) return;
+
+    const now = Date.now();
+    const confirmedAt = Number(durable?.updated_at);
+    await this.db('mcp_operations').where({
+      id: sourceId, owner_id: cancellation.owner_id, grant_id: cancellation.grant_id,
+    }).whereIn('lifecycle', ['accepted', 'running', 'unknown']).update({
+      lifecycle: 'cancelled',
+      finished_at: this.db.raw('COALESCE(finished_at, ?)', [Number.isFinite(confirmedAt) ? confirmedAt : now]),
+      failure: null,
+      updated_at: now,
+    });
+  }
+
   project(row: Operation): Record<string, unknown> {
     const interrupted = invocationInterrupted(row);
     const stale = interrupted || (row.state === 'running' && Date.now() - Number(row.updated_at) > interruptionTimeoutMs);
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index f9bc09cc3..0be5c3c9f 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -15,7 +15,7 @@ import { parseClientMetadataDocument } from '../mcp/clients.js';
 import { createToolCatalog, type ToolDeps } from '../mcp/tools.js';
 import type { McpPrincipal } from '../mcp/policy.js';
 import { artifactsFromReceipt, failureFromReceipt, syncLifecycle } from '../mcp/operationLifecycle.js';
-import { trackExecution } from '../mcp/operationTracking.js';
+import { trackCancellation, trackExecution } from '../mcp/operationTracking.js';
 
 after(closeConnection);
 
@@ -242,6 +242,76 @@ test('list_operations recovers terminal lifecycle, artifacts and failure before
   });
 });
 
+test('replay and listing recover confirmed cancellation propagation after the tracker write', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await db.schema.createTable('tasks', table => {
+    table.string('task_id').primary(); table.string('repository'); table.string('task_type');
+  });
+  await db.schema.createTable('goals', table => {
+    table.string('goal_id').primary(); table.string('current_task_id');
+  });
+  await db.schema.createTable('task_history', table => {
+    table.increments('history_id').primary(); table.string('task_id'); table.string('state'); table.timestamp('timestamp');
+  });
+  await up(db); await lifecycleUp(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const otherGrant = { user: { id: 'alice' }, grant: { id: 'grant-b' } } as McpPrincipal;
+  const operations = new McpOperations(db);
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const createInterruptedConfirmation = async (suffix: string) => {
+    const taskId = `cancel-task-${suffix}`;
+    const source = await operations.run(principal, {
+      tool: 'review_pull_request', args: { idempotencyKey: `cancel-source-${suffix}` }, repository: 'acme/repo',
+    }, async () => ({ status: 202, data: { state: 'queued', continuation: { taskId } } }));
+    const args = { idempotencyKey: `cancel-receipt-${suffix}` };
+    const cancellation = await operations.run(principal, { tool: 'cancel_operation', args, repository: 'acme/repo' }, async () => ({
+      status: 202, data: { operationId: source.operationId, cancellation: 'requested', continuation: { taskId }, targetTool: 'review_pull_request' },
+    }));
+    await db('tasks').insert({ task_id: taskId, repository: 'acme/repo', task_type: 'issue' });
+    await db('task_history').insert({ task_id: taskId, state: 'cancelled', timestamp: new Date() });
+    const row = (await db<Operation>('mcp_operations').where({ id: cancellation.operationId }).first())!;
+    await trackCancellation(deps, row, principal, operations.project(row));
+    const persisted = (await db<Operation>('mcp_operations').where({ id: cancellation.operationId }).first())!;
+    assert.equal(persisted.state, 'completed');
+    assert.equal(persisted.lifecycle, 'accepted');
+    assert.equal((await db<Operation>('mcp_operations').where({ id: source.operationId }).first())!.lifecycle, 'accepted');
+    return { args, cancellation, persisted, source };
+  };
+
+  const replayCase = await createInterruptedConfirmation('replay-01');
+  const replayed = await operations.replay(principal, 'cancel_operation', replayCase.args);
+  assert.equal((replayed?.lifecycle as { state: string }).state, 'completed');
+  const replayedSource = (await db<Operation>('mcp_operations').where({ id: replayCase.source.operationId }).first())!;
+  assert.equal(replayedSource.lifecycle, 'cancelled');
+  assert.equal(replayedSource.finished_at, replayCase.persisted.updated_at);
+
+  const listCase = await createInterruptedConfirmation('listing-1');
+  const foreignSource = await operations.run(otherGrant, {
+    tool: 'review_pull_request', args: { idempotencyKey: 'foreign-cancel-source' }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued' } }));
+  await operations.run(principal, {
+    tool: 'cancel_operation', args: { idempotencyKey: 'foreign-cancel-proof' },
+  }, async () => ({ status: 200, data: { operationId: foreignSource.operationId, cancellation: 'confirmed', executionResolved: true } }));
+  const completedSource = await operations.run(principal, {
+    tool: 'review_pull_request', args: { idempotencyKey: 'completed-cancel-source' }, repository: 'acme/repo',
+  }, async () => ({ status: 200, data: { changed: true } }));
+  await operations.run(principal, {
+    tool: 'cancel_operation', args: { idempotencyKey: 'completed-cancel-proof' }, repository: 'acme/repo',
+  }, async () => ({ status: 200, data: { operationId: completedSource.operationId, cancellation: 'confirmed', executionResolved: true } }));
+
+  const list = createToolCatalog(deps).find(tool => tool.name === 'list_operations')!;
+  const listed = (await list.run({ principal, args: list.schema.parse({}) })).data as { operations: Array<Record<string, unknown>> };
+  assert.ok(listed.operations.some(row => row.operationId === listCase.cancellation.operationId));
+  const listedSource = (await db<Operation>('mcp_operations').where({ id: listCase.source.operationId }).first())!;
+  assert.equal(listedSource.lifecycle, 'cancelled');
+  assert.equal(listedSource.finished_at, listCase.persisted.updated_at);
+  assert.equal((await db<Operation>('mcp_operations').where({ id: foreignSource.operationId }).first())!.lifecycle, 'accepted');
+  assert.equal((await db<Operation>('mcp_operations').where({ id: completedSource.operationId }).first())!.lifecycle, 'completed');
+});
+
 test('polling an accepted wrapper does not fabricate backend execution start', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());

From be834ee579b68872a2037a824b9899a6be4728d3 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 05:17:07 +0000
Subject: [PATCH 16/19] feat(ai): Implemented F17.

Implemented F17.

- Terminal progress and lifecycle now persist atomically.
- Stale nonterminal tracker and delayed invocation writes cannot replace terminal receipts.
- Stale callers reload the winning durable terminal observation.
- Added regressions covering the GitHub-await ordering, delayed invocation results, history pruning, replay, and listing.
- No visual preview was needed because the change is backend-only.

Validation:

- Focused operations suite: 18 passed
- Full MCP suite: 125 passed
- API typecheck: passed
- API lint: passed
- `git diff --check`: passed

Independent discovery, left unchanged as out of scope: the pre-existing task-submission tracker has a similar unconditional write after an await in `toolsTaskSubmissions.ts`; it was not introduced or modified by this PR.

PR: #2613
Comment by: @propr-ultrafix (ID: 0)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts  |  11 ++-
 packages/api/mcp/operationTracking.ts   |  17 +++-
 packages/api/mcp/operations.ts          |  24 ++++--
 packages/api/test/mcpOperations.test.ts | 109 ++++++++++++++++++++++++
 4 files changed, 150 insertions(+), 11 deletions(-)

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index e2187a598..f2c4d19bc 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -192,17 +192,20 @@ export async function syncLifecycle(
   if (Object.keys(artifacts).length) await operations.recordArtifacts(row.id, artifacts);
 
   const target = record(receipt.targetState);
-  if (target) await operations.recordProgress(row.id, target);
-
   const targetState = String(target?.state ?? '');
   const receiptState = String(receipt.state ?? '');
   const result = record(receipt.result);
+  const outcome = lifecycleOutcome(row, target, receiptState, targetState);
+  if (target && !outcome) await operations.recordProgress(row.id, target);
+
   const startedAt = observedStartTimestamp(target, result, targetState);
   if (startedAt !== null) await operations.markStarted(row.id, startedAt);
 
-  const outcome = lifecycleOutcome(row, target, receiptState, targetState);
   if (outcome) {
-    await operations.finish(row.id, outcome, outcome === 'failed' ? failureFromReceipt(receipt) : undefined);
+    // Persist the terminal snapshot in the same guarded update as the outcome.
+    // This closes the window where an older nonterminal poll could otherwise
+    // replace terminal progress between two lifecycle writes.
+    await operations.finish(row.id, outcome, outcome === 'failed' ? failureFromReceipt(receipt) : undefined, target);
   } else if (receiptState === 'unknown') {
     await operations.markUnknown(row.id);
   } else if (receiptState === 'queued' && target) {
diff --git a/packages/api/mcp/operationTracking.ts b/packages/api/mcp/operationTracking.ts
index 8466c6f22..88007a53d 100644
--- a/packages/api/mcp/operationTracking.ts
+++ b/packages/api/mcp/operationTracking.ts
@@ -120,7 +120,22 @@ export async function trackExecution(deps: ToolDeps, row: Operation, principal:
   }
   receipt.result = result;
   if (receipt.state === 'unknown') receipt.message = 'Execution cannot yet be confirmed. Inspect the linked comment/job; polling can still resolve it. Do not blindly resubmit.';
-  await db('mcp_operations').where({ id: row.id }).update({ state: receipt.state, result: JSON.stringify(result), updated_at: Date.now() });
+  const recorded = await db('mcp_operations').where({ id: row.id }).whereNotIn('state', terminalStates)
+    .update({ state: receipt.state, result: JSON.stringify(result), updated_at: Date.now() });
+  if (!recorded) {
+    // Another poll persisted terminal evidence while this observation was
+    // awaiting external context. Return that durable receipt and let lifecycle
+    // synchronization use its terminal target instead of this stale snapshot.
+    const current = await db<Operation>('mcp_operations').where({ id: row.id }).first();
+    if (current && terminalStates.includes(current.state)) {
+      const currentResult = current.result ? JSON.parse(current.result) as ExecutionResult & Record<string, unknown> : {};
+      receipt.state = current.state;
+      receipt.result = currentResult;
+      if (currentResult.targetState) receipt.targetState = currentResult.targetState;
+      else delete receipt.targetState;
+      delete receipt.message;
+    }
+  }
 }
 
 interface ExecutionResult {
diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index ec2a4ab78..0ce039d5b 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -106,7 +106,9 @@ export class McpOperations {
     try {
       const result = await invoke(id);
       const state = operationState(result);
-      await this.db('mcp_operations').where({ id }).update({ state, result: JSON.stringify(result.data), updated_at: Date.now() });
+      const recorded = await this.db('mcp_operations').where({ id }).whereNotIn('state', ['completed', 'failed', 'cancelled'])
+        .update({ state, result: JSON.stringify(result.data), updated_at: Date.now() });
+      if (!recorded) return this.project((await this.db<Operation>('mcp_operations').where({ id }).first())!);
       const receipt = { state, result: result.data };
       await this.recordArtifacts(id, artifactsFromReceipt({ repository: repository || null }, receipt));
       const lifecycle = lifecycleFromLegacy(state);
@@ -127,7 +129,9 @@ export class McpOperations {
       // automatically or claim it was rolled back. The handle remains durable.
       const envelope = classifyError(error, { sideEffectsPossible: true });
       const state = envelope.code === 'OUTCOME_UNKNOWN' ? 'unknown' : 'failed';
-      await this.db('mcp_operations').where({ id }).update({ state, result: JSON.stringify({ error: envelope }), updated_at: Date.now() });
+      const recorded = await this.db('mcp_operations').where({ id }).whereNotIn('state', ['completed', 'failed', 'cancelled'])
+        .update({ state, result: JSON.stringify({ error: envelope }), updated_at: Date.now() });
+      if (!recorded) return this.project((await this.db<Operation>('mcp_operations').where({ id }).first())!);
       if (state === 'failed') await this.finish(id, 'failed', envelope);
       else await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'unknown'])
         .update({ lifecycle: 'unknown', failure: JSON.stringify(envelope), updated_at: Date.now() });
@@ -234,21 +238,29 @@ export class McpOperations {
   }
 
   async recordProgress(id: string, progress: unknown): Promise<void> {
-    await this.db('mcp_operations').where({ id }).update({ progress: JSON.stringify(progress), updated_at: Date.now() });
+    await this.db('mcp_operations').where({ id })
+      .whereIn('lifecycle', ['accepted', 'running', 'unknown'])
+      .whereNotIn('state', ['completed', 'failed', 'cancelled'])
+      .update({ progress: JSON.stringify(progress), updated_at: Date.now() });
   }
 
-  async finish(id: string, outcome: LifecycleOutcome, failure?: McpErrorEnvelope): Promise<void> {
+  async finish(id: string, outcome: LifecycleOutcome, failure?: McpErrorEnvelope, progress?: unknown): Promise<void> {
     const at = Date.now();
     const eligible = this.db('mcp_operations').where({ id }).andWhere(builder => {
       builder.whereIn('lifecycle', ['accepted', 'running', 'unknown']);
       if (outcome === 'failed' && failure) builder.orWhere(nested => nested.where({ lifecycle: 'failed' }).whereNull('failure'));
     });
-    await eligible.update({
+    const update: Record<string, unknown> = {
       lifecycle: outcome,
       finished_at: this.db.raw('COALESCE(finished_at, ?)', [at]),
       failure: failure ? this.db.raw('COALESCE(failure, ?)', [JSON.stringify(failure)]) : null,
       updated_at: at,
-    });
+    };
+    if (progress !== undefined) update.progress = this.db.raw(`CASE
+      WHEN lifecycle IN ('accepted', 'running', 'unknown') THEN ?
+      ELSE COALESCE(progress, ?)
+    END`, [JSON.stringify(progress), JSON.stringify(progress)]);
+    await eligible.update(update);
   }
 
   /** Apply durable cancellation evidence only to the receipt owner's source operation. */
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 0be5c3c9f..87cd3dde7 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -115,6 +115,115 @@ test('operation lifecycle transitions, artifacts and progress are durable and mo
   assert.equal((projected.lifecycle as { failure: unknown }).failure, null);
 });
 
+test('a delayed invocation result cannot replace terminal evidence persisted by a poll', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await up(db); await lifecycleUp(db);
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  let invocationStarted!: () => void;
+  let finishInvocation!: (result: { status: number; data: unknown }) => void;
+  const started = new Promise<void>(resolve => { invocationStarted = resolve; });
+  const pending = operations.run(principal, {
+    tool: 'review_pull_request', args: { idempotencyKey: 'late-invocation-result' }, repository: 'acme/repo',
+  }, async () => {
+    invocationStarted();
+    return new Promise(resolve => { finishInvocation = resolve; });
+  });
+  await started;
+
+  const row = (await db<Operation>('mcp_operations').where({ idempotency_key: 'late-invocation-result' }).first())!;
+  const targetState = { taskId: 'review-task', state: 'completed', timestamp: '2026-09-29T04:01:00.000Z' };
+  await db('mcp_operations').where({ id: row.id }).update({
+    state: 'completed', result: JSON.stringify({ executionResolved: true, targetState }), updated_at: Date.now(),
+  });
+  await operations.finish(row.id, 'completed', undefined, targetState);
+  finishInvocation({ status: 202, data: { state: 'queued', pullRequest: 42 } });
+
+  const completed = await pending;
+  assert.equal(completed.state, 'completed');
+  assert.deepEqual(completed.result, { executionResolved: true, targetState });
+  assert.deepEqual((completed.lifecycle as { progress: unknown }).progress, targetState);
+});
+
+test('stale concurrent polls cannot replace terminal tracker receipts or lifecycle progress', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await db.schema.createTable('tasks', table => {
+    table.string('task_id').primary(); table.string('repository'); table.string('task_type');
+    table.integer('issue_number'); table.integer('pr_number'); table.text('initial_job_data');
+    table.timestamp('created_at').defaultTo(db.fn.now());
+  });
+  await db.schema.createTable('task_history', table => {
+    table.increments('history_id').primary(); table.string('task_id'); table.string('state');
+    table.timestamp('timestamp'); table.text('reason'); table.text('metadata');
+  });
+  await up(db); await lifecycleUp(db);
+
+  const operations = new McpOperations(db);
+  const args = { idempotencyKey: 'stale-terminal-poll-1' };
+  let releaseStale!: () => void;
+  let staleReachedRefresh!: () => void;
+  const release = new Promise<void>(resolve => { releaseStale = resolve; });
+  const reachedRefresh = new Promise<void>(resolve => { staleReachedRefresh = resolve; });
+  let githubRequests = 0;
+  const principal = {
+    user: { id: 'alice' }, grant: { id: 'grant-a' }, github: { request: async () => {
+      githubRequests++;
+      if (githubRequests === 1) { staleReachedRefresh(); await release; }
+      return { data: { head: { sha: `head-${githubRequests}` } } };
+    } },
+  } as unknown as McpPrincipal;
+  const receipt = await operations.run(principal, { tool: 'review_pull_request', args, repository: 'acme/repo' }, async () => ({
+    status: 202, data: { state: 'queued', pullRequest: 42, commentId: 99 },
+  }));
+  await db('tasks').insert({ task_id: 'review-task', repository: 'acme/repo', task_type: 'issue', issue_number: 42,
+    initial_job_data: JSON.stringify({ commandCommentId: 99, commandMode: 'review' }) });
+  await db('task_history').insert({ task_id: 'review-task', state: 'processing',
+    timestamp: '2026-09-29T04:00:00.000Z', reason: 'Review is running' });
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+
+  const staleRow = (await db<Operation>('mcp_operations').where({ id: receipt.operationId }).first())!;
+  const staleReceipt = operations.project(staleRow);
+  const stalePoll = trackExecution(deps, staleRow, principal, staleReceipt);
+  await reachedRefresh;
+
+  const terminalAt = '2026-09-29T04:01:00.000Z';
+  await db('task_history').insert({ task_id: 'review-task', state: 'completed', timestamp: terminalAt,
+    reason: 'Review processing completed successfully' });
+  const terminalRow = (await db<Operation>('mcp_operations').where({ id: receipt.operationId }).first())!;
+  const terminalReceipt = operations.project(terminalRow);
+  await trackExecution(deps, terminalRow, principal, terminalReceipt);
+  await syncLifecycle(operations, terminalRow, terminalReceipt);
+
+  releaseStale();
+  await stalePoll;
+  await syncLifecycle(operations, staleRow, staleReceipt);
+
+  const durable = (await db<Operation>('mcp_operations').where({ id: receipt.operationId }).first())!;
+  const durableResult = JSON.parse(durable.result!);
+  assert.equal(durable.state, 'completed');
+  assert.equal(durable.lifecycle, 'completed');
+  assert.equal(durableResult.executionResolved, true);
+  assert.equal(durableResult.targetState.state, 'completed');
+  assert.equal(durableResult.targetState.reason, 'Review processing completed successfully');
+  assert.deepEqual(JSON.parse(durable.progress!), durableResult.targetState);
+  assert.equal(staleReceipt.state, 'completed', 'the stale caller returns the winning durable observation');
+  assert.deepEqual(staleReceipt.targetState, durableResult.targetState);
+
+  await db('task_history').delete();
+  const replayed = await operations.replay(principal, 'review_pull_request', args);
+  assert.equal((replayed?.lifecycle as { state: string }).state, 'completed');
+  assert.deepEqual((replayed?.lifecycle as { progress: unknown }).progress, durableResult.targetState);
+  const list = createToolCatalog(deps).find(tool => tool.name === 'list_operations')!;
+  const listed = (await list.run({ principal, args: list.schema.parse({}) })).data as { operations: Array<Record<string, unknown>> };
+  const listedReceipt = listed.operations.find(operation => operation.operationId === receipt.operationId)!;
+  assert.deepEqual((listedReceipt.lifecycle as { progress: unknown }).progress, durableResult.targetState);
+});
+
 test('replay recovers terminal lifecycle, artifacts and failure from durable receipts', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());

From 0e6f4b73fd18c29ccafb22c6f43d804f855b4e24 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 07:48:16 +0000
Subject: [PATCH 17/19] feat(ai): Implemented the MCP legacy cleanup:

Implemented the MCP legacy cleanup:

- Folded lifecycle columns into the original MCP schema migration.
- Removed the additive migration, backfill logic, legacy lifecycle mapping, and legacy receipt tests/fallbacks.
- Required lifecycle metadata for all newly created MCP operations.
- Preserved current crash recovery and fixed terminal recovery replacing stale progress.
- Updated affected fixtures and tests.

Validation passed:

- Full MCP suite: 124/124
- API typecheck
- API and core lint
- `git diff --check`

No visual preview was created because these are API/database-only changes.

PR: #2613
Comment by: @integry (ID: 5885821150)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationLifecycle.ts        |  11 +-
 packages/api/mcp/operationTracking.ts         |  24 ++--
 packages/api/mcp/operations.ts                |  45 ++++---
 packages/api/mcp/tools.ts                     |   4 +-
 packages/api/test/fixtures/mcpCancellation.ts |   8 +-
 packages/api/test/mcpIntegration.test.ts      |   3 +-
 packages/api/test/mcpOperations.test.ts       | 112 +++---------------
 packages/api/test/mcpTaskSubmissions.test.ts  |   2 -
 .../db/migrations/20260910220000_add_mcp.js   |   8 ++
 ...61001000000_add_mcp_operation_lifecycle.js |  33 ------
 10 files changed, 75 insertions(+), 175 deletions(-)
 delete mode 100644 packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js

diff --git a/packages/api/mcp/operationLifecycle.ts b/packages/api/mcp/operationLifecycle.ts
index f2c4d19bc..2fd36aeed 100644
--- a/packages/api/mcp/operationLifecycle.ts
+++ b/packages/api/mcp/operationLifecycle.ts
@@ -1,5 +1,5 @@
 import { redactSecrets, type McpErrorEnvelope } from './errorEnvelope.js';
-import type { McpOperations, LifecycleOutcome, LifecycleState, Operation } from './operations.js';
+import type { McpOperations, LifecycleOutcome, Operation } from './operations.js';
 
 const startedTaskStates = new Set(['processing', 'claude_execution', 'post_processing']);
 const executedGoalTaskStates = new Set([...startedTaskStates, 'completed', 'failed']);
@@ -63,14 +63,7 @@ function issueNumbersFromReceipt(
   return [...issueNumbers];
 }
 
-/** Translate the compatibility state into the persisted public lifecycle. */
-export function lifecycleFromLegacy(state: unknown): LifecycleState {
-  if (['running', 'accepted', 'posted', 'queued', 'browser_required'].includes(String(state))) return 'accepted';
-  if (['completed', 'failed', 'cancelled'].includes(String(state))) return String(state) as LifecycleState;
-  return 'unknown';
-}
-
-/** Collect stable output handles regardless of which legacy receipt layer exposed them. */
+/** Collect stable output handles from mutation results and tracker observations. */
 export function artifactsFromReceipt(row: Pick<Operation, 'repository'>, receipt: Record<string, unknown>): Record<string, unknown> {
   const result = record(receipt.result) ?? {};
   const continuation = record(result.continuation) ?? {};
diff --git a/packages/api/mcp/operationTracking.ts b/packages/api/mcp/operationTracking.ts
index 88007a53d..033aeacc6 100644
--- a/packages/api/mcp/operationTracking.ts
+++ b/packages/api/mcp/operationTracking.ts
@@ -69,18 +69,6 @@ export async function trackCancellation(deps: ToolDeps, row: Operation, principa
   await deps.db('mcp_operations').where({ id: row.id }).whereNotIn('state', terminalStates).update({ state: receipt.state, result: JSON.stringify(result), updated_at: Date.now() });
 }
 
-function restoreResolvedTarget(
-  receipt: Record<string, unknown>,
-  result: ExecutionResult,
-  task: TrackingContext['task'] | undefined,
-): void {
-  const persistedTarget = result.targetState ?? {};
-  if (task || Object.keys(persistedTarget).length) receipt.targetState = {
-    ...persistedTarget,
-    ...(task ? { taskId: task.task_id, pr_number: task.pr_number } : {}),
-  };
-}
-
 async function refreshPullRequestContext(
   row: Operation,
   principal: McpPrincipal,
@@ -98,6 +86,18 @@ async function refreshPullRequestContext(
   };
 }
 
+function restoreResolvedTarget(
+  receipt: Record<string, unknown>,
+  result: ExecutionResult,
+  task: TrackingContext['task'] | undefined,
+): void {
+  if (!result.targetState) return;
+  receipt.targetState = {
+    ...result.targetState,
+    ...(task ? { taskId: task.task_id, pr_number: task.pr_number } : {}),
+  };
+}
+
 /** Resolve the execution from the actual job or the exact triggering comment. */
 export async function trackExecution(deps: ToolDeps, row: Operation, principal: McpPrincipal, receipt: Record<string, unknown>): Promise<void> {
   if (!trackedTools.includes(row.tool) || !row.result) return;
diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index 0ce039d5b..46508a248 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -4,7 +4,7 @@ import { McpError } from './config.js';
 import { classifyError, type McpErrorEnvelope } from './errorEnvelope.js';
 import { digest } from './store.js';
 import type { McpPrincipal } from './policy.js';
-import { artifactsFromReceipt, failureFromReceipt, lifecycleFromLegacy } from './operationLifecycle.js';
+import { artifactsFromReceipt, failureFromReceipt } from './operationLifecycle.js';
 
 const interruptionTimeoutMs = 120_000;
 
@@ -14,7 +14,7 @@ export type LifecycleOutcome = 'completed' | 'failed' | 'cancelled';
 export interface Operation {
   id: string; owner_id: string; grant_id: string; idempotency_key: string; tool: string; repository: string | null;
   state: string; result: string | null; created_at: number; updated_at: number; payload_hash: string;
-  lifecycle: LifecycleState; accepted_at: number | null; started_at: number | null; finished_at: number | null;
+  lifecycle: LifecycleState; accepted_at: number; started_at: number | null; finished_at: number | null;
   failure: string | null; artifacts: string | null; progress: string | null;
 }
 
@@ -67,11 +67,21 @@ function operationState(result: OperationResult): string {
 }
 
 function invocationInterrupted(row: Operation, now = Date.now()): boolean {
-  const invokedAt = Number(row.accepted_at ?? row.created_at);
-  return ['accepted', 'running'].includes(row.state) && row.result === null && Number.isFinite(invokedAt)
+  const invokedAt = Number(row.accepted_at);
+  return row.state === 'accepted' && row.result === null && Number.isFinite(invokedAt)
     && now - invokedAt > interruptionTimeoutMs;
 }
 
+function needsProgressRecovery(targetState: unknown, lifecycleMissing: boolean, progress: string | null): boolean {
+  if (targetState === undefined) return false;
+  return lifecycleMissing || progress === null;
+}
+
+function recoveredProgress(db: Knex, targetState: unknown, lifecycleMissing: boolean): unknown {
+  if (lifecycleMissing) return JSON.stringify(targetState);
+  return db.raw('COALESCE(progress, ?)', [JSON.stringify(targetState)]);
+}
+
 export class McpOperations {
   constructor(readonly db: Knex) {}
 
@@ -111,15 +121,14 @@ export class McpOperations {
       if (!recorded) return this.project((await this.db<Operation>('mcp_operations').where({ id }).first())!);
       const receipt = { state, result: result.data };
       await this.recordArtifacts(id, artifactsFromReceipt({ repository: repository || null }, receipt));
-      const lifecycle = lifecycleFromLegacy(state);
-      if (['completed', 'failed', 'cancelled'].includes(lifecycle)) {
+      if (['completed', 'failed', 'cancelled'].includes(state)) {
         const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error) ?? failureFromReceipt(receipt);
-        await this.finish(id, lifecycle as LifecycleOutcome, failure);
-      } else if (lifecycle === 'unknown') {
+        await this.finish(id, state as LifecycleOutcome, failure);
+      } else if (state === 'unknown') {
         const failure = errorEnvelope((result.data as { error?: unknown } | null)?.error);
         await this.db('mcp_operations').where({ id }).whereIn('lifecycle', ['accepted', 'unknown'])
           .update({ lifecycle: 'unknown', failure: failure ? JSON.stringify(failure) : null, updated_at: Date.now() });
-      } else if (lifecycle === 'accepted') {
+      } else {
         // A live invocation result is authoritative if a concurrent poll had
         // already classified its previously result-less receipt as interrupted.
         await this.markAccepted(id);
@@ -166,8 +175,8 @@ export class McpOperations {
         .filter(([key, value]) => canonical(artifactRecord[key]) !== canonical(value)));
       const failure = row.state === 'failed' ? failureFromReceipt(receipt) : undefined;
       const lifecycleMissing = ['accepted', 'running', 'unknown'].includes(row.lifecycle) || row.finished_at === null;
-      const progressMissing = row.progress === null && targetState !== undefined;
-      if (!lifecycleMissing && !Object.keys(missingArtifacts).length && !(failure && row.failure === null) && !progressMissing) continue;
+      const progressNeedsRecovery = needsProgressRecovery(targetState, lifecycleMissing, row.progress);
+      if (!lifecycleMissing && !Object.keys(missingArtifacts).length && !(failure && row.failure === null) && !progressNeedsRecovery) continue;
 
       const update: Record<string, unknown> = { updated_at: Date.now() };
       if (lifecycleMissing) {
@@ -182,8 +191,10 @@ export class McpOperations {
       if (failure && row.failure === null) {
         update.failure = this.db.raw('COALESCE(failure, ?)', [JSON.stringify(failure)]);
       }
-      if (progressMissing) {
-        update.progress = this.db.raw('COALESCE(progress, ?)', [JSON.stringify(targetState)]);
+      if (progressNeedsRecovery) {
+        // A terminal tracker receipt is newer than any nonterminal progress
+        // recorded before lifecycle synchronization was interrupted.
+        update.progress = recoveredProgress(this.db, targetState, lifecycleMissing);
       }
 
       // Do not attach metadata derived from a receipt that changed after the
@@ -201,8 +212,8 @@ export class McpOperations {
   async markInterruptedInvocations(principal: McpPrincipal, id?: string): Promise<void> {
     const now = Date.now();
     const query = this.db('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
-      .whereIn('state', ['accepted', 'running']).whereNull('result').whereIn('lifecycle', ['accepted', 'running', 'unknown'])
-      .whereRaw('COALESCE(accepted_at, created_at) < ?', [now - interruptionTimeoutMs]);
+      .where({ state: 'accepted' }).whereNull('result').whereIn('lifecycle', ['accepted', 'running', 'unknown'])
+      .where('accepted_at', '<', now - interruptionTimeoutMs);
     if (id) query.andWhere({ id });
     await query.update({ state: 'unknown', lifecycle: 'unknown', updated_at: now });
   }
@@ -292,8 +303,8 @@ export class McpOperations {
     const stale = interrupted || (row.state === 'running' && Date.now() - Number(row.updated_at) > interruptionTimeoutMs);
     const state = stale ? 'unknown' : row.state;
     return { operationId: row.id, tool: row.tool, state, result: json(row.result), lifecycle: {
-      state: interrupted ? 'unknown' : row.lifecycle ?? lifecycleFromLegacy(row.state),
-      acceptedAt: iso(row.accepted_at ?? row.created_at),
+      state: interrupted ? 'unknown' : row.lifecycle,
+      acceptedAt: iso(row.accepted_at),
       startedAt: iso(row.started_at),
       finishedAt: iso(row.finished_at),
       failure: json(row.failure),
diff --git a/packages/api/mcp/tools.ts b/packages/api/mcp/tools.ts
index 0d64682db..21e47a157 100644
--- a/packages/api/mcp/tools.ts
+++ b/packages/api/mcp/tools.ts
@@ -379,12 +379,12 @@ export function createToolCatalog(deps: ToolDeps): McpTool[] {
       await operations.reconcileTerminalLifecycles(principal);
       await operations.markInterruptedInvocations(principal);
       const query = db<Operation>('mcp_operations').where({ owner_id: principal.user.id, grant_id: principal.grant.id })
-        .whereRaw('COALESCE(accepted_at, created_at) >= ?', [Date.now() - args.sinceMinutes * 60_000]);
+        .where('accepted_at', '>=', Date.now() - args.sinceMinutes * 60_000);
       if (args.tool) query.where('tool', args.tool);
       if (args.repository) query.andWhere(builder => builder.where('repository', args.repository).orWhere('tool', 'cancel_operation'));
       if (args.lifecycle === 'active') query.whereIn('lifecycle', ['accepted', 'running']);
       else if (args.lifecycle) query.where('lifecycle', args.lifecycle);
-      const ordered = query.orderByRaw('COALESCE(accepted_at, created_at) DESC').orderBy('id', 'desc');
+      const ordered = query.orderBy('accepted_at', 'desc').orderBy('id', 'desc');
       const authorized: Operation[] = [];
       const repositoryAuthorizations = new Map<string, Promise<void>>();
       const wanted = args.offset + args.limit + 1;
diff --git a/packages/api/test/fixtures/mcpCancellation.ts b/packages/api/test/fixtures/mcpCancellation.ts
index 0826fca1a..293d6daf4 100644
--- a/packages/api/test/fixtures/mcpCancellation.ts
+++ b/packages/api/test/fixtures/mcpCancellation.ts
@@ -78,9 +78,11 @@ export async function verifyCancellation({ call, client, principal, deps, agentI
     await db('task_drafts').where({ draft_id: id }).update({ status: tool === 'generate_plan' ? 'generating' : 'refining', [column]: JSON.stringify({ runId, steps: [] }) });
     // This is the persisted 202 boundary produced by the planner start handler.
     const operationId = randomUUID();
+    const acceptedAt = Date.now();
     await db('mcp_operations').insert({ id: operationId, owner_id: principal.user.id, grant_id: principal.grant.id,
       idempotency_key: randomUUID(), tool, repository, payload_hash: 'fixture', state: 'accepted',
-      result: JSON.stringify({ runId, continuation: { planId: id } }), created_at: Date.now(), updated_at: Date.now() });
+      result: JSON.stringify({ runId, continuation: { planId: id } }), lifecycle: 'accepted', accepted_at: acceptedAt,
+      artifacts: JSON.stringify({}), created_at: acceptedAt, updated_at: acceptedAt });
     let enter!: () => void, release!: () => void;
     const entered = new Promise<void>(resolve => { enter = resolve; });
     const hold = new Promise<void>(resolve => { release = resolve; });
@@ -110,9 +112,11 @@ export async function verifyCancellation({ call, client, principal, deps, agentI
     assert.equal(stale.result.error.code, 'NOT_CANCELLABLE');
     for (const outcome of ['completed', 'failed']) {
       const completedRun = randomUUID(), completedOperation = randomUUID();
+      const completedAcceptedAt = Date.now();
       await db('mcp_operations').insert({ id: completedOperation, owner_id: principal.user.id, grant_id: principal.grant.id,
         idempotency_key: randomUUID(), tool, repository, payload_hash: 'fixture', state: 'accepted',
-        result: JSON.stringify({ runId: completedRun, continuation: { planId: id } }), created_at: Date.now(), updated_at: Date.now() });
+        result: JSON.stringify({ runId: completedRun, continuation: { planId: id } }), lifecycle: 'accepted', accepted_at: completedAcceptedAt,
+        artifacts: JSON.stringify({}), created_at: completedAcceptedAt, updated_at: completedAcceptedAt });
       await db('task_drafts').where({ draft_id: id }).update({
         status: tool === 'generate_plan' && outcome === 'failed' ? 'failed' : 'review',
         [column]: JSON.stringify({ runId: completedRun, status: outcome }),
diff --git a/packages/api/test/mcpIntegration.test.ts b/packages/api/test/mcpIntegration.test.ts
index 5db24855d..4b98fc2cf 100644
--- a/packages/api/test/mcpIntegration.test.ts
+++ b/packages/api/test/mcpIntegration.test.ts
@@ -17,7 +17,6 @@ import { up as planIssues } from '../../core/src/db/migrations/20260120000000_ad
 import { up as planIssueTasks } from '../../core/src/db/migrations/20260121000000_add_task_id_to_plan_issues.js';
 import { up as taskPullRequests } from '../../core/src/db/migrations/20260216000000_add_pr_number_to_tasks.js';
 import { up as mcpMigration } from '../../core/src/db/migrations/20260910220000_add_mcp.js';
-import { up as operationLifecycleMigration } from '../../core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js';
 import { McpStore } from '../mcp/store.js';
 import { McpOAuthProvider } from '../mcp/oauth.js';
 import { McpError } from '../mcp/config.js';
@@ -30,7 +29,7 @@ after(async () => closeConnection());
 
 test('both official SDK protocol eras execute real draft/revision/publication/task transitions over the same HTTP endpoint', async () => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
-  await initial(db); await planIssues(db); await planIssueTasks(db); await taskPullRequests(db); await mcpMigration(db); await operationLifecycleMigration(db);
+  await initial(db); await planIssues(db); await planIssueTasks(db); await taskPullRequests(db); await mcpMigration(db);
   await db.schema.alterTable('task_drafts', table => table.boolean('paused').defaultTo(false));
   await db.schema.createTable('goals', table => {
     table.string('goal_id'); table.string('owner_id'); table.string('repository'); table.string('current_task_id');
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index 87cd3dde7..be70b049b 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -7,7 +7,6 @@ import path from 'node:path';
 import knex from 'knex';
 import { closeConnection } from '@propr/core';
 import { up } from '../../core/src/db/migrations/20260910220000_add_mcp.js';
-import { down as lifecycleDown, up as lifecycleUp } from '../../core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js';
 import { McpOperations, type Operation } from '../mcp/operations.js';
 import { McpError } from '../mcp/config.js';
 import { callWorkflow } from '../mcp/adapter.js';
@@ -26,7 +25,6 @@ test('mutation deduplication survives concurrent callers and reopening the SQLit
   try {
     await db.schema.createTable('task_drafts', table => { table.string('draft_id').primary(); table.string('name'); });
     await up(db);
-    await lifecycleUp(db);
     const principal = { user: { id: '123' }, grant: { id: 'grant-1' } } as never;
     const args = { idempotencyKey: 'durable-key-1', value: 'payload' };
     let invoked = 0;
@@ -78,7 +76,7 @@ test('operation lifecycle transitions, artifacts and progress are durable and mo
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as never;
   const receipt = await operations.run(principal, {
@@ -119,7 +117,7 @@ test('a delayed invocation result cannot replace terminal evidence persisted by
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   let invocationStarted!: () => void;
@@ -160,7 +158,7 @@ test('stale concurrent polls cannot replace terminal tracker receipts or lifecyc
     table.increments('history_id').primary(); table.string('task_id'); table.string('state');
     table.timestamp('timestamp'); table.text('reason'); table.text('metadata');
   });
-  await up(db); await lifecycleUp(db);
+  await up(db);
 
   const operations = new McpOperations(db);
   const args = { idempotencyKey: 'stale-terminal-poll-1' };
@@ -228,7 +226,7 @@ test('replay recovers terminal lifecycle, artifacts and failure from durable rec
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const operations = new McpOperations(db);
   const args = { idempotencyKey: 'interrupted-success-1' };
@@ -276,7 +274,7 @@ test('replay recovers terminal lifecycle, artifacts and failure from durable rec
   assert.deepEqual((failedReplay?.lifecycle as { failure: unknown }).failure, failure);
 });
 
-test('list_operations recovers terminal lifecycle, artifacts and failure before filtering', async t => {
+test('list_operations recovers tracker lifecycle, artifacts and failure before filtering', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
@@ -288,28 +286,19 @@ test('list_operations recovers terminal lifecycle, artifacts and failure before
     table.increments('history_id').primary(); table.string('task_id'); table.string('state');
     table.timestamp('timestamp'); table.text('reason'); table.text('metadata');
   });
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const operations = new McpOperations(db);
-  const receipt = await operations.run(principal, {
-    tool: 'send_task_followup', args: { idempotencyKey: 'tracker-interrupt-1' }, repository: 'acme/repo',
-  }, async () => ({ status: 202, data: { state: 'queued' } }));
   const failedArgs = { idempotencyKey: 'tracker-failure-02' };
   const failed = await operations.run(principal, {
     tool: 'send_task_followup', args: failedArgs, repository: 'acme/repo',
   }, async () => ({ status: 202, data: { state: 'queued', jobId: 'job-failed', continuation: { taskId: 'task-failed' } } }));
-  const persistedAt = Date.now() - 500;
-  // Keep coverage for a legacy terminal receipt whose identifiers are directly
-  // in the result alongside the tracker-shaped receipt below.
-  await db('mcp_operations').where({ id: receipt.operationId }).update({
-    state: 'completed', result: JSON.stringify({ state: 'queued', continuation: { taskId: 'task-1' }, executionResolved: true }),
-    updated_at: persistedAt,
-  });
   const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
     taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
   const observedAt = '2026-09-29T03:00:00.000Z';
   await db('tasks').insert({ task_id: 'task-failed', job_id: 'job-failed', repository: 'acme/repo', task_type: 'issue', pr_number: 73 });
   await db('task_history').insert({ task_id: 'task-failed', state: 'failed', timestamp: observedAt, reason: 'Agent stopped after tests failed.' });
+  await operations.recordProgress(String(failed.operationId), { taskId: 'task-failed', state: 'processing' });
   const failedRow = await db<Operation>('mcp_operations').where({ id: failed.operationId }).first();
   // Stop immediately after the awaited tracker write, before syncLifecycle can
   // project its nested targetState into lifecycle columns.
@@ -318,20 +307,15 @@ test('list_operations recovers terminal lifecycle, artifacts and failure before
   assert.equal(trackerWrite?.state, 'failed');
   assert.equal(trackerWrite?.lifecycle, 'accepted');
   assert.equal(trackerWrite?.failure, null);
-  assert.equal(trackerWrite?.progress, null);
+  assert.deepEqual(JSON.parse(trackerWrite!.progress!), { taskId: 'task-failed', state: 'processing' });
   assert.deepEqual(JSON.parse(trackerWrite!.result!).targetState, {
     taskId: 'task-failed', pr_number: 73, state: 'failed', timestamp: observedAt, reason: 'Agent stopped after tests failed.',
   });
 
   const list = createToolCatalog(deps).find(tool => tool.name === 'list_operations')!;
   const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: Array<Record<string, unknown>> };
-  const completed = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'completed' }) })).data as { operations: Array<Record<string, unknown>> };
   const failures = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'failed' }) })).data as { operations: Array<Record<string, unknown>> };
   assert.deepEqual(active.operations, []);
-  assert.deepEqual(completed.operations.map(row => row.operationId), [receipt.operationId]);
-  assert.equal((completed.operations[0].lifecycle as { state: string }).state, 'completed');
-  assert.equal((completed.operations[0].lifecycle as { finishedAt: string }).finishedAt, new Date(persistedAt).toISOString());
-  assert.deepEqual((completed.operations[0].lifecycle as { artifacts: unknown }).artifacts, { taskId: 'task-1' });
   assert.deepEqual(failures.operations.map(row => row.operationId), [failed.operationId]);
   const recoveredLifecycle = failures.operations[0].lifecycle as Record<string, unknown>;
   assert.deepEqual(recoveredLifecycle.failure, {
@@ -346,9 +330,6 @@ test('list_operations recovers terminal lifecycle, artifacts and failure before
   });
   const replay = await operations.replay(principal, 'send_task_followup', failedArgs);
   assert.deepEqual(replay?.lifecycle, recoveredLifecycle);
-  assert.deepEqual(await db('mcp_operations').where({ id: receipt.operationId }).first('state', 'lifecycle', 'finished_at'), {
-    state: 'completed', lifecycle: 'completed', finished_at: persistedAt,
-  });
 });
 
 test('replay and listing recover confirmed cancellation propagation after the tracker write', async t => {
@@ -364,7 +345,7 @@ test('replay and listing recover confirmed cancellation propagation after the tr
   await db.schema.createTable('task_history', table => {
     table.increments('history_id').primary(); table.string('task_id'); table.string('state'); table.timestamp('timestamp');
   });
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const otherGrant = { user: { id: 'alice' }, grant: { id: 'grant-b' } } as McpPrincipal;
   const operations = new McpOperations(db);
@@ -425,7 +406,7 @@ test('polling an accepted wrapper does not fabricate backend execution start', a
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   let finishInvocation!: (result: { status: number; data: unknown }) => void;
@@ -458,7 +439,7 @@ test('interrupted accepted invocations become durable unknown while acknowledged
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   let finishInvocation!: (result: { status: number; data: unknown }) => void;
@@ -523,7 +504,7 @@ test('tracker uncertainty resolves from later evidence and preserves observed ti
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const receipt = await operations.run(principal, {
@@ -563,7 +544,7 @@ test('tracker task and review failures populate and can enrich the durable failu
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const create = (tool: string, key: string) => operations.run(principal, {
@@ -637,7 +618,7 @@ test('goal failures and generated task pull requests remain durable after backen
     table.integer('issue_number'); table.text('issue_url'); table.string('task_id'); table.string('retry_event_id');
     table.boolean('dispatch_complete'); table.text('error'); table.timestamp('created_at').defaultTo(db.fn.now());
   });
-  await up(db); await lifecycleUp(db);
+  await up(db);
 
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const operations = new McpOperations(db);
@@ -711,7 +692,7 @@ test('list_operations filters active receipts by exact owner and grant without r
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
   const otherGrant = { user: { id: 'alice' }, grant: { id: 'grant-b' } } as McpPrincipal;
@@ -741,7 +722,7 @@ test('list_operations filters current repository, tool permission and cancellati
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
   await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db); await lifecycleUp(db);
+  await up(db);
   const operations = new McpOperations(db);
   const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' }, authorization: { permissions: [] } } as unknown as McpPrincipal;
   const run = (tool: string, key: string, repository?: string, data: Record<string, unknown> = {}) => operations.run(principal, {
@@ -798,67 +779,6 @@ test('list_operations filters current repository, tool permission and cancellati
   await assert.rejects(get.run({ principal, args: get.schema.parse({ operationId: cancellation.operationId }) }), /No current access/);
 });
 
-test('operation lifecycle migration backfills and rolls back on SQLite', async t => {
-  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
-  t.after(() => db.destroy());
-  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db);
-  await db('mcp_operations').insert([
-    { id: 'completed', owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'completed-key', tool: 'fixture', payload_hash: 'a', state: 'completed', result: '{}', created_at: 10, updated_at: 20 },
-    { id: 'failed', owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'failed-key-01', tool: 'fixture', payload_hash: 'b', state: 'failed', result: JSON.stringify({ error: { code: 'BROKEN' } }), created_at: 30, updated_at: 40 },
-    { id: 'queued', owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'queued-key-01', tool: 'fixture', payload_hash: 'c', state: 'queued', result: '{}', created_at: 50, updated_at: 60 },
-  ]);
-  await lifecycleUp(db);
-  const rows = await db('mcp_operations').orderBy('created_at');
-  assert.deepEqual(rows.map(row => [row.lifecycle, row.accepted_at, row.finished_at]), [
-    ['completed', 10, 20], ['failed', 30, 40], ['accepted', 50, null],
-  ]);
-  assert.deepEqual(JSON.parse(rows[1].failure), { code: 'BROKEN' });
-  await lifecycleDown(db);
-  assert.equal(await db.schema.hasColumn('mcp_operations', 'lifecycle'), false);
-  assert.equal(await db.schema.hasColumn('mcp_operations', 'accepted_at'), false);
-});
-
-test('migration reconciles an interrupted legacy running receipt across filters and repeated polls', async t => {
-  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
-  t.after(() => db.destroy());
-  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
-  await up(db);
-  const operationId = '00000000-0000-4000-8000-000000000007';
-  const invokedAt = Date.now() - 120_001;
-  await db('mcp_operations').insert({
-    id: operationId, owner_id: 'alice', grant_id: 'grant-a', idempotency_key: 'legacy-running-1',
-    tool: 'fixture', payload_hash: 'legacy', state: 'running', result: null,
-    created_at: invokedAt, updated_at: invokedAt,
-  });
-  await lifecycleUp(db);
-  assert.deepEqual(await db('mcp_operations').where({ id: operationId }).first('state', 'lifecycle', 'accepted_at'), {
-    state: 'running', lifecycle: 'accepted', accepted_at: invokedAt,
-  });
-
-  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
-  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
-    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
-  const catalog = createToolCatalog(deps);
-  const list = catalog.find(tool => tool.name === 'list_operations')!;
-  const get = catalog.find(tool => tool.name === 'get_operation')!;
-
-  const active = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'active' }) })).data as { operations: Array<Record<string, unknown>> };
-  const unknown = (await list.run({ principal, args: list.schema.parse({ lifecycle: 'unknown' }) })).data as { operations: Array<Record<string, unknown>> };
-  assert.deepEqual(active.operations, []);
-  assert.deepEqual(unknown.operations.map(row => row.operationId), [operationId]);
-
-  for (let poll = 0; poll < 2; poll++) {
-    const receipt = (await get.run({ principal, args: get.schema.parse({ operationId }) })).data as Record<string, unknown>;
-    assert.equal(receipt.state, 'unknown');
-    assert.equal((receipt.lifecycle as { state: string }).state, 'unknown');
-    assert.equal(receipt.retryAfterSeconds, undefined);
-  }
-  assert.deepEqual(await db('mcp_operations').where({ id: operationId }).first('state', 'lifecycle'), {
-    state: 'unknown', lifecycle: 'unknown',
-  });
-});
-
 test('CIMD intersects plural supported methods with public PKCE instead of trusting a legacy preference', () => {
   const id = 'https://client.example/oauth/client.json';
   const document = { client_id: id, client_name: 'Test', redirect_uris: ['https://client.example/callback'], token_endpoint_auth_methods_supported: ['none', 'private_key_jwt'], token_endpoint_auth_method: 'private_key_jwt' };
diff --git a/packages/api/test/mcpTaskSubmissions.test.ts b/packages/api/test/mcpTaskSubmissions.test.ts
index dd31ddb91..0aa8b734e 100644
--- a/packages/api/test/mcpTaskSubmissions.test.ts
+++ b/packages/api/test/mcpTaskSubmissions.test.ts
@@ -5,7 +5,6 @@ import knex from 'knex';
 import { z } from 'zod';
 import { associateSubmissionTask, closeConnection } from '@propr/core';
 import { up as mcpMigration } from '../../core/src/db/migrations/20260910220000_add_mcp.js';
-import { up as operationLifecycleMigration } from '../../core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js';
 import { up as submissionMigration } from '../../core/src/db/migrations/20260922000000_add_task_submissions.js';
 import { up as identityMigration } from '../../core/src/db/migrations/20260922010000_preserve_task_submission_identity.js';
 import { createToolCatalog, executeTool, type ToolDeps } from '../mcp/tools.js';
@@ -38,7 +37,6 @@ async function fixture() {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   await db.schema.createTable('task_drafts', table => { table.string('draft_id').primary(); });
   await mcpMigration(db);
-  await operationLifecycleMigration(db);
   await submissionMigration(db);
   await identityMigration(db);
   await db.schema.createTable('tasks', table => {
diff --git a/packages/core/src/db/migrations/20260910220000_add_mcp.js b/packages/core/src/db/migrations/20260910220000_add_mcp.js
index 2145d3a9f..cd1fb350a 100644
--- a/packages/core/src/db/migrations/20260910220000_add_mcp.js
+++ b/packages/core/src/db/migrations/20260910220000_add_mcp.js
@@ -19,9 +19,17 @@ export async function up(knex) {
     table.string('payload_hash', 64).notNullable();
     table.string('state').notNullable();
     table.text('result').nullable();
+    table.string('lifecycle', 16).notNullable();
+    table.bigInteger('accepted_at').notNullable();
+    table.bigInteger('started_at').nullable();
+    table.bigInteger('finished_at').nullable();
+    table.json('failure').nullable();
+    table.json('artifacts').notNullable();
+    table.json('progress').nullable();
     table.bigInteger('created_at').notNullable();
     table.bigInteger('updated_at').notNullable();
     table.unique(['owner_id', 'grant_id', 'idempotency_key']);
+    table.index(['owner_id', 'grant_id', 'accepted_at'], 'mcp_operations_owner_grant_accepted_idx');
   });
   await knex.schema.alterTable('task_drafts', table => { table.integer('mcp_revision').notNullable().defaultTo(0); });
   // Every writer, including browser handlers and background workers, invalidates
diff --git a/packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js b/packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js
deleted file mode 100644
index 5999cb927..000000000
--- a/packages/core/src/db/migrations/20261001000000_add_mcp_operation_lifecycle.js
+++ /dev/null
@@ -1,33 +0,0 @@
-export async function up(knex) {
-  await knex.schema.alterTable('mcp_operations', table => {
-    table.string('lifecycle', 16).notNullable().defaultTo('accepted');
-    table.bigInteger('accepted_at').nullable();
-    table.bigInteger('started_at').nullable();
-    table.bigInteger('finished_at').nullable();
-    table.json('failure').nullable();
-    table.json('artifacts').notNullable().defaultTo('{}');
-    table.json('progress').nullable();
-    table.index(['owner_id', 'grant_id', 'accepted_at'], 'mcp_operations_owner_grant_accepted_idx');
-  });
-
-  await knex.raw(`UPDATE mcp_operations SET
-    lifecycle = CASE
-      WHEN state IN ('running', 'accepted', 'posted', 'queued', 'browser_required') THEN 'accepted'
-      WHEN state IN ('completed', 'failed', 'cancelled') THEN state
-      ELSE 'unknown'
-    END,
-    accepted_at = created_at,
-    finished_at = CASE WHEN state IN ('completed', 'failed', 'cancelled') THEN updated_at ELSE NULL END,
-    failure = CASE
-      WHEN result IS NOT NULL AND json_valid(result) THEN json_extract(result, '$.error')
-      ELSE NULL
-    END,
-    artifacts = '{}'`);
-}
-
-export async function down(knex) {
-  await knex.schema.alterTable('mcp_operations', table => {
-    table.dropIndex([], 'mcp_operations_owner_grant_accepted_idx');
-    table.dropColumns('lifecycle', 'accepted_at', 'started_at', 'finished_at', 'failure', 'artifacts', 'progress');
-  });
-}

From 10c42076c343af74f99a53014c284cf56b9b4790 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 08:43:23 +0000
Subject: [PATCH 18/19] feat(ai): Implemented F18, F19, and F20 only.

Implemented F18, F19, and F20 only.

- F18: verified the existing guarded recovery overwrites stale nonterminal progress with the durable terminal target snapshot; its interruption regression passes.
- F19: terminal execution restoration now preserves live `targetState` fields and enriches them with task/PR identity.
- F20: terminal lifecycle state now governs replay/list projections, removing contradictory polling hints and stale messages.
- Added focused `get_operation`, replay, and listing regressions.

Validation:

- Full MCP suite: 125/125 passed
- Focused operations suite: 17/17 passed
- API typecheck passed
- API lint passed
- `git diff --check` passed

Independent pre-existing findings, intentionally unchanged: resolved cancellation tracking can similarly clear a missing persisted target, and follow-up task lookup assumes a job ID is present. Both are outside PR-changed behavior. No visual preview was generated because the changes are API-only.

PR: #2613
Comment by: @integry (ID: 5886663832)
Model: gpt-5.6-sol
---
 packages/api/mcp/operationTracking.ts   |  7 +++--
 packages/api/mcp/operations.ts          |  7 +++--
 packages/api/test/mcpOperations.test.ts | 41 +++++++++++++++++++++++++
 3 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/packages/api/mcp/operationTracking.ts b/packages/api/mcp/operationTracking.ts
index 033aeacc6..945b142aa 100644
--- a/packages/api/mcp/operationTracking.ts
+++ b/packages/api/mcp/operationTracking.ts
@@ -91,9 +91,12 @@ function restoreResolvedTarget(
   result: ExecutionResult,
   task: TrackingContext['task'] | undefined,
 ): void {
-  if (!result.targetState) return;
+  const target = result.targetState
+    ?? (receipt.targetState as Record<string, unknown> | undefined)
+    ?? {};
+  if (!task && !Object.keys(target).length) return;
   receipt.targetState = {
-    ...result.targetState,
+    ...target,
     ...(task ? { taskId: task.task_id, pr_number: task.pr_number } : {}),
   };
 }
diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index 46508a248..b3d225a71 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -300,10 +300,11 @@ export class McpOperations {
 
   project(row: Operation): Record<string, unknown> {
     const interrupted = invocationInterrupted(row);
-    const stale = interrupted || (row.state === 'running' && Date.now() - Number(row.updated_at) > interruptionTimeoutMs);
-    const state = stale ? 'unknown' : row.state;
+    const terminal = ['completed', 'failed', 'cancelled'].includes(row.lifecycle);
+    const stale = !terminal && (interrupted || (row.state === 'running' && Date.now() - Number(row.updated_at) > interruptionTimeoutMs));
+    const state = terminal ? row.lifecycle : stale ? 'unknown' : row.state;
     return { operationId: row.id, tool: row.tool, state, result: json(row.result), lifecycle: {
-      state: interrupted ? 'unknown' : row.lifecycle,
+      state: interrupted && !terminal ? 'unknown' : row.lifecycle,
       acceptedAt: iso(row.accepted_at),
       startedAt: iso(row.started_at),
       finishedAt: iso(row.finished_at),
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index be70b049b..c5d50415d 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -222,6 +222,41 @@ test('stale concurrent polls cannot replace terminal tracker receipts or lifecyc
   assert.deepEqual((listedReceipt.lifecycle as { progress: unknown }).progress, durableResult.targetState);
 });
 
+test('terminal execution restoration preserves target state resolved by get_operation', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await db.schema.createTable('tasks', table => {
+    table.string('task_id').primary(); table.string('job_id'); table.string('repository'); table.string('task_type');
+    table.integer('pr_number'); table.text('initial_job_data'); table.timestamp('created_at').defaultTo(db.fn.now());
+  });
+  await db.schema.createTable('task_history', table => {
+    table.increments('history_id').primary(); table.string('task_id'); table.string('state'); table.timestamp('timestamp');
+  });
+  await up(db);
+
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const operations = new McpOperations(db);
+  const receipt = await operations.run(principal, {
+    tool: 'send_task_followup', args: { idempotencyKey: 'resolved-target-fallback' }, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: { state: 'queued', continuation: { taskId: 'resolved-task' } } }));
+  const observedAt = '2026-09-29T05:00:00.000Z';
+  await db('tasks').insert({ task_id: 'resolved-task', job_id: 'resolved-job', repository: 'acme/repo', task_type: 'issue', pr_number: 81 });
+  await db('task_history').insert({ task_id: 'resolved-task', state: 'completed', timestamp: observedAt });
+  await db('mcp_operations').where({ id: receipt.operationId }).update({
+    state: 'completed', lifecycle: 'completed', finished_at: Date.now(),
+    result: JSON.stringify({ jobId: 'resolved-job', continuation: { taskId: 'resolved-task' }, executionResolved: true }),
+  });
+
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const get = createToolCatalog(deps).find(tool => tool.name === 'get_operation')!;
+  const restored = (await get.run({ principal, args: get.schema.parse({ operationId: receipt.operationId }) })).data as Record<string, unknown>;
+  assert.deepEqual(restored.targetState, {
+    state: 'completed', timestamp: observedAt, taskId: 'resolved-task', pr_number: 81,
+  });
+});
+
 test('replay recovers terminal lifecycle, artifacts and failure from durable receipts', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());
@@ -683,9 +718,15 @@ test('goal failures and generated task pull requests remain durable after backen
   const durableTask = await operations.replay(principal, 'create_task', taskArgs);
   assert.deepEqual((durableTask?.lifecycle as { artifacts: unknown }).artifacts,
     { taskId, pullRequest: { repository: 'acme/repo', number: 73, url: 'https://github.com/acme/repo/pull/73' } });
+  const replayedGoal = await operations.replay(principal, 'create_goal', goalArgs);
+  assert.equal(replayedGoal?.state, 'failed');
+  assert.equal(replayedGoal?.retryAfterSeconds, undefined);
   const listed = (await list.run({ principal, args: list.schema.parse({}) })).data as { operations: Array<Record<string, unknown>> };
   assert.equal(listed.operations.length, 2);
   assert.ok(listed.operations.every(operation => Object.keys((operation.lifecycle as { artifacts: object }).artifacts).length > 0));
+  const listedGoal = listed.operations.find(operation => operation.operationId === goalReceipt.operationId)!;
+  assert.equal(listedGoal.state, 'failed');
+  assert.equal(listedGoal.retryAfterSeconds, undefined);
 });
 
 test('list_operations filters active receipts by exact owner and grant without refreshing trackers', async t => {

From bbe1192b5685d2c0e877eddbf1ffc874707fb593 Mon Sep 17 00:00:00 2001
From: "propr-dev[bot]" <1316198+propr-dev[bot]@users.noreply.github.com>
Date: Tue, 29 Sep 2026 09:24:25 +0000
Subject: [PATCH 19/19] feat(ai): Implemented F21 only.

Implemented F21 only.

- Removed timestamp-based interruption classification for tracker-confirmed `running` operations in [operations.ts](/home/node/workspace/packages/api/mcp/operations.ts:301).
- Added regression coverage for `list_operations`, replay, and duplicate idempotency responses in [mcpOperations.test.ts](/home/node/workspace/packages/api/test/mcpOperations.test.ts:538).
- Preserved result-less `accepted` invocation interruption handling.

Validation passed:

- Full MCP suite: 126/126 tests
- API TypeScript check
- Scoped ESLint
- `git diff --check`

No independent related defects found. No visual preview was needed for this API-only change.

PR: #2613
Comment by: @integry (ID: 5887302103)
Model: gpt-5.6-sol
---
 packages/api/mcp/operations.ts          |  2 +-
 packages/api/test/mcpOperations.test.ts | 66 +++++++++++++++++++++++++
 2 files changed, 67 insertions(+), 1 deletion(-)

diff --git a/packages/api/mcp/operations.ts b/packages/api/mcp/operations.ts
index b3d225a71..17cf38112 100644
--- a/packages/api/mcp/operations.ts
+++ b/packages/api/mcp/operations.ts
@@ -301,7 +301,7 @@ export class McpOperations {
   project(row: Operation): Record<string, unknown> {
     const interrupted = invocationInterrupted(row);
     const terminal = ['completed', 'failed', 'cancelled'].includes(row.lifecycle);
-    const stale = !terminal && (interrupted || (row.state === 'running' && Date.now() - Number(row.updated_at) > interruptionTimeoutMs));
+    const stale = !terminal && interrupted;
     const state = terminal ? row.lifecycle : stale ? 'unknown' : row.state;
     return { operationId: row.id, tool: row.tool, state, result: json(row.result), lifecycle: {
       state: interrupted && !terminal ? 'unknown' : row.lifecycle,
diff --git a/packages/api/test/mcpOperations.test.ts b/packages/api/test/mcpOperations.test.ts
index c5d50415d..408662827 100644
--- a/packages/api/test/mcpOperations.test.ts
+++ b/packages/api/test/mcpOperations.test.ts
@@ -535,6 +535,72 @@ test('interrupted accepted invocations become durable unknown while acknowledged
   assert.equal((resolved.lifecycle as { state: string }).state, 'accepted');
 });
 
+test('tracker-observed running operations remain active when their projection timestamp ages', async t => {
+  const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  await db.schema.createTable('task_drafts', table => table.string('draft_id').primary());
+  await db.schema.createTable('tasks', table => {
+    table.string('task_id').primary(); table.string('job_id'); table.string('repository'); table.string('task_type');
+    table.integer('pr_number'); table.text('initial_job_data'); table.timestamp('created_at').defaultTo(db.fn.now());
+  });
+  await db.schema.createTable('task_history', table => {
+    table.increments('history_id').primary(); table.string('task_id'); table.string('state');
+    table.timestamp('timestamp'); table.text('reason'); table.text('metadata');
+  });
+  await up(db);
+
+  const operations = new McpOperations(db);
+  const principal = { user: { id: 'alice' }, grant: { id: 'grant-a' } } as McpPrincipal;
+  const args = { idempotencyKey: 'long-running-tracker-1' };
+  const receipt = await operations.run(principal, {
+    tool: 'send_task_followup', args, repository: 'acme/repo',
+  }, async () => ({ status: 202, data: {
+    state: 'queued', jobId: 'long-running-job', continuation: { taskId: 'long-running-task' },
+  } }));
+  await db('tasks').insert({
+    task_id: 'long-running-task', job_id: 'long-running-job', repository: 'acme/repo', task_type: 'issue',
+    initial_job_data: JSON.stringify({}),
+  });
+  await db('task_history').insert({
+    task_id: 'long-running-task', state: 'processing', timestamp: new Date(), reason: 'Task is still running',
+  });
+  const deps = { db, policy: { repository: async () => {}, requirePermission: () => {}, config: {} } as never,
+    taskQueue: {} as never, redisClient: {} as never, runtimeBuildQueue: {} as never } as ToolDeps;
+  const catalog = createToolCatalog(deps);
+  const get = catalog.find(tool => tool.name === 'get_operation')!;
+  const list = catalog.find(tool => tool.name === 'list_operations')!;
+
+  const polled = (await get.run({
+    principal, args: get.schema.parse({ operationId: receipt.operationId }),
+  })).data as Record<string, unknown>;
+  assert.equal(polled.state, 'running');
+  assert.equal((polled.lifecycle as { state: string }).state, 'running');
+
+  await db('mcp_operations').where({ id: receipt.operationId }).update({ updated_at: Date.now() - 120_001 });
+  const assertRunning = (projected: Record<string, unknown> | undefined) => {
+    assert.equal(projected?.state, 'running');
+    assert.equal((projected?.lifecycle as { state: string }).state, 'running');
+    assert.equal(projected?.retryAfterSeconds, 3);
+    assert.equal(projected?.message, undefined);
+  };
+
+  const active = (await list.run({
+    principal, args: list.schema.parse({ lifecycle: 'active' }),
+  })).data as { operations: Array<Record<string, unknown>> };
+  assertRunning(active.operations.find(operation => operation.operationId === receipt.operationId));
+  assertRunning(await operations.replay(principal, 'send_task_followup', args));
+
+  let invoked = false;
+  const duplicate = await operations.run(principal, {
+    tool: 'send_task_followup', args, repository: 'acme/repo',
+  }, async () => {
+    invoked = true;
+    return { status: 200, data: {} };
+  });
+  assert.equal(invoked, false);
+  assertRunning(duplicate);
+});
+
 test('tracker uncertainty resolves from later evidence and preserves observed timestamps and terminal outcomes', async t => {
   const db = knex({ client: 'better-sqlite3', connection: { filename: ':memory:' }, useNullAsDefault: true });
   t.after(() => db.destroy());