@duetso/agent 0.2.4 → 0.2.6

package/dist/src/turn-runner/turn-runner.js

@@ -6,7 +6,9 @@ import { stripSystemReminders, systemReminder } from "../lib/system-reminder.js"
 import { assistantText } from "../core/serializer.js";
 import { classifyRoute } from "../model-routing/classifier.js";
 import { loadRoutingTable } from "../model-routing/loader.js";
-import { ADVISOR_EXECUTOR_GUIDANCE_LAYER } from "../model-routing/prompts.js";
+import { AdvisorTurnLifecycle } from "../model-routing/advisor-lifecycle.js";
+import { ADVISOR_COMPLETION_REVIEW_REMINDER, ADVISOR_EXECUTOR_GUIDANCE_LAYER, ADVISOR_ORIENTATION_REMINDER, } from "../model-routing/prompts.js";
+import { captureAdvisorExecutorContext } from "../model-routing/advisor-context.js";
 import { resolveTierDefault } from "../model-routing/resolve.js";
 import { ModelRouter, } from "../model-routing/router.js";
 import { BUILT_IN_ROUTING_TABLE, isVirtualModel, } from "../model-routing/table.js";
@@ -14,7 +16,7 @@ import { toXML } from "../lib/xml.js";
 import { createObservationalContextTransform, DEFAULT_EFFECTIVE_CONTEXT, estimateTokens, resolveObservationalMemorySettings, stripObservationalContextMessages, updateObservationalMemory, } from "../memory/observational.js";
 import { rebuildMemoryContextPack } from "../memory/context-pack.js";
 import { createEmbeddingClient } from "../memory/embedding.js";
-import { loadStoredMemory, readSessionObservations, replaceSessionObservations, } from "../memory/storage.js";
+import { loadStoredMemory, replaceSessionObservations, } from "../memory/storage.js";
 import { MemoryContextCache } from "../memory/store.js";
 import { DEFAULT_CLI_MEMORY_MODEL, DEFAULT_CLI_MODEL, resolveModelName, routingCatalogAdapter, } from "../model-resolution/resolver.js";
 import { DEFAULT_TASK_WAIT_BUDGET_MS } from "../types/config.js";
@@ -25,7 +27,7 @@ import { applyEvictionHorizon, calculateWireTokens, createInitialHorizon, findEv
 import { createDefaultTurnRunnerTools, createTurnRunnerTools, resolveStateCwd, formatCarriedTodosReminder, formatStateMachineTerminalAcknowledgmentPrompt, isTurnRunnerControlResult, MINIMUM_STATE_MACHINE_DELAY_MS, } from "./tools.js";
 import { connectMcpServers } from "./mcp.js";
 import { SkillContext } from "./skill-context.js";
-import { currentParkState } from "./state-machine-session.js";
+import { currentParkState, currentScheduledState } from "./state-machine-session.js";
 import { failActiveSession, markTerminalAcknowledged, planDecision, planWake, recordPlannedTerminal, recordScheduled, recordSettled, repeatedSelectionLoopCount, startSession as startStateMachineSession, supersede, } from "./state-machine-decisions.js";
 import { createSubagentExecutor, classifySpawnModel, } from "./subagent.js";
 import { completeTurn, copyOptionalArray, createInitialTurnState } from "./turn-state.js";
@@ -145,6 +147,8 @@ export class TurnRunner {
     pendingModelSelection;
     /** Advisor target and transcript budget selected with the current virtual tier. */
     advisorPolicy;
+    /** Product-owned early/final consultation checkpoints for the active public agent-mode turn. */
+    advisorTurnLifecycle;
     /** True only while the parent pi agent is actively producing the public terminal event. */
     parentAgentRunning = false;
     /** Control results captured during the current parent pass. More than one is a protocol error. */
@@ -541,6 +545,11 @@ export class TurnRunner {
         this.interruptCleanup = undefined;
         this.terminalEmitted = false;
         this.activeRootScopeId = `turn-${this.nextRootScope++}`;
+        const routeStatus = this.modelRouter?.status();
+        this.advisorTurnLifecycle =
+            this.requireRunnerState().mode === "agent" && this.advisorPolicy?.enabled && routeStatus
+                ? new AdvisorTurnLifecycle(routeStatus.assistantSteps)
+                : undefined;
         this.turnTools = this.createTools(this.requireRunnerState().mode).tools;
         this.enqueueParentInput(command.type === "wake" ? { type: "wake" } : { type: "user_command", command });
         const carriedUserCommands = this.hydratedQueuedCommands?.filter((queued) => queued.type !== "wake");
@@ -616,6 +625,8 @@ export class TurnRunner {
                     });
                 }
                 if (result?.type === "terminal") {
+                    if (this.queueAdvisorCompletionReviewIfDue(result.status))
+                        continue;
                     completion = {
                         status: result.status === "error" ? "failed" : "completed",
                         ...(result.result !== undefined ? { result: result.result } : {}),
@@ -697,6 +708,7 @@ export class TurnRunner {
             this.setState(terminal.state);
             this.emitTerminalOnce(terminal);
             this.turnTools = undefined;
+            this.advisorTurnLifecycle = undefined;
             this.activeRootScopeId = undefined;
             this.turnUsage = undefined;
             this.turnUsageByModel = undefined;
@@ -937,6 +949,8 @@ export class TurnRunner {
                 return this.selectNextStateAfterCompletion(input.stateName, input.output);
             case "terminal_acknowledgment":
                 return this.runTerminalAcknowledgmentPass();
+            case "advisor_completion_review":
+                return this.runAdvisorCompletionReviewPass();
             case "wake":
                 return this.runWakeInput();
         }
@@ -1051,6 +1065,48 @@ export class TurnRunner {
             return { type: "interrupted" };
         return this.stateMachineResultFromWorker(worker, worker.outcome.state);
     }
+    async runAdvisorCompletionReviewPass() {
+        const worker = await this.runParentPass({
+            state: this.snapshotState({ ...this.requireRunnerState(), status: "running" }),
+            prompt: systemReminder(ADVISOR_COMPLETION_REVIEW_REMINDER),
+            continuation: true,
+        });
+        this.setState(worker.outcome.state);
+        if (worker.outcome.type === "interrupted")
+            return { type: "interrupted" };
+        if (worker.control.type === "ask_user_question") {
+            return { type: "ask", questions: worker.control.questions };
+        }
+        return worker.outcome.status === "failed"
+            ? { type: "terminal", status: "error", error: worker.outcome.error }
+            : { type: "terminal", status: "completed", result: worker.outcome.result };
+    }
+    /**
+     * Queue a fresh parent continuation only when a completed agent-mode turn did enough work to
+     * benefit from review. A successful consultation with no subsequent real-world tool work already
+     * saw the final available evidence and satisfies this checkpoint without call counting. Otherwise
+     * completion starts a distinct consultation phase, so its first call gets a fresh ordinary floor
+     * even when the orientation call was recent. The checkpoint is marked before enqueueing so
+     * failures and ignored reminders remain non-recursive.
+     */
+    queueAdvisorCompletionReviewIfDue(status) {
+        const lifecycle = this.advisorTurnLifecycle;
+        const routeStatus = this.modelRouter?.status();
+        if (status !== "completed" ||
+            !lifecycle ||
+            !routeStatus ||
+            this.taskManager.pendingWork().kind === "open" ||
+            !lifecycle.takeCompletionCheckpoint(routeStatus.assistantSteps)) {
+            return false;
+        }
+        // Completion review is a distinct product lifecycle phase, just like a
+        // replacement model starts a fresh phase after a route switch. Reset the
+        // step floor instead of bypassing the advisor gate so the ordinary
+        // in-flight reservation and post-success cooldown still apply.
+        this.modelRouter?.resetAdvisorCooldown();
+        this.parentInputs.unshift({ type: "advisor_completion_review" });
+        return true;
+    }
     async executePlannedWork(work) {
         if ("terminal" in work) {
             const settled = recordPlannedTerminal(this.requireStateMachine(), work.terminal);
@@ -1265,6 +1321,19 @@ export class TurnRunner {
         return metadata.shell.partialOutput();
     }
     async interruptTasks(reason) {
+        const scheduledState = currentScheduledState(this.stateMachine);
+        const scheduledTask = scheduledState
+            ? this.taskManager
+                .list()
+                .find((task) => task.kind === "scheduled" &&
+                task.status === "scheduled" &&
+                task.name === scheduledState.name)
+            : undefined;
+        if (scheduledState && scheduledTask) {
+            const recorded = recordSettled(this.requireStateMachine(), scheduledState.name, scheduledState.kind, { type: "interrupted", reason }, undefined, this.clock.now());
+            this.setStateMachine(recorded.session);
+            this.ignoredTaskSettlements.add(scheduledTask.id);
+        }
         for (const [id, metadata] of this.stateTasks) {
             if (this.taskManager.output(id)?.descriptor.status !== "running")
                 continue;
@@ -1814,21 +1883,26 @@ export class TurnRunner {
     createAskAdvisorStorage(router, policy) {
         const resolveAdvisorModel = () => resolveModelName(policy.target.modelName);
         return {
-            getMessages: () => this.parentAgent?.state.messages ?? this.state?.agent.messages ?? [],
-            getSystemPrompt: () => this.parentAgent?.state.systemPrompt ?? "",
-            getObservations: async () => {
-                const session = this.memoryPersistence?.session;
-                const sessionId = this.config.sessionId;
-                if (!session || !sessionId)
-                    return [];
-                const snapshot = await readSessionObservations(session, sessionId);
-                return snapshot.observations.map((observation) => observation.content);
+            getContext: async () => {
+                const agent = this.requireParentAgent();
+                return await captureAdvisorExecutorContext(agent);
+            },
+            resolveModel: () => {
+                const model = resolveAdvisorModel();
+                return {
+                    modelName: model.id,
+                    contextWindowTokens: model.contextWindow,
+                    acceptsImages: model.input.includes("image"),
+                };
             },
-            budgetTokens: policy.transcriptTokens,
-            modelName: () => resolveAdvisorModel().id,
             thinkingLevel: policy.target.thinkingLevel,
             advisorGate: () => router.beginAdvisorConsult(),
-            noteAdvisorConsult: (success = true) => router.endAdvisorConsult(success),
+            noteAdvisorConsult: (success = true) => {
+                router.endAdvisorConsult(success);
+                if (success && this.advisorTurnLifecycle) {
+                    this.advisorTurnLifecycle.noteSuccessfulConsult(router.status().assistantSteps);
+                }
+            },
             recordUsage: (usage) => {
                 const model = resolveAdvisorModel();
                 this.recordAndEmitUsage(usageFromAiSdk(usage, model), model.id);
@@ -1841,6 +1915,14 @@ export class TurnRunner {
                     message: `Advisor usage accounting failed; advice was retained: ${reason}`,
                 });
             },
+            onAdvisorError: (error) => {
+                const reason = error instanceof Error ? error.message : String(error);
+                this.emit({
+                    type: "system",
+                    level: "warn",
+                    message: `Advisor consultation failed; executor continued: ${reason}`,
+                });
+            },
         };
     }
     /**
@@ -2374,6 +2456,8 @@ export class TurnRunner {
         this.emitAgentEvent(event);
         if (event.type === "turn_end" && event.message.role === "assistant") {
             this.modelRouter?.noteAssistantStep(routerStepObservation(event.message, event.toolResults));
+            this.advisorTurnLifecycle?.noteExecutedTools(event.toolResults.map((result) => result.toolName));
+            this.steerAdvisorOrientationIfDue();
         }
         if (event.type !== "message_end" || event.message.role !== "assistant")
             return;
@@ -2395,6 +2479,17 @@ export class TurnRunner {
         if (event.message.usage.totalTokens > 0)
             this.emitTurnUsage();
     }
+    /** Deliver one in-transcript orientation checkpoint without changing the public protocol. */
+    steerAdvisorOrientationIfDue() {
+        const lifecycle = this.advisorTurnLifecycle;
+        const routeStatus = this.modelRouter?.status();
+        if (!lifecycle ||
+            !routeStatus ||
+            !lifecycle.takeOrientationCheckpoint(routeStatus.assistantSteps)) {
+            return;
+        }
+        this.requireParentAgent().steer(buildUserAgentMessage(systemReminder(ADVISOR_ORIENTATION_REMINDER), undefined));
+    }
     /**
      * Re-emit the context-window breakdown after `compact()` advances the
      * eviction horizon. The bar's numerator is the latest parent