kiokuko-dsh 0.2.25 → 0.2.27

package/dist/dsh/host-adapter/lifecycle.js

@@ -1,33 +1,39 @@
-import { readTaskSnapshot } from '../task-state.js';
-import { dshTurnBoundarySeq } from '../session-memory-finalizer.js';
-import { withImmediateTransaction } from '../../db/transaction.js';
-import { LedgerStore } from '../../ledger/store.js';
-import { terminalizeLedgerRunInTransaction } from '../../enno-oduno/store.js';
-import { KiokukoError } from '../../errors.js';
-import { saveTaskCompletionReceipt, taskCompletionBlocksClose } from '../task-completion.js';
-import { readCodingWorkflow } from '../coding-workflow/store.js';
-import { stopCodingWorkflow, synchronizeCodingWorkflow } from '../coding-workflow/service.js';
-import { saveSessionNotice } from '../plugin-records.js';
-import { canonicalContentHash } from '../../serialization/validate.js';
-import { DshRunLifecycle } from '../session-bridge.js';
+import { readTaskSnapshot, } from "../task-state.js";
+import { dshTurnBoundarySeq } from "../session-memory-finalizer.js";
+import { withImmediateTransaction } from "../../db/transaction.js";
+import { LedgerStore } from "../../ledger/store.js";
+import { terminalizeLedgerRunInTransaction } from "../../enno-oduno/store.js";
+import { KiokukoError } from "../../errors.js";
+import { saveTaskCompletionReceipt, taskCompletionBlocksClose, } from "../task-completion.js";
+import { readCodingWorkflow } from "../coding-workflow/store.js";
+import { stopCodingWorkflow, synchronizeCodingWorkflow, } from "../coding-workflow/service.js";
+import { saveSessionNotice } from "../plugin-records.js";
+import { canonicalContentHash } from "../../serialization/validate.js";
+import { DshRunLifecycle, } from "../session-bridge.js";
 function currentCloseAuthority(database, runId, authority) {
     if (!authority)
-        return database.prepare('SELECT task_managed FROM ledger_runs WHERE run_id=?').get(runId)?.task_managed !== 1;
+        return (database
+            .prepare("SELECT task_managed FROM ledger_runs WHERE run_id=?")
+            .get(runId)?.task_managed !== 1);
     if (authority.taskId !== runId)
         return false;
     try {
         const current = readTaskSnapshot(database, authority);
-        return current.revision === authority.revision && current.generation === authority.generation && !current.pendingStop;
+        return (current.revision === authority.revision &&
+            current.generation === authority.generation &&
+            !current.pendingStop);
     }
     catch {
         return false;
     }
 }
-function closeAuthority(item) { return item.authority ? { authority: item.authority } : {}; }
+function closeAuthority(item) {
+    return item.authority ? { authority: item.authority } : {};
+}
 export function createLifecycle(deps) {
-    const { runtime, sessions, sessionMirror, autoReview, answerReview, ennoController, ennoMemory, executionSupport, gate, turnState, currentSession, currentForAgentEvent, stateForRun, deliverCompletionReport, reviewBinding, clearToolRun, sessionEventSource } = deps;
+    const { runtime, sessions, sessionMirror, autoReview, answerReview, ennoController, ennoMemory, executionSupport, gate, turnState, currentSession, currentForAgentEvent, stateForRun, deliverCompletionReport, reviewBinding, clearToolRun, sessionEventSource, } = deps;
     const getSelection = deps.getSelection;
-    const completionReady = async (item) => runtime.withDatabase(database => {
+    const completionReady = async (item) => runtime.withDatabase((database) => {
         if (!currentCloseAuthority(database, item.runId, item.authority))
             return false;
         try {
@@ -35,17 +41,28 @@ export function createLifecycle(deps) {
             const assessment = saveTaskCompletionReceipt(database, item.runId);
             if (!taskCompletionBlocksClose(assessment))
                 return true;
-            const unresolved = assessment.criteria.filter(criterion => criterion.state !== 'satisfied');
-            const text = `完了条件の検証待ちです。未確認: ${unresolved.map(criterion => criterion.description).join(' / ').slice(0, 4000)}。task_completion status で根拠を確認し、検証方法を登録してください。`;
-            saveSessionNotice(database, { id: `completion-wait:${canonicalContentHash({ runId: item.runId, unresolved })}`,
-                runId: item.runId, sessionId: item.sessionId, rootPath: item.cwd, kind: 'status', text, anchorSeq: 0 });
+            const unresolved = assessment.criteria.filter((criterion) => criterion.state !== "satisfied");
+            const text = `完了条件の検証待ちです。未確認: ${unresolved
+                .map((criterion) => criterion.description)
+                .join(" / ")
+                .slice(0, 4000)}。task_completion status で根拠を確認し、検証方法を登録してください。`;
+            saveSessionNotice(database, {
+                id: `completion-wait:${canonicalContentHash({ runId: item.runId, unresolved })}`,
+                runId: item.runId,
+                sessionId: item.sessionId,
+                rootPath: item.cwd,
+                kind: "status",
+                text,
+                anchorSeq: 0,
+            });
             return false;
         }
         catch {
             // A missing or corrupt new completion assessment never grants an opted-in
             // enforce run a verified terminal state. Legacy/shadow close as before.
-            return database.prepare('SELECT mode FROM dsh_completion_runs WHERE run_id = ?')
-                .get(item.runId)?.mode !== 'enforce';
+            return (database
+                .prepare("SELECT mode FROM dsh_completion_runs WHERE run_id = ?")
+                .get(item.runId)?.mode !== "enforce");
         }
     });
     const resolveIdleClose = async (agentId, sessionId, nativeSession, nativeAgent) => {
@@ -53,34 +70,58 @@ export function createLifecycle(deps) {
             return undefined;
         await deliverCompletionReport(nativeSession);
         const item = currentForAgentEvent(agentId, sessionId, undefined, nativeSession, nativeAgent);
-        if (item === undefined || item.closed || executionSupport.paused(item.sessionId))
+        if (item === undefined ||
+            item.closed ||
+            executionSupport.paused(item.sessionId))
             return undefined;
         if (nativeAgent && answerReview.hold(nativeAgent))
             return undefined;
         const selection = getSelection(item.runId)?.value;
         if (selection?.discussion)
             return undefined;
-        if (selection && (selection.status !== 'ready' && item.prepared.intake.profile.taskType !== 'chat' || item.failed && selection.mode === 'normal'))
+        if (selection &&
+            ((selection.status !== "ready" &&
+                item.prepared.intake.profile.taskType !== "chat") ||
+                (item.failed && selection.mode === "normal")))
             return undefined;
         const state = await runtime.withDatabase((database) => stateForRun(database, item));
-        const coding = await runtime.withDatabase(db => readCodingWorkflow(db, item.runId));
-        if (coding?.state === 'cancelled' || coding?.state === 'superseded')
-            return { ...closeAuthority(item), runId: item.runId, status: 'cancelled', terminalTurn: item.turn };
-        if (state.status === 'cancelled')
-            return { ...closeAuthority(item), runId: item.runId, status: 'cancelled' };
-        if (state.status === 'blocked' || state.nextAction === 'report_blocker')
-            return { ...closeAuthority(item), runId: item.runId, status: 'failed', terminalTurn: item.turn };
+        const coding = await runtime.withDatabase((db) => readCodingWorkflow(db, item.runId));
+        if (coding?.state === "cancelled" || coding?.state === "superseded")
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "cancelled",
+                terminalTurn: item.turn,
+            };
+        if (state.status === "cancelled")
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "cancelled",
+            };
+        if (state.status === "blocked" || state.nextAction === "report_blocker")
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "failed",
+                terminalTurn: item.turn,
+            };
         // A chat run spans the quiet time between user messages. Enno's
         // inapplicable `complete` means that no orchestration is required for this
         // turn; it does not mean that the persistent conversation has ended.
-        if (item.prepared.intake.profile.taskType === 'chat')
+        if (item.prepared.intake.profile.taskType === "chat")
             return undefined;
-        if (state.status === 'completed' || state.nextAction === 'complete') {
-            if (!await completionReady(item))
+        if (state.status === "completed" || state.nextAction === "complete") {
+            if (!(await completionReady(item)))
                 return undefined;
             // A provider failure while wording the final response cannot undo
             // already verified completion. The durable host report covers it.
-            return { ...closeAuthority(item), runId: item.runId, status: 'completed', terminalTurn: item.turn };
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "completed",
+                terminalTurn: item.turn,
+            };
         }
         // Idle means the driver has no active work, not that Enno reached a
         // terminal state. Keep only genuinely resumable active states open.
@@ -95,65 +136,102 @@ export function createLifecycle(deps) {
     const resolveSessionClose = async (sessionId, nativeSession) => {
         answerReview.cancel(sessionId);
         const item = currentSession(sessionId);
-        if (item === undefined || item.closed || item.nativeSession !== nativeSession)
+        if (item === undefined ||
+            item.closed ||
+            item.nativeSession !== nativeSession)
             return undefined;
-        if (executionSupport.paused(item.sessionId) || getSelection(item.runId)?.value.status !== undefined && getSelection(item.runId)?.value.status !== 'ready') {
-            const end = await sessionMirror.latestEvent(sessionId, 'turn/end', Number.MAX_SAFE_INTEGER);
+        if (executionSupport.paused(item.sessionId) ||
+            (getSelection(item.runId)?.value.status !== undefined &&
+                getSelection(item.runId)?.value.status !== "ready")) {
+            const end = await sessionMirror.latestEvent(sessionId, "turn/end", Number.MAX_SAFE_INTEGER);
             if (end)
-                autoReview.notify(reviewBinding(item, nativeSession), end.seq, 'boundary');
+                autoReview.notify(reviewBinding(item, nativeSession), end.seq, "boundary");
             return undefined;
         }
         const state = await runtime.withDatabase((database) => stateForRun(database, item));
-        if (state.status === 'completed') {
-            if (!await completionReady(item))
+        if (state.status === "completed") {
+            if (!(await completionReady(item)))
                 return undefined;
             await deliverCompletionReport(nativeSession);
-            return { ...closeAuthority(item), runId: item.runId, status: 'completed', terminalTurn: item.turn };
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "completed",
+                terminalTurn: item.turn,
+            };
         }
         if (item.failed)
-            return { ...closeAuthority(item), runId: item.runId, status: 'failed', terminalTurn: item.turn };
-        if (state.status === 'cancelled')
-            return { ...closeAuthority(item), runId: item.runId, status: 'cancelled' };
-        if (state.status === 'blocked' || state.nextAction === 'report_blocker')
-            return { ...closeAuthority(item), runId: item.runId, status: 'failed', terminalTurn: item.turn };
-        if (item.prepared.intake.profile.taskType === 'chat' || state.nextAction === 'complete') {
-            if (item.prepared.intake.profile.taskType !== 'chat' && !await completionReady(item))
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "failed",
+                terminalTurn: item.turn,
+            };
+        if (state.status === "cancelled")
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "cancelled",
+            };
+        if (state.status === "blocked" || state.nextAction === "report_blocker")
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "failed",
+                terminalTurn: item.turn,
+            };
+        if (item.prepared.intake.profile.taskType === "chat" ||
+            state.nextAction === "complete") {
+            if (item.prepared.intake.profile.taskType !== "chat" &&
+                !(await completionReady(item)))
                 return undefined;
-            return { ...closeAuthority(item), runId: item.runId, status: 'completed', terminalTurn: item.turn };
+            return {
+                ...closeAuthority(item),
+                runId: item.runId,
+                status: "completed",
+                terminalTurn: item.turn,
+            };
         }
-        return { ...closeAuthority(item), runId: item.runId, status: 'cancelled' };
+        return { ...closeAuthority(item), runId: item.runId, status: "cancelled" };
     };
     const closeRun = async (input) => {
         let committedAuthority;
         const committed = await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
             if (!currentCloseAuthority(database, input.runId, input.authority))
                 return false;
-            if (input.status === 'cancelled')
-                stopCodingWorkflow(database, input.runId, 'cancelled');
+            if (input.status === "cancelled")
+                stopCodingWorkflow(database, input.runId, "cancelled");
             let completionBlocked;
             try {
                 completionBlocked = taskCompletionBlocksClose(saveTaskCompletionReceipt(database, input.runId));
             }
             catch {
-                completionBlocked = database.prepare('SELECT mode FROM dsh_completion_runs WHERE run_id=?').get(input.runId)?.mode === 'enforce';
+                completionBlocked =
+                    database
+                        .prepare("SELECT mode FROM dsh_completion_runs WHERE run_id=?")
+                        .get(input.runId)?.mode === "enforce";
             }
-            if (input.status === 'completed' && completionBlocked)
-                throw new KiokukoError('CONFLICT', 'Required task completion evidence is unresolved');
+            if (input.status === "completed" && completionBlocked)
+                throw new KiokukoError("CONFLICT", "Required task completion evidence is unresolved");
             const store = new LedgerStore(database);
             const before = store.readRun(input.runId);
             if (before === undefined)
-                throw new KiokukoError('INTEGRITY_ERROR', 'Run close target does not exist');
-            if (before.status === 'intake' || before.status === 'active') {
+                throw new KiokukoError("INTEGRITY_ERROR", "Run close target does not exist");
+            if (before.status === "intake" || before.status === "active") {
                 terminalizeLedgerRunInTransaction(database, input.runId, input.status);
             }
             else if (before.status !== input.status) {
-                throw new KiokukoError('CONFLICT', 'Run close status is immutable');
+                throw new KiokukoError("CONFLICT", "Run close status is immutable");
             }
             // Native completion and authority have been checked independently.
             // A missing optional memory range cannot change the observed task outcome.
             if (input.authority) {
                 const closed = readTaskSnapshot(database, input.authority);
-                committedAuthority = { ...input.authority, revision: closed.revision, generation: closed.generation };
+                committedAuthority = {
+                    ...input.authority,
+                    revision: closed.revision,
+                    generation: closed.generation,
+                };
             }
             return true;
         }));
@@ -162,31 +240,50 @@ export function createLifecycle(deps) {
         const reviewFinishes = [];
         // The DB callback may resume after another client reopened this same run.
         // Run-wide caches must be retired atomically with a fresh generation check.
-        await runtime.withDatabase(database => {
+        await runtime.withDatabase((database) => {
             if (!currentCloseAuthority(database, input.runId, committedAuthority))
                 return;
             try {
                 autoReview.worker.abort(input.runId);
             }
-            catch { /* Optional memory cleanup cannot retain a task owner. */ }
-            const items = turnState.allTurns().filter(candidate => candidate.runId === input.runId
-                && (!input.authority || candidate.authority?.sessionId === input.authority.sessionId && candidate.authority.generation === input.authority.generation));
+            catch {
+                /* Optional memory cleanup cannot retain a task owner. */
+            }
+            const items = turnState
+                .allTurns()
+                .filter((candidate) => candidate.runId === input.runId &&
+                (!input.authority ||
+                    (candidate.authority?.sessionId === input.authority.sessionId &&
+                        candidate.authority.generation === input.authority.generation)));
             const committedSessionId = items[0]?.sessionId;
             if (committedSessionId)
                 try {
-                    deps.onRunClosed?.(input.runId, input.status, committedSessionId);
+                    deps.onRunClosed?.(input.runId, input.status, committedSessionId, committedAuthority &&
+                        readTaskSnapshot(database, committedAuthority).state === "Done"
+                        ? committedAuthority
+                        : undefined);
+                }
+                catch {
+                    /* optional memory observation */
                 }
-                catch { /* optional memory observation */ }
             for (const item of items) {
-                ennoController.retire({ ...(item.nativeAgent === undefined ? {} : { nativeAgent: item.nativeAgent }),
-                    ...(item.nativeSession === undefined ? {} : { nativeSession: item.nativeSession }) });
+                ennoController.retire({
+                    ...(item.nativeAgent === undefined
+                        ? {}
+                        : { nativeAgent: item.nativeAgent }),
+                    ...(item.nativeSession === undefined
+                        ? {}
+                        : { nativeSession: item.nativeSession }),
+                });
                 if (item.nativeAgent)
                     reviewFinishes.push(answerReview.finish(item.nativeAgent));
                 item.closed = true;
                 try {
                     ennoMemory.clear(item.runId);
                 }
-                catch { /* Optional memory cleanup cannot retain a task owner. */ }
+                catch {
+                    /* Optional memory cleanup cannot retain a task owner. */
+                }
                 executionSupport.clear(item.sessionId);
                 gate.clearTurn(item.sessionId, item.turn);
             }
@@ -196,9 +293,72 @@ export function createLifecycle(deps) {
         await Promise.all(reviewFinishes);
     };
     const runLifecycle = new DshRunLifecycle({ closeRun });
+    const completeTask = async (task) => {
+        const authority = await runtime.withDatabase((database) => {
+            const current = readTaskSnapshot(database, task);
+            if (current.state !== "Done" ||
+                task.state !== "Done" ||
+                current.pendingStop ||
+                current.revision !== task.revision ||
+                current.generation !== task.generation)
+                return undefined;
+            const item = currentSession(task.sessionId);
+            const agent = item?.nativeAgent;
+            if (!item ||
+                item.closed ||
+                item.runId !== task.taskId ||
+                item.sessionId !== task.sessionId ||
+                item.repositoryRoot !== task.repositoryRoot ||
+                !agent ||
+                agent.status !== "idle" ||
+                agent.session !== item.nativeSession ||
+                sessions?.get(task.sessionId) !== item.nativeSession ||
+                currentForAgentEvent(item.agentId, item.sessionId, undefined, item.nativeSession, agent) !== item)
+                return undefined;
+            const matches = (candidate) => {
+                const prior = candidate.authority;
+                return (candidate.runId === task.taskId &&
+                    candidate.sessionId === task.sessionId &&
+                    candidate.repositoryRoot === task.repositoryRoot &&
+                    candidate.nativeAgent === agent &&
+                    candidate.nativeSession === item.nativeSession &&
+                    !!prior &&
+                    prior.taskId === task.taskId &&
+                    prior.sessionId === task.sessionId &&
+                    prior.repositoryRoot === task.repositoryRoot &&
+                    ((prior.revision === task.revision &&
+                        prior.generation === task.generation) ||
+                        (prior.revision + 1 === task.revision &&
+                            prior.generation + 1 === task.generation)));
+            };
+            if (!matches(item))
+                return undefined;
+            const next = {
+                taskId: task.taskId,
+                sessionId: task.sessionId,
+                repositoryRoot: task.repositoryRoot,
+                revision: task.revision,
+                generation: task.generation,
+            };
+            // Explicit completion advances the task lease before the final native answer.
+            // Reconcile only its exact projection; closeRun independently rechecks it.
+            for (const candidate of turnState.allTurns())
+                if (matches(candidate))
+                    candidate.authority = next;
+            return next;
+        });
+        if (authority)
+            await runLifecycle.closeTurn({
+                runId: task.taskId,
+                status: "completed",
+                authority,
+            });
+    };
     const optionalSourceBoundary = (item) => {
         try {
-            return { sourceEndSeq: dshTurnBoundarySeq(sessionEventSource(item.nativeSession), item.turn, 'end') };
+            return {
+                sourceEndSeq: dshTurnBoundarySeq(sessionEventSource(item.nativeSession), item.turn, "end"),
+            };
         }
         catch {
             return {}; /* Incomplete source evidence stays unavailable to memory. */
@@ -212,7 +372,9 @@ export function createLifecycle(deps) {
             try {
                 await sessionMirror.checkpointAfterNativeFlush(item.nativeSession);
             }
-            catch { /* Optional mirror cannot veto native task closure. */ }
+            catch {
+                /* Optional mirror cannot veto native task closure. */
+            }
             return optionalSourceBoundary(item);
         }
         catch {
@@ -220,71 +382,97 @@ export function createLifecycle(deps) {
         }
     };
     const retireSupersededRun = async (item, status) => {
-        if (status === 'completed' && !await completionReady(item))
-            status = 'cancelled';
-        if (status !== 'completed') {
-            await runLifecycle.closeTurn({ ...closeAuthority(item), runId: item.runId, status, ...(status === 'failed' ? await failedBoundary(item) : {}) });
+        if (status === "completed" && !(await completionReady(item)))
+            status = "cancelled";
+        if (status !== "completed") {
+            await runLifecycle.closeTurn({
+                ...closeAuthority(item),
+                runId: item.runId,
+                status,
+                ...(status === "failed" ? await failedBoundary(item) : {}),
+            });
             return;
         }
         if (item.nativeSession === undefined || sessions?.flush === undefined) {
-            throw new KiokukoError('CONFLICT', 'Completed DSH run requires its exact native session checkpoint');
+            throw new KiokukoError("CONFLICT", "Completed DSH run requires its exact native session checkpoint");
         }
         await sessions.flush(item.nativeSession);
         try {
             await sessionMirror.checkpointAfterNativeFlush(item.nativeSession);
         }
-        catch { /* Optional mirror cannot veto native task closure. */ }
+        catch {
+            /* Optional mirror cannot veto native task closure. */
+        }
         await runLifecycle.closeTurn({
-            ...closeAuthority(item), runId: item.runId,
+            ...closeAuthority(item),
+            runId: item.runId,
             status,
             ...optionalSourceBoundary(item),
         });
     };
     const closeRemainingRuns = async (pausedSessions) => {
         const failures = [];
-        const remainingRuns = [...new Map(turnState.allTurns()
+        const remainingRuns = [
+            ...new Map(turnState
+                .allTurns()
                 .filter((item) => !item.closed && !pausedSessions.has(item.sessionId))
-                .map((item) => [item.runId, item])).values()];
+                .map((item) => [item.runId, item])).values(),
+        ];
         for (const item of remainingRuns) {
             try {
                 const selected = getSelection(item.runId)?.value;
                 if (selected) {
-                    const state = await runtime.withDatabase(db => stateForRun(db, item));
-                    if (selected.status !== 'ready'
-                        || selected.mode === 'enno' && !['completed', 'blocked', 'cancelled'].includes(state.status ?? '')
-                        || selected.mode === 'normal' && (item.failed || item.nativeAgent?.status === 'running'))
+                    const state = await runtime.withDatabase((db) => stateForRun(db, item));
+                    if (selected.status !== "ready" ||
+                        (selected.mode === "enno" &&
+                            !["completed", "blocked", "cancelled"].includes(state.status ?? "")) ||
+                        (selected.mode === "normal" &&
+                            (item.failed ||
+                                item.nativeAgent?.status ===
+                                    "running")))
                         continue;
                 }
                 let status;
-                if (item.prepared.intake.profile.taskType === 'chat')
-                    status = item.failed ? 'failed' : 'cancelled';
+                if (item.prepared.intake.profile.taskType === "chat")
+                    status = item.failed ? "failed" : "cancelled";
                 else {
                     const state = await runtime.withDatabase((database) => stateForRun(database, item));
-                    status = state.status === 'completed' || state.nextAction === 'complete'
-                        ? 'completed'
-                        : item.failed || state.status === 'blocked' || state.nextAction === 'report_blocker'
-                            ? 'failed'
-                            : 'cancelled';
+                    status =
+                        state.status === "completed" || state.nextAction === "complete"
+                            ? "completed"
+                            : item.failed ||
+                                state.status === "blocked" ||
+                                state.nextAction === "report_blocker"
+                                ? "failed"
+                                : "cancelled";
                 }
-                if (status === 'completed') {
-                    if (!await completionReady(item))
+                if (status === "completed") {
+                    if (!(await completionReady(item)))
                         continue;
                     await deliverCompletionReport(item.nativeSession);
-                    if (item.nativeSession === undefined || sessions?.flush === undefined) {
-                        throw new KiokukoError('CONFLICT', 'Completed DSH run requires its exact native session checkpoint');
+                    if (item.nativeSession === undefined ||
+                        sessions?.flush === undefined) {
+                        throw new KiokukoError("CONFLICT", "Completed DSH run requires its exact native session checkpoint");
                     }
                     await sessions.flush(item.nativeSession);
                     try {
                         await sessionMirror.checkpointAfterNativeFlush(item.nativeSession);
                     }
-                    catch { /* Optional mirror cannot veto native task closure. */ }
+                    catch {
+                        /* Optional mirror cannot veto native task closure. */
+                    }
                 }
                 await runLifecycle.closeTurn({
-                    ...closeAuthority(item), runId: item.runId,
+                    ...closeAuthority(item),
+                    runId: item.runId,
                     status,
-                    ...(status !== 'completed' ? status === 'failed' ? await failedBoundary(item) : {} : {
-                        ...optionalSourceBoundary(item),
-                    }),
+                    ...(status !== "completed"
+                        ? status === "failed"
+                            ? await failedBoundary(item)
+                            : {}
+                        : {
+                            ...optionalSourceBoundary(item),
+                        }),
                 });
             }
             catch (error) {
@@ -293,6 +481,14 @@ export function createLifecycle(deps) {
         }
         return failures;
     };
-    return { runLifecycle, resolveIdleClose, resolveSessionRunId, resolveSessionClose, retireSupersededRun, closeRemainingRuns };
+    return {
+        runLifecycle,
+        completeTask,
+        resolveIdleClose,
+        resolveSessionRunId,
+        resolveSessionClose,
+        retireSupersededRun,
+        closeRemainingRuns,
+    };
 }
 //# sourceMappingURL=lifecycle.js.map