elanous 0.2.0 → 0.2.5

package/src/task-orchestrator/runtimes/create.ts

@@ -10,9 +10,14 @@ import {
   type TaskSurface,
   type TaskPriority,
   type TaskIsolation,
+  TASK_DEFAULTS,
 } from '../types.js';
 import { getToxRuntimeDeps } from '../runtime-deps.js';
+import type { TaskGraph } from '../graph.js';
+import { debug } from '../../debug/log.js';
 import { taskToWorkflowEntry } from '../task-to-workflow.js';
+import { TaskStore } from '../store.js';
+import { decideExternalApproval, externalTaskPrompt, isExternalProvider, type ExternalTaskContext } from '../external-policy.js';
 import type { WorkflowRuntimeDaemon } from '../../workflow-runtime/daemon.js';
 
 export interface TaskCreateInput {
@@ -27,12 +32,18 @@ export interface TaskCreateInput {
   estimateTokens?: number;
   estimateUsd?: number;
   scheduleText?: string;
+  external?: ExternalTaskContext;
+  /** The HTTP default prompt repeats title/description; it is not caller-provided content. */
+  externalSurfaceDefaulted?: boolean;
+  eventId?: string;
+  traceId?: string;
 }
 
 export interface TaskCreateResult {
   output: string;
   taskId?: string;
   task?: Task;
+  deduplicated?: boolean;
 }
 
 export async function dispatchTaskCreate(
@@ -46,6 +57,17 @@ export async function dispatchTaskCreate(
   if (!isTaskSurface(input.surface)) {
     return { output: 'TaskCreate: surface must be a valid TaskSurface tagged union' };
   }
+  if (input.external) {
+    if (!isExternalProvider(input.external.provider)) return { output: 'TaskCreate: external.provider is invalid' };
+    if (!input.external.ref?.trim()) return { output: 'TaskCreate: external.ref is required' };
+    if (input.surface.kind !== 'llm-direct') {
+      return { output: 'TaskCreate: external tasks require llm-direct surface' };
+    }
+    if (input.surface.model !== undefined || input.surface.systemPrompt !== undefined) {
+      return { output: 'TaskCreate: external tasks cannot set model or systemPrompt' };
+    }
+    return createExternalTask(input, graph);
+  }
 
   const task = createTask({
     title: input.title,
@@ -113,6 +135,112 @@ export async function dispatchTaskCreate(
   };
 }
 
+const externalCreateLocks = new Map<string, Promise<void>>();
+
+async function createExternalTask(input: TaskCreateInput, graph: TaskGraph): Promise<TaskCreateResult> {
+  const external = input.external!;
+  const key = JSON.stringify([external.provider, external.ref]);
+  const previous = externalCreateLocks.get(key);
+  let release!: () => void;
+  const finished = new Promise<void>((resolve) => { release = resolve; });
+  externalCreateLocks.set(key, finished);
+  if (previous) await previous;
+  try {
+    return createExternalTaskLocked(input, graph);
+  } finally {
+    if (externalCreateLocks.get(key) === finished) externalCreateLocks.delete(key);
+    release();
+  }
+}
+
+function createExternalTaskLocked(input: TaskCreateInput, graph: TaskGraph): TaskCreateResult {
+  const external = input.external!;
+  if (input.title.length > TASK_DEFAULTS.titleMaxLen || (input.description?.length ?? 0) > TASK_DEFAULTS.descriptionMaxLen || input.priority === 'urgent') {
+    return { output: 'TaskCreate: invalid external task title, description or unchecked urgent priority' };
+  }
+  const store = getToxRuntimeDeps().getStore?.() as TaskStore | null | undefined;
+  let ownedStore: TaskStore | null = null;
+  try {
+    ownedStore = store ? null : new TaskStore();
+    const db = (store ?? ownedStore)!;
+    const surface: TaskSurface = {
+      kind: 'llm-direct',
+      prompt: externalTaskPrompt(external, input.title, input.description ?? '',
+        input.externalSurfaceDefaulted ? undefined : (input.surface as Extract<TaskSurface, { kind: 'llm-direct' }>).prompt),
+    };
+    // Keep lookup and persistence in one transaction; restore the graph if
+    // commit fails, without deleting another request's external identity.
+    let graphBefore: Task | undefined;
+    let changedId: string | undefined;
+    let changedTask: Task | undefined;
+    let result: TaskCreateResult;
+    try {
+      result = db.transaction((): TaskCreateResult => {
+        const existing = db.findTaskByExternalRef(external.provider, external.ref)
+          ?? graph.listAll().find((task) => task.generatedBy?.kind === 'external'
+            && task.generatedBy.provider === external.provider && task.generatedBy.ref === external.ref);
+        if (existing) {
+          const graphPrevious = graph.getTask(existing.id);
+          const current = graphPrevious ?? existing;
+          const content = { title: input.title, description: input.description ?? '', priority: input.priority ?? current.priority, surface };
+          const contentChanged = content.title !== current.title || content.description !== (current.description ?? '')
+            || content.priority !== current.priority || JSON.stringify(content.surface) !== JSON.stringify(current.surface);
+          // Approval covers the content and the rule match at that moment. For work that has not
+          // started, re-decide: an autoRun match now → ready · a person's approval of unchanged
+          // content stands · anything else waits for a person again (🅢 M1).
+          let approvalPatch: Partial<Task> = {};
+          if (current.status === 'backlog' || current.status === 'ready') {
+            const redecided = decideExternalApproval(external);
+            const approval = redecided.state === 'auto' ? redecided
+              : current.approval?.state === 'approved' && !contentChanged ? current.approval
+              : { state: 'pending' as const };
+            approvalPatch = { approval, status: approval.state === 'pending' ? 'backlog' : 'ready' };
+          }
+          // The source link travels with the item: a moved/renamed issue keeps its ref but not its URL.
+          const generatedBy = current.generatedBy?.kind === 'external' && external.url !== undefined && external.url !== current.generatedBy.url
+            ? { ...current.generatedBy, url: external.url } : undefined;
+          const patch: Partial<Task> = { ...content, ...approvalPatch, ...(generatedBy ? { generatedBy } : {}) };
+          const updated = { ...current, ...patch, updatedAt: Date.now() };
+          db.saveTask(updated);
+          graphBefore = graphPrevious;
+          changedId = existing.id;
+          if (graphPrevious) changedTask = graph.updateTask(existing.id, patch);
+          else { graph.addTask(updated); changedTask = updated; }
+          return { output: `TaskCreate: ${updated.id} deduplicated`, taskId: updated.id, task: updated, deduplicated: true };
+        }
+        const approval = decideExternalApproval(external);
+        const task = createTask({
+          title: input.title,
+          description: input.description,
+          surface,
+          priority: input.priority,
+          generatedBy: { kind: 'external', provider: external.provider, ref: external.ref, url: external.url },
+          approval,
+          status: approval.state === 'auto' ? 'ready' : 'backlog',
+        });
+        db.saveTask(task);
+        changedId = task.id;
+        graph.addTask(task);
+        changedTask = task;
+        return { output: `TaskCreate: ${task.id} created`, taskId: task.id, task, deduplicated: false };
+      });
+    } catch (err) {
+      if (changedId && graph.getTask(changedId) !== graphBefore
+        && (!changedTask || graph.getTask(changedId) === changedTask)) graph.restoreTask(changedId, graphBefore);
+      throw err;
+    }
+    debug.log('tox.external', result.deduplicated ? 'deduplicated' : 'created', {
+      provider: external.provider, ref: external.ref, taskId: result.taskId, approval: result.task?.approval,
+      eventId: input.eventId, traceId: input.traceId,
+    });
+    return result;
+  } catch (err) {
+    return { output: `TaskCreate failed: ${err instanceof Error ? err.message : String(err)}` };
+  } finally {
+    ownedStore?.close();
+  }
+}
+
 export function buildTaskCreateTool(): LLMToolSpec {
   return {
     name: 'TaskCreate',

package/src/task-orchestrator/store.ts

@@ -55,7 +55,8 @@ import type {
 // v2 (Phase 1 I6 · 2026-05-12) — tox_missions table + tox_tasks.mission_id column
 // v3 (Mission Fabric 통합 U1 · 2026-07-09) — tox_missions.autopilot_json
 //    (PFC Layer2 자율 메타 흡수 · apm Mission 병렬 table 제거 준비)
-export const TOX_SCHEMA_VERSION = 3;
+// v4 — external task identity and approval
+export const TOX_SCHEMA_VERSION = 4;
 
 // ─────────────────────── Row shapes ────────────────────────────────
 
@@ -89,6 +90,9 @@ interface TaskRow {
   review_verdicts_json: string | null;
   notes_json: string; // JSON array
   generated_by_json: string | null;
+  approval_json: string | null;
+  external_provider: string | null;
+  external_ref: string | null;
   trigger_chain_json: string;
 }
 
@@ -170,9 +174,19 @@ export class TaskStore {
       ensureDir(dirname(path));
     }
     this.db = new Database(path);
-    if (!opts.noWal && this.fileBacked) this.db.exec('PRAGMA journal_mode=WAL');
-    this.db.exec('PRAGMA foreign_keys=ON');
-    this.migrate();
+    this.db.exec('PRAGMA busy_timeout = 5000');
+    const openedAt = Date.now();
+    try {
+      if (!opts.noWal && this.fileBacked) this.db.exec('PRAGMA journal_mode=WAL');
+      this.db.exec('PRAGMA foreign_keys=ON');
+      this.migrate();
+    } catch (error) {
+      this.db.close();
+      if (/SQLITE_BUSY|SQLITE_LOCKED|database is locked|database is busy/i.test(String(error))) {
+        debug.log('store.sqlite', 'busy-lost', { store: 'tasks', op: 'open', waitedMs: Date.now() - openedAt });
+      }
+      throw error;
+    }
 
     if (this.fileBacked) {
       __tsFileOpenCount++;
@@ -298,6 +312,10 @@ export class TaskStore {
     this.addColumnIfMissing('tox_executions', 'host_id', 'TEXT');
     this.addColumnIfMissing('tox_executions', 'hostname', 'TEXT');
     this.db.exec('CREATE INDEX IF NOT EXISTS idx_tox_executions_host ON tox_executions(host_id, started_at)');
+    this.addColumnIfMissing('tox_tasks', 'approval_json', 'TEXT');
+    this.addColumnIfMissing('tox_tasks', 'external_provider', 'TEXT');
+    this.addColumnIfMissing('tox_tasks', 'external_ref', 'TEXT');
+    this.db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_tox_tasks_external_ref ON tox_tasks(external_provider, external_ref) WHERE external_provider IS NOT NULL AND external_ref IS NOT NULL');
     this.db.exec(`PRAGMA user_version = ${TOX_SCHEMA_VERSION}`);
   }
 
@@ -316,17 +334,47 @@ export class TaskStore {
 
   // ──────────────── Task CRUD ───────────────────────────────────
 
+  private observeBusyLoss<T>(op: string, work: () => T): T {
+    const startedAt = Date.now();
+    try { return work(); }
+    catch (error) {
+      if (/SQLITE_BUSY|SQLITE_LOCKED|database is locked|database is busy/i.test(String(error))) {
+        debug.log('store.sqlite', 'busy-lost', { store: 'tasks', op, waitedMs: Date.now() - startedAt });
+      }
+      throw error;
+    }
+  }
+
+  transaction<T>(work: () => T): T {
+    return this.observeBusyLoss('transaction', () => this.db.transaction(work)());
+  }
+
   saveTask(task: Task): void {
-    this.db
+    this.observeBusyLoss('saveTask', () => this.db
       .prepare(
-        `INSERT OR REPLACE INTO tox_tasks (
+        `INSERT INTO tox_tasks (
           id, created_at, updated_at, version, title, description, surface_json,
           parent_id, goal_slug, mission_id, depends_on_json, triggers_json, priority,
           estimate_ms, estimate_tokens, estimate_usd, feature_name, isolation,
           max_retries, attempt, timeout_ms, status, schedule_text, scheduler_job_id, last_execution_id,
           acceptance_json, review_verdicts_json, notes_json, generated_by_json,
-          trigger_chain_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+          trigger_chain_json, approval_json, external_provider, external_ref
+        ) VALUES (${Array(33).fill('?').join(', ')})
+        ON CONFLICT(id) DO UPDATE SET
+          created_at=excluded.created_at, updated_at=excluded.updated_at, version=excluded.version, title=excluded.title,
+          description=excluded.description, surface_json=excluded.surface_json,
+          parent_id=excluded.parent_id, goal_slug=excluded.goal_slug, mission_id=excluded.mission_id,
+          depends_on_json=excluded.depends_on_json, triggers_json=excluded.triggers_json,
+          priority=excluded.priority, estimate_ms=excluded.estimate_ms,
+          estimate_tokens=excluded.estimate_tokens, estimate_usd=excluded.estimate_usd,
+          feature_name=excluded.feature_name, isolation=excluded.isolation,
+          max_retries=excluded.max_retries, attempt=excluded.attempt, timeout_ms=excluded.timeout_ms,
+          status=excluded.status, schedule_text=excluded.schedule_text,
+          scheduler_job_id=excluded.scheduler_job_id, last_execution_id=excluded.last_execution_id,
+          acceptance_json=excluded.acceptance_json, review_verdicts_json=excluded.review_verdicts_json,
+          notes_json=excluded.notes_json, generated_by_json=excluded.generated_by_json,
+          trigger_chain_json=excluded.trigger_chain_json, approval_json=excluded.approval_json,
+          external_provider=excluded.external_provider, external_ref=excluded.external_ref`
       )
       .run(
         task.id,
@@ -358,8 +406,17 @@ export class TaskStore {
         task.reviewVerdicts ? JSON.stringify(task.reviewVerdicts) : null,
         JSON.stringify(task.notes),
         task.generatedBy ? JSON.stringify(task.generatedBy) : null,
-        JSON.stringify([...task.triggerChain])
-      );
+        JSON.stringify([...task.triggerChain]),
+        task.approval ? JSON.stringify(task.approval) : null,
+        task.generatedBy?.kind === 'external' ? task.generatedBy.provider : null,
+        task.generatedBy?.kind === 'external' ? task.generatedBy.ref : null,
+      ));
+  }
+
+  findTaskByExternalRef(provider: string, ref: string): Task | null {
+    const row = this.db.prepare('SELECT * FROM tox_tasks WHERE external_provider = ? AND external_ref = ?')
+      .get(provider, ref) as TaskRow | undefined;
+    return row ? this.rowToTask(row) : null;
   }
 
   getTask(id: string): Task | null {
@@ -390,7 +447,7 @@ export class TaskStore {
   }
 
   deleteTask(id: string): boolean {
-    const res = this.db.prepare('DELETE FROM tox_tasks WHERE id = ?').run(id);
+    const res = this.observeBusyLoss('deleteTask', () => this.db.prepare('DELETE FROM tox_tasks WHERE id = ?').run(id));
     return res.changes > 0;
   }
 
@@ -412,7 +469,7 @@ export class TaskStore {
     if (hostname === undefined) {
       try { hostname = osHostname(); } catch { /* Origin resolution must not block persistence. */ }
     }
-    this.db
+    this.observeBusyLoss('saveExecution', () => this.db
       .prepare(
         `INSERT OR REPLACE INTO tox_executions (
           id, task_id, started_at, ended_at, duration_ms, status, surface_json,
@@ -438,7 +495,7 @@ export class TaskStore {
         exec.modelId ?? null,
         hostId ?? null,
         hostname ?? null
-      );
+      ));
   }
 
   getExecution(id: string): TaskExecution | null {
@@ -463,7 +520,7 @@ export class TaskStore {
   appendEvent(event: TaskEvent): number {
     const goalSlug =
       (event as { goalSlug?: string | null }).goalSlug ?? null;
-    const res = this.db
+    const res = this.observeBusyLoss('appendEvent', () => this.db
       .prepare(
         `INSERT INTO tox_events (kind, timestamp, task_id, goal_slug, payload_json)
          VALUES (?, ?, ?, ?, ?)`
@@ -474,7 +531,7 @@ export class TaskStore {
         event.taskId ?? null,
         goalSlug,
         JSON.stringify(event)
-      );
+      ));
     return Number(res.lastInsertRowid);
   }
 
@@ -525,7 +582,7 @@ export class TaskStore {
   // ──────────────── Mission CRUD (Phase 1 I6 · v2) ──────────────
 
   saveMission(mission: Mission): void {
-    this.db
+    this.observeBusyLoss('saveMission', () => this.db
       .prepare(
         `INSERT OR REPLACE INTO tox_missions (
           id, created_at, updated_at, closed_at, title, description, intent,
@@ -548,7 +605,7 @@ export class TaskStore {
         mission.goalSlug ?? null,
         JSON.stringify([...mission.notes]),
         mission.autopilot ? JSON.stringify(mission.autopilot) : null,
-      );
+      ));
   }
 
   getMission(id: string): Mission | null {
@@ -579,7 +636,7 @@ export class TaskStore {
   }
 
   deleteMission(id: string): boolean {
-    const res = this.db.prepare('DELETE FROM tox_missions WHERE id = ?').run(id);
+    const res = this.observeBusyLoss('deleteMission', () => this.db.prepare('DELETE FROM tox_missions WHERE id = ?').run(id));
     return res.changes > 0;
   }
 
@@ -651,6 +708,9 @@ export class TaskStore {
       generatedBy: row.generated_by_json
         ? (JSON.parse(row.generated_by_json) as TaskGeneratedBy)
         : undefined,
+      approval: row.approval_json
+        ? (JSON.parse(row.approval_json) as Task['approval'])
+        : undefined,
       triggerChain: Object.freeze(JSON.parse(row.trigger_chain_json) as string[]),
     };
   }

package/src/task-orchestrator/surface-registry.ts

@@ -52,10 +52,13 @@ export interface DispatchContext {
 }
 
 /** An adapter is a pure-ish function bound to one surface kind. */
-export type SurfaceAdapter = (
+export type SurfaceAdapter = ((
   task: Task,
   ctx: DispatchContext
-) => Promise<DispatchResult>;
+) => Promise<DispatchResult>) & {
+  /** Admission check before the dispatcher changes ready → running. */
+  deferReason?: (task: Task) => 'intake-sequential' | undefined;
+};
 
 /**
  * In-memory registry with a singleton escape for dashboard boot.

package/src/task-orchestrator/surfaces/external-exec.ts

@@ -0,0 +1,180 @@
+import { debug } from '../../debug/log.js';
+import type { DispatchContext, SurfaceAdapter } from '../surface-registry.js';
+import { createExecution, type Task, type TaskExecution } from '../types.js';
+import type { DaemonToolDispatchCtx } from '../../boot/daemon-tools/types.js';
+import { createSubagentAdapter, type SubagentCallable } from './subagent.js';
+import { externalTaskFingerprint } from '../external-fingerprint.js';
+import { approvedExternalTaskPrompt } from '../external-policy.js';
+import { finalize, type IdeaApprovalGh } from './idea-approval-pr.js';
+
+const RUN_OUTCOME_INSTRUCTION = '\n\nOn the final line of your response, report the outcome as JSON: {"outcome":"done"} only if the requested work is done; otherwise {"outcome":"not-done"}.';
+
+function reportedDone(output: string | undefined): boolean {
+  const lastLine = output?.trim().split(/\r?\n/).at(-1);
+  if (!lastLine) return false;
+  try {
+    const result: unknown = JSON.parse(lastLine);
+    return !!result && typeof result === 'object' && !Array.isArray(result)
+      && (result as Record<string, unknown>).outcome === 'done';
+  } catch {
+    return false;
+  }
+}
+
+export function triageExternalTask(task: Task): 'dev' | 'run' {
+  if (/\[dev\]/i.test(task.title)) return 'dev';
+  return 'run';
+}
+
+export type ExternalDevDispatch = (
+  args: Record<string, unknown>,
+  ctx: DaemonToolDispatchCtx & { autoMerge?: boolean },
+) => Promise<unknown>;
+
+export function createExternalExecAdapter(opts: {
+  dispatch: ExternalDevDispatch;
+  cwd: string;
+  subagent: SubagentCallable;
+  ideaApprovalPr?: { finalize: (input: { prUrl: string; task: Task; runId?: string; ok: boolean }) => ReturnType<typeof finalize> };
+  gh?: IdeaApprovalGh;
+  now?: () => number;
+}): SurfaceAdapter {
+  const now = opts.now ?? Date.now;
+  const run = createSubagentAdapter({ callable: opts.subagent, now: opts.now });
+  const activeIntake = new Set<string>();
+  const isIntake = (task: Task) => task.generatedBy?.kind === 'external' && String(task.generatedBy.provider) === 'intake';
+
+  const adapter: SurfaceAdapter = async (task: Task, ctx: DispatchContext) => {
+    if (task.surface.kind !== 'llm-direct') {
+      throw new Error(`external-exec adapter received wrong kind: ${task.surface.kind}`);
+    }
+    const surface = task.surface;
+    const lane = triageExternalTask(task);
+    debug.log('tox.external-exec', 'triaged', {
+      taskId: task.id, lane, priority: task.priority,
+      provider: task.generatedBy?.kind === 'external' ? task.generatedBy.provider : undefined,
+    });
+    if (isIntake(task)) activeIntake.add(task.id);
+    try {
+      if (task.approval?.state === 'approved' && task.approval.approvedBy === 'manual'
+          && task.approval.fingerprint !== externalTaskFingerprint(task)) {
+        const exec = createExecution(task, { now: now() });
+        const reason = 'approved external task content changed since approval';
+        const end = now();
+        debug.log('tox.external-exec', 'run-finished', { taskId: task.id, lane, ok: false, reason });
+        activeIntake.delete(task.id);
+        return {
+          executionId: exec.id,
+          promise: Promise.resolve({
+            ...exec, endedAt: end, durationMs: end - exec.startedAt,
+            status: 'failed' as const, error: { code: 'APPROVAL_FINGERPRINT_CHANGED', message: reason },
+          }),
+        };
+      }
+      // Manually approved ⊕ fingerprint matched (checked above): rebuild from the approved fields — the stored
+      // surface prompt is only used for unapproved/auto tasks, which keep the untrusted-reference wrapping.
+      const approvedPrompt = task.approval?.state === 'approved' && task.approval.approvedBy === 'manual' && task.generatedBy?.kind === 'external'
+        ? approvedExternalTaskPrompt({ provider: task.generatedBy.provider, ref: task.generatedBy.ref }, task.title, task.description ?? '')
+        : undefined;
+      const prompt = approvedPrompt ?? surface.prompt;
+      // The execution record carries the prompt that actually ran, not the stored one it replaced.
+      const ranSurface = { ...surface, prompt };
+      debug.log('tox.external-exec', 'prompt-selected', { taskId: task.id, lane, source: approvedPrompt ? 'approved' : 'stored' });
+      if (lane === 'dev') {
+        const exec = createExecution({ ...task, surface: ranSurface }, { now: now() });
+        const promise: Promise<TaskExecution> = (async () => {
+          try {
+            const raw = await opts.dispatch({ feature: task.title }, {
+              cwd: opts.cwd, signal: ctx.signal ?? new AbortController().signal, userText: prompt, autoMerge: !isIntake(task),
+            });
+            const result = raw && typeof raw === 'object' ? raw as Record<string, unknown> : {};
+            const runId = typeof result.runId === 'string' ? result.runId : undefined;
+            const prUrl = typeof result.prUrl === 'string' ? result.prUrl : undefined;
+            const ok = result.ok === true;
+            let finalizeError: string | undefined;
+            if (isIntake(task)) {
+              if (ok && !prUrl) {
+                finalizeError = 'idea-pr-finalize: successful intake run returned no PR URL';
+              } else if (prUrl) {
+                try {
+                  if (ok && !opts.ideaApprovalPr && !opts.gh) throw new Error('gh executor not configured');
+                  const finalized = await (opts.ideaApprovalPr?.finalize({ prUrl, task, runId, ok })
+                    ?? finalize({ prUrl, task, runId, ok, gh: opts.gh! }));
+                  if (ok) {
+                    if (!finalized.ready || !finalized.labeled) throw new Error('PR not ready and labeled for approval');
+                    debug.log('tox.external-exec', 'idea-pr-finalized', { taskId: task.id, ...finalized });
+                  }
+                } catch (error) {
+                  finalizeError = `idea-pr-finalize: ${error instanceof Error ? error.message : String(error)}`;
+                }
+              }
+            }
+            const output = JSON.stringify({ runId, prUrl, ok });
+            const reason = typeof result.error === 'string' ? result.error
+              : typeof result.detail === 'string' ? result.detail : 'self-implement did not succeed';
+            const end = now();
+            return {
+              ...exec, endedAt: end, durationMs: end - exec.startedAt,
+              status: ctx.signal?.aborted ? 'cancelled' : ok ? 'completed' : 'failed',
+              output,
+              ...(ok && finalizeError ? { reviewRequired: true } : {}),
+              ...(runId ? { surfaceAddress: `self-impl:${runId}` } : {}),
+              ...(ctx.signal?.aborted
+                ? { error: { code: 'ABORTED', message: 'cancelled by caller' } }
+                : !ok ? { error: { code: 'SELF_IMPL_FAILED', message: finalizeError ? `${reason}; ${finalizeError}` : reason } }
+                : finalizeError ? { error: { code: 'IDEA_PR_FINALIZE_FAILED', message: finalizeError } } : {}),
+            };
+          } catch (error) {
+            const end = now();
+            return {
+              ...exec, endedAt: end, durationMs: end - exec.startedAt,
+              status: ctx.signal?.aborted ? 'cancelled' : 'failed',
+              error: { code: ctx.signal?.aborted ? 'ABORTED' : 'SELF_IMPL_FAILED', message: error instanceof Error ? error.message : String(error) },
+            };
+          }
+        })();
+        return {
+          executionId: exec.id,
+          promise: promise.then((result) => {
+            debug.log('tox.external-exec', 'run-finished', {
+              taskId: task.id, lane, ok: result.status === 'completed',
+              ...(result.error ? { reason: result.error.message } : {}),
+            });
+            return result;
+          }).finally(() => { activeIntake.delete(task.id); }),
+        };
+      }
+      const delegated: Task = {
+        ...task,
+        surface: { kind: 'subagent', definitionName: 'general-purpose', prompt: prompt + RUN_OUTCOME_INSTRUCTION },
+      };
+      const result = await run(delegated, ctx);
+      return {
+        ...result,
+        promise: result.promise.then((exec) => {
+          const reason = exec.status === 'failed'
+            ? exec.output?.slice(0, 500) || exec.error?.message || 'subagent failed'
+            : undefined;
+          const completed: TaskExecution = {
+            ...exec, surface: ranSurface,
+            ...(exec.status === 'completed' && !reportedDone(exec.output)
+              ? { reviewRequired: true } : {}),
+            ...(reason ? { error: { code: exec.error?.code ?? 'SUBAGENT_FAILED', message: reason } } : {}),
+          };
+          debug.log('tox.external-exec', 'run-finished', {
+            taskId: task.id, lane, ok: completed.status === 'completed' && !completed.reviewRequired,
+            ...(completed.reviewRequired ? { reason: 'final-line done outcome absent; execution requires review' } : {}),
+            ...(completed.error ? { reason: completed.error.message } : {}),
+          });
+          return completed;
+        }).finally(() => { activeIntake.delete(task.id); }),
+      };
+    } catch (error) {
+      activeIntake.delete(task.id);
+      throw error;
+    }
+  };
+  adapter.deferReason = (task) => isIntake(task) && activeIntake.size > 0
+    ? 'intake-sequential' : undefined;
+  return adapter;
+}