qlogicagent 2.13.5 → 2.13.7

package/dist/agent/memory-recall-context.test.js

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildRecalledMemorySystemContent, detectRecallMemoryConflicts, } from "./memory-recall-context.js";
-describe("memory recall context", () => {
-    it("marks L1 project MD and L2 long-term memories as separate sources", () => {
-        const content = buildRecalledMemorySystemContent([
-            {
-                text: "用户接单金额 1000",
-                source: "l1-project-md",
-                label: "L1 project MD",
-            },
-            {
-                text: "用户偏好简洁回答",
-                source: "l2-long-term",
-                label: "L2 long-term",
-            },
-        ]);
-        expect(content).toContain("[L1 project MD]");
-        expect(content).toContain("[L2 long-term]");
-        expect(content).toContain("L1 project MD is project-scoped working memory");
-        expect(content).toContain("L2 long-term memory is cross-project canonical memory");
-    });
-    it("flags same-fact amount conflicts between L1 project MD and L2 long-term memory", () => {
-        const memories = [
-            {
-                text: "用户接单金额 1000",
-                source: "l1-project-md",
-            },
-            {
-                text: "用户接单金额 2000",
-                source: "l2-long-term",
-            },
-        ];
-        const conflicts = detectRecallMemoryConflicts(memories);
-        expect(conflicts).toHaveLength(1);
-        expect(conflicts[0]).toMatchObject({
-            entity: "用户",
-            predicate: "接单金额",
-            l1Amount: 1000,
-            l2Amount: 2000,
-        });
-        const content = buildRecalledMemorySystemContent(memories);
-        expect(content).toContain("[Memory conflict detected]");
-        expect(content).toContain("ask the user which value is current");
-    });
-    it("does not flag the same amount as a conflict", () => {
-        const conflicts = detectRecallMemoryConflicts([
-            {
-                text: "用户接单金额 1000",
-                source: "l1-project-md",
-            },
-            {
-                text: "用户接单金额 1000",
-                source: "l2-long-term",
-            },
-        ]);
-        expect(conflicts).toHaveLength(0);
-    });
-});

package/dist/agent/memory-recall-injection.d.ts

@@ -1,34 +0,0 @@
-/**
- * Turn-time QMemory recall orchestration (hippocampus bridge).
- *
- * Impure counterpart to the pure memory-recall-context.ts: it drives the
- * `memory.before_recall` hook, caps the recalled set by a per-turn byte budget,
- * and fires `memory.after_recall`. Kept out of Agent.run so the turn entrypoint
- * stays a thin lifecycle wrapper; the pure prompt-building (and conflict
- * detection) stays in memory-recall-context.ts.
- *
- * Returns the system-message content to inject (already prefixed), or null when
- * there is nothing to inject. Recall failures are swallowed — a recall miss must
- * never block the turn. The caller decides WHERE to splice the message; this
- * module only decides WHAT (if anything) to inject.
- */
-import type { AgentLogger, HookRegistry } from "./types.js";
-export interface RecallMemoriesDeps {
-    hooks: HookRegistry;
-    /** P6: maps the query to category recall preferences (runtime port). */
-    detectRecallCategories: (query: string) => {
-        preferred: string[];
-        deprioritized: string[];
-    };
-    log: AgentLogger;
-    sessionId: string;
-    turnId: string;
-    /** Last user message (already truncated by the caller). */
-    query: string;
-}
-/**
- * Recall long-term memories for this turn and build the system-message content
- * to inject. Always fires `memory.after_recall` (with the pre-cap count) when the
- * recall hook runs. Returns null when there is nothing worth injecting.
- */
-export declare function recallMemoriesForTurn(deps: RecallMemoriesDeps): Promise<string | null>;

package/dist/agent/memory-recall-injection.js

@@ -1,66 +0,0 @@
-/**
- * Turn-time QMemory recall orchestration (hippocampus bridge).
- *
- * Impure counterpart to the pure memory-recall-context.ts: it drives the
- * `memory.before_recall` hook, caps the recalled set by a per-turn byte budget,
- * and fires `memory.after_recall`. Kept out of Agent.run so the turn entrypoint
- * stays a thin lifecycle wrapper; the pure prompt-building (and conflict
- * detection) stays in memory-recall-context.ts.
- *
- * Returns the system-message content to inject (already prefixed), or null when
- * there is nothing to inject. Recall failures are swallowed — a recall miss must
- * never block the turn. The caller decides WHERE to splice the message; this
- * module only decides WHAT (if anything) to inject.
- */
-import { fireHook } from "../contracts/fire-hook.js";
-import { buildRecalledMemorySystemContent } from "./memory-recall-context.js";
-/** Per-turn injection cap: max bytes of recalled memory text. Prevents context
- * flooding on early turns when the session budget is already full. */
-const PER_TURN_RECALL_MAX_BYTES = 8192;
-/**
- * Recall long-term memories for this turn and build the system-message content
- * to inject. Always fires `memory.after_recall` (with the pre-cap count) when the
- * recall hook runs. Returns null when there is nothing worth injecting.
- */
-export async function recallMemoriesForTurn(deps) {
-    const { hooks, detectRecallCategories, log, sessionId, turnId, query } = deps;
-    try {
-        // P6: detect query scenario → category preferences for recall filtering.
-        const categoryHint = detectRecallCategories(query);
-        const recallResult = await hooks.invoke("memory.before_recall", {
-            sessionId,
-            turnId,
-            query,
-            preferredCategories: categoryHint.preferred.length > 0 ? categoryHint.preferred : undefined,
-            deprioritizedCategories: categoryHint.deprioritized.length > 0 ? categoryHint.deprioritized : undefined,
-        });
-        const memories = recallResult?.context?.recalledMemories;
-        let systemContent = null;
-        if (memories && memories.length > 0) {
-            let usedBytes = 0;
-            const capped = [];
-            for (const m of memories) {
-                const entryBytes = (m.text?.length ?? 0) * 2;
-                if (usedBytes + entryBytes > PER_TURN_RECALL_MAX_BYTES)
-                    break;
-                capped.push(m);
-                usedBytes += entryBytes;
-            }
-            if (capped.length > 0) {
-                const memoryBlock = buildRecalledMemorySystemContent(capped);
-                systemContent = `[Recalled memories — context priority: project-specific facts override general user preferences when they conflict]\n${memoryBlock}`;
-            }
-        }
-        // Notify after_recall with the pre-cap count (matches prior behavior).
-        fireHook(hooks, "memory.after_recall", {
-            sessionId,
-            turnId,
-            blockCount: memories?.length ?? 0,
-        }, log);
-        return systemContent;
-    }
-    catch {
-        // Non-fatal: recall failure should not block the turn.
-        return null;
-    }
-}

package/dist/agent/runtime-vars.d.ts

@@ -1,48 +0,0 @@
-/**
- * RuntimeVars — Unified mutable runtime variables for the agent server.
- *
- * All tunable/configurable runtime state that can be changed via RPC
- * (config.updateTunable) or internal logic should live here. This avoids
- * scattering mutable state as private fields across stdio-server.ts.
- *
- * Categories:
- *   1. Budget — aggregate token usage tracking and limits
- *   2. Dream  — idle dream scheduling parameters
- *
- * Usage:
- *   import { runtimeVars } from "../agent/runtime-vars.js";
- *   runtimeVars.teamTokensUsed += tokens;
- *   if (runtimeVars.isTeamBudgetExceeded()) { ... }
- */
-export interface TeamBudgetState {
-    /** Total tokens consumed by all forked sub-agents (accumulated). */
-    tokensUsed: number;
-    /** Maximum total tokens allowed across all forks. 0 = unlimited. */
-    budgetTokens: number;
-}
-export interface DreamState {
-    /** Idle threshold before triggering dream (minutes). */
-    idleMinutes: number;
-    /** Whether idle dream is enabled. */
-    enabled: boolean;
-    /** Last dream timestamp (ms since epoch). */
-    lastDreamAt: number;
-    /** Cooldown between dreams (ms). */
-    cooldownMs: number;
-    /** Max duration for a single dream run (ms). */
-    maxDurationMs: number;
-}
-export declare class RuntimeVars {
-    readonly teamBudget: TeamBudgetState;
-    /** Check if team aggregate budget is exceeded. */
-    isTeamBudgetExceeded(): boolean;
-    /** Record token consumption from a fork and return updated total. */
-    recordForkTokens(tokens: number): number;
-    /** Format budget-exceeded error message. */
-    teamBudgetExceededError(): string;
-    readonly dream: DreamState;
-    /** Reset all accumulated state (e.g. on session end). */
-    resetAccumulators(): void;
-}
-/** Singleton instance — shared across the server lifetime. */
-export declare const runtimeVars: RuntimeVars;

package/dist/agent/runtime-vars.js

@@ -1,54 +0,0 @@
-/**
- * RuntimeVars — Unified mutable runtime variables for the agent server.
- *
- * All tunable/configurable runtime state that can be changed via RPC
- * (config.updateTunable) or internal logic should live here. This avoids
- * scattering mutable state as private fields across stdio-server.ts.
- *
- * Categories:
- *   1. Budget — aggregate token usage tracking and limits
- *   2. Dream  — idle dream scheduling parameters
- *
- * Usage:
- *   import { runtimeVars } from "../agent/runtime-vars.js";
- *   runtimeVars.teamTokensUsed += tokens;
- *   if (runtimeVars.isTeamBudgetExceeded()) { ... }
- */
-import { TEAM_BUDGET_TOKENS } from "./tunable-defaults.js";
-// ── RuntimeVars Class ───────────────────────────────────────
-export class RuntimeVars {
-    // ── Team Budget ─────────────────────────────────────────
-    teamBudget = {
-        tokensUsed: 0,
-        budgetTokens: TEAM_BUDGET_TOKENS,
-    };
-    /** Check if team aggregate budget is exceeded. */
-    isTeamBudgetExceeded() {
-        return (this.teamBudget.budgetTokens > 0 &&
-            this.teamBudget.tokensUsed >= this.teamBudget.budgetTokens);
-    }
-    /** Record token consumption from a fork and return updated total. */
-    recordForkTokens(tokens) {
-        this.teamBudget.tokensUsed += tokens;
-        return this.teamBudget.tokensUsed;
-    }
-    /** Format budget-exceeded error message. */
-    teamBudgetExceededError() {
-        return `Team budget exceeded (${this.teamBudget.tokensUsed} / ${this.teamBudget.budgetTokens} tokens). No more sub-agents allowed.`;
-    }
-    // ── Dream ───────────────────────────────────────────────
-    dream = {
-        idleMinutes: 30,
-        enabled: false,
-        lastDreamAt: 0,
-        cooldownMs: 4 * 60 * 60 * 1000,
-        maxDurationMs: 5 * 60 * 1000,
-    };
-    // ── Reset ───────────────────────────────────────────────
-    /** Reset all accumulated state (e.g. on session end). */
-    resetAccumulators() {
-        this.teamBudget.tokensUsed = 0;
-    }
-}
-/** Singleton instance — shared across the server lifetime. */
-export const runtimeVars = new RuntimeVars();

package/dist/agent/tool-access.d.ts

@@ -1 +0,0 @@
-export * from "../skills/tool-access.js";

package/dist/agent/tool-access.js

@@ -1 +0,0 @@
-export * from "../skills/tool-access.js";

package/dist/agent/tool-loop/artifact-events.d.ts

@@ -1,17 +0,0 @@
-import type { TurnEvent } from "../types.js";
-import type { ToolExecutionResultPort } from "../../runtime/ports/index.js";
-type ToolSidecarEvent = Extract<TurnEvent, {
-    type: "plan_update" | "artifact";
-}>;
-type ToolCallLike = {
-    id: string;
-    function: {
-        arguments: string;
-    };
-};
-export declare function createToolSidecarEvents(params: {
-    turnId: string;
-    result: ToolExecutionResultPort;
-    toolCalls: ToolCallLike[];
-}): ToolSidecarEvent[];
-export {};

package/dist/agent/tool-loop/artifact-events.js

@@ -1,75 +0,0 @@
-const ARTIFACT_TOOL_SET = new Set(["write", "edit", "patch"]);
-export function createToolSidecarEvents(params) {
-    const { turnId, result, toolCalls } = params;
-    if (!result.ok)
-        return [];
-    const originalCall = toolCalls.find(tc => tc.id === result.callId);
-    if (!originalCall)
-        return [];
-    const events = [];
-    const callArgs = parseToolArguments(originalCall.function.arguments);
-    if (!callArgs)
-        return events;
-    if (result.toolName === "plan_mode" && callArgs.action === "exit" && typeof callArgs.plan === "string" && callArgs.plan.length > 0) {
-        events.push({
-            type: "plan_update",
-            turnId,
-            slug: "approved-plan",
-            content: callArgs.plan,
-        });
-    }
-    if (ARTIFACT_TOOL_SET.has(result.toolName)) {
-        const filePath = getArtifactPath(callArgs);
-        if (filePath) {
-            events.push({
-                type: "artifact",
-                turnId,
-                artifactId: `artifact-${result.callId}`,
-                artifactType: inferArtifactType(filePath),
-                title: filePath.split(/[\\/]/).pop() || filePath,
-                filePath,
-                language: inferLanguageFromPath(filePath),
-            });
-        }
-    }
-    return events;
-}
-function parseToolArguments(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-function getArtifactPath(args) {
-    return typeof args.file_path === "string" ? args.file_path
-        : typeof args.filePath === "string" ? args.filePath
-            : typeof args.path === "string" ? args.path
-                : undefined;
-}
-function inferArtifactType(filePath) {
-    const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
-    if (["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico"].includes(ext))
-        return "image";
-    if (["md", "txt", "pdf", "doc", "docx", "rtf", "html"].includes(ext))
-        return "document";
-    if (["mermaid", "mmd", "dot", "puml", "plantuml"].includes(ext))
-        return "diagram";
-    if (["csv", "tsv", "xlsx", "xls"].includes(ext))
-        return "table";
-    if (["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "c", "cpp", "h", "cs", "rb", "sh", "sql", "json", "yaml", "yml", "toml", "xml", "css", "scss", "vue", "svelte"].includes(ext))
-        return "code";
-    return "file";
-}
-function inferLanguageFromPath(filePath) {
-    const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
-    const langMap = {
-        ts: "typescript", tsx: "typescriptreact", js: "javascript", jsx: "javascriptreact",
-        py: "python", rs: "rust", go: "go", java: "java", c: "c", cpp: "cpp", h: "c",
-        cs: "csharp", rb: "ruby", sh: "shellscript", sql: "sql", json: "json",
-        yaml: "yaml", yml: "yaml", toml: "toml", xml: "xml", html: "html",
-        css: "css", scss: "scss", vue: "vue", svelte: "svelte", md: "markdown",
-    };
-    return langMap[ext];
-}

package/dist/agent/tool-loop/budget-continuation-policy.d.ts

@@ -1,22 +0,0 @@
-import type { AgentLogger, ThinkingBlock, TokenUsage, ToolLoopTransition } from "../types.js";
-export interface BudgetContinuationPolicyInput {
-    tokenBudget: number | undefined;
-    totalUsage: TokenUsage;
-    budgetContinuationCount: number;
-    lastBudgetDeltaTokens: number;
-    lastBudgetGlobalTokens: number;
-    messages: unknown[];
-    finalText: string;
-    thinkingBlocks: readonly ThinkingBlock[];
-    getBudgetContinuationMessage(usagePct: number, totalUsed: number, tokenBudget?: number): string;
-    log: Pick<AgentLogger, "info">;
-}
-export interface BudgetContinuationPolicyDecision {
-    messages: unknown[];
-    budgetContinuationCount: number;
-    lastBudgetDeltaTokens: number;
-    lastBudgetGlobalTokens: number;
-    recoveryDetail: string;
-    transition: ToolLoopTransition;
-}
-export declare function resolveBudgetContinuationPolicy(input: BudgetContinuationPolicyInput): BudgetContinuationPolicyDecision | null;

package/dist/agent/tool-loop/budget-continuation-policy.js

@@ -1,44 +0,0 @@
-import { DIMINISHING_RETURNS_MIN_CONTINUATIONS, DIMINISHING_RETURNS_THRESHOLD, } from "../tunable-defaults.js";
-const MAX_BUDGET_CONTINUATIONS = 5;
-function totalTokens(usage) {
-    return usage.inputTokens + usage.outputTokens + (usage.reasoningTokens ?? 0);
-}
-function assistantMessage(finalText, thinkingBlocks) {
-    return {
-        role: "assistant",
-        content: finalText,
-        ...(thinkingBlocks.length > 0 && { thinkingBlocks: [...thinkingBlocks] }),
-    };
-}
-export function resolveBudgetContinuationPolicy(input) {
-    if (!input.tokenBudget || input.tokenBudget <= 0)
-        return null;
-    if (input.budgetContinuationCount >= MAX_BUDGET_CONTINUATIONS)
-        return null;
-    const totalUsed = totalTokens(input.totalUsage);
-    const usagePct = (totalUsed / input.tokenBudget) * 100;
-    const deltaSinceLastCheck = totalUsed - input.lastBudgetGlobalTokens;
-    const isDiminishing = input.budgetContinuationCount >= DIMINISHING_RETURNS_MIN_CONTINUATIONS &&
-        deltaSinceLastCheck < DIMINISHING_RETURNS_THRESHOLD &&
-        input.lastBudgetDeltaTokens < DIMINISHING_RETURNS_THRESHOLD;
-    if (isDiminishing) {
-        input.log.info(`token budget early stop: diminishing returns at ${Math.round(usagePct)}% (delta=${deltaSinceLastCheck})`);
-        return null;
-    }
-    if (usagePct >= 90)
-        return null;
-    const nextCount = input.budgetContinuationCount + 1;
-    const budgetMsg = {
-        role: "user",
-        content: input.getBudgetContinuationMessage(usagePct, totalUsed, input.tokenBudget),
-    };
-    input.log.info(`token budget continuation #${nextCount}: ${Math.round(usagePct)}% used`);
-    return {
-        messages: [...input.messages, assistantMessage(input.finalText, input.thinkingBlocks), budgetMsg],
-        budgetContinuationCount: nextCount,
-        lastBudgetDeltaTokens: deltaSinceLastCheck,
-        lastBudgetGlobalTokens: totalUsed,
-        recoveryDetail: `${Math.round(usagePct)}% used (#${nextCount})`,
-        transition: { reason: "token_budget_continuation" },
-    };
-}

package/dist/agent/tool-loop/completion-action-policy.d.ts

@@ -1,19 +0,0 @@
-import type { AgentLogger, ChatMessage, ThinkingBlock, ToolLoopTransition } from "../types.js";
-export type CompletionActionPolicyReason = "file_action_verification" | "multi_file_skeleton_verification";
-export interface CompletionActionPolicyInput {
-    inputMessages: readonly ChatMessage[];
-    messages: unknown[];
-    finalText: string;
-    thinkingBlocks: readonly ThinkingBlock[];
-    stopHookActive: boolean | undefined;
-    totalToolCallCount: number;
-    distinctToolNames: ReadonlySet<string>;
-    log: Pick<AgentLogger, "info">;
-}
-export interface CompletionActionPolicyDecision {
-    reason: CompletionActionPolicyReason;
-    messages: unknown[];
-    stopHookActive: true;
-    transition: ToolLoopTransition;
-}
-export declare function resolveCompletionActionPolicy(input: CompletionActionPolicyInput): CompletionActionPolicyDecision | null;

package/dist/agent/tool-loop/completion-action-policy.js

@@ -1,68 +0,0 @@
-const FILE_ACTION_PATTERN = /create\s+(?:a\s+)?file|write\s+(?:a\s+)?file|make\s+(?:a\s+)?file|fix|implement|modify|update|repair|generate\s+(?:a\s+)?file|new\s+file/i;
-function buildAssistantMessage(finalText, thinkingBlocks) {
-    return {
-        role: "assistant",
-        content: finalText,
-        ...(thinkingBlocks.length > 0 && { thinkingBlocks: [...thinkingBlocks] }),
-    };
-}
-function hasSuccessfulToolResult(msg) {
-    const m = msg;
-    const isError = m.is_error === true || (typeof m.content === "string" && m.content.startsWith("Error:"));
-    return m.role === "tool" && typeof m.content === "string" && !isError;
-}
-function appendLastToolResultInstruction(messages) {
-    const lastToolMsg = [...messages].reverse().find((m) => m.role === "tool");
-    if (lastToolMsg && typeof lastToolMsg.content === "string") {
-        lastToolMsg.content += "\n\n鈿狅笍 NOTE: You used shell commands but did not call the write or edit tool to create/modify the file. " +
-            "Shell commands may fail silently or produce incorrect results on this platform. " +
-            "Please use the 'write' tool directly to create the requested file with the correct content.";
-    }
-}
-function createDecision(reason, messages, assistantMsg, nudgeMsg) {
-    return {
-        reason,
-        messages: [...messages, assistantMsg, nudgeMsg],
-        stopHookActive: true,
-        transition: { reason: "stop_hook_blocking" },
-    };
-}
-export function resolveCompletionActionPolicy(input) {
-    if (input.stopHookActive)
-        return null;
-    const userMsg = input.inputMessages.find((m) => m.role === "user");
-    const userText = typeof userMsg?.content === "string" ? userMsg.content : "";
-    const requestsFileAction = FILE_ACTION_PATTERN.test(userText);
-    const usedWriteOrEdit = input.distinctToolNames.has("write") || input.distinctToolNames.has("edit");
-    if (requestsFileAction && !usedWriteOrEdit) {
-        input.log.info("AP1 action-verification: user requested file action but no write/edit tool was called, injecting nudge");
-        if (input.totalToolCallCount > 0) {
-            appendLastToolResultInstruction(input.messages);
-        }
-        const nudgeMsg = {
-            role: "user",
-            content: input.totalToolCallCount === 0
-                ? "You described what to do but did not actually call any tool to write or edit a file. " +
-                    "Please use the write or edit tool now to perform the requested action. Do not just describe the changes - actually make them."
-                : "You used shell commands but did not call the write or edit tool to create/modify the file. " +
-                    "Shell commands may fail on this platform. Please use the write tool directly to create the requested file with the correct content.",
-        };
-        return createDecision("file_action_verification", input.messages, buildAssistantMessage(input.finalText, input.thinkingBlocks), nudgeMsg);
-    }
-    if (input.totalToolCallCount >= 3 && input.distinctToolNames.has("write")) {
-        const fileWriteSuccessCount = input.messages.filter(hasSuccessfulToolResult).length;
-        if (fileWriteSuccessCount >= 3) {
-            input.log.info("AP3 verification nudge: 3+ files created, injecting completeness check");
-            const nudgeMsg = {
-                role: "user",
-                content: "You created multiple files. Before completing, verify: " +
-                    "(1) All imports between your files resolve to real exports. " +
-                    "(2) No TODO, placeholder, or 'not implemented' stubs remain. " +
-                    "(3) Functions that are imported are actually called, not just declared. " +
-                    "If everything is correct, confirm completion. If not, fix the issues now.",
-            };
-            return createDecision("multi_file_skeleton_verification", input.messages, buildAssistantMessage(input.finalText, input.thinkingBlocks), nudgeMsg);
-        }
-    }
-    return null;
-}

package/dist/agent/tool-loop/completion-action-policy.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/agent/tool-loop/completion-action-policy.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { resolveCompletionActionPolicy } from "./completion-action-policy.js";
-const log = { info: vi.fn() };
-function user(content) {
-    return { role: "user", content };
-}
-function baseInput(overrides = {}) {
-    return {
-        inputMessages: [user("Create a file at src/example.ts")],
-        messages: [],
-        finalText: "I will create it.",
-        thinkingBlocks: [],
-        stopHookActive: undefined,
-        totalToolCallCount: 0,
-        distinctToolNames: new Set(),
-        log,
-        ...overrides,
-    };
-}
-describe("resolveCompletionActionPolicy", () => {
-    it("requests a write/edit action when a file action completes without tools", () => {
-        const decision = resolveCompletionActionPolicy(baseInput());
-        expect(decision).toMatchObject({
-            reason: "file_action_verification",
-            stopHookActive: true,
-            transition: { reason: "stop_hook_blocking" },
-        });
-        expect(decision?.messages).toHaveLength(2);
-        expect(decision?.messages[0]).toMatchObject({ role: "assistant", content: "I will create it." });
-        expect(decision?.messages[1]).toMatchObject({ role: "user" });
-        expect(String(decision?.messages[1]?.content)).toContain("write or edit tool");
-    });
-    it("annotates the last tool result when shell commands were used without write/edit", () => {
-        const messages = [
-            { role: "assistant", content: "running shell" },
-            { role: "tool", name: "shell", tool_call_id: "call-1", content: "ok" },
-        ];
-        const decision = resolveCompletionActionPolicy(baseInput({
-            messages,
-            totalToolCallCount: 1,
-            distinctToolNames: new Set(["shell"]),
-        }));
-        expect(decision?.reason).toBe("file_action_verification");
-        expect(messages[1].content).toContain("NOTE:");
-        expect(String(decision?.messages.at(-1)?.content)).toContain("Please use the write tool directly");
-    });
-    it("does not intervene when write/edit already handled the file action", () => {
-        const decision = resolveCompletionActionPolicy(baseInput({
-            totalToolCallCount: 1,
-            distinctToolNames: new Set(["write"]),
-        }));
-        expect(decision).toBeNull();
-    });
-    it("requests multi-file skeleton verification after a broad write burst", () => {
-        const messages = [
-            { role: "tool", content: "created a", tool_call_id: "a" },
-            { role: "tool", content: "created b", tool_call_id: "b" },
-            { role: "tool", content: "created c", tool_call_id: "c" },
-        ];
-        const decision = resolveCompletionActionPolicy(baseInput({
-            messages,
-            finalText: "All files created.",
-            totalToolCallCount: 3,
-            distinctToolNames: new Set(["write"]),
-        }));
-        expect(decision).toMatchObject({
-            reason: "multi_file_skeleton_verification",
-            stopHookActive: true,
-            transition: { reason: "stop_hook_blocking" },
-        });
-        expect(String(decision?.messages.at(-1)?.content)).toContain("All imports between your files resolve");
-    });
-    it("stays quiet while a stop hook is already active", () => {
-        const decision = resolveCompletionActionPolicy(baseInput({ stopHookActive: true }));
-        expect(decision).toBeNull();
-    });
-});

package/dist/agent/tool-loop/completion-stop-policy.d.ts

@@ -1,19 +0,0 @@
-import type { AgentLogger, HookRegistry, ThinkingBlock, ToolLoopTransition } from "../types.js";
-export type CompletionStopPolicyDecision = {
-    action: "end";
-    content: string;
-} | {
-    action: "continue";
-    messages: unknown[];
-    stopHookActive: true;
-    transition: ToolLoopTransition;
-};
-export interface CompletionStopPolicyInput {
-    hooks: HookRegistry | undefined;
-    sessionId: string;
-    messages: unknown[];
-    finalText: string;
-    thinkingBlocks: readonly ThinkingBlock[];
-    log: Pick<AgentLogger, "info">;
-}
-export declare function resolveCompletionStopPolicy(input: CompletionStopPolicyInput): Promise<CompletionStopPolicyDecision | null>;

package/dist/agent/tool-loop/completion-stop-policy.js

@@ -1,31 +0,0 @@
-function assistantMessage(finalText, thinkingBlocks) {
-    return {
-        role: "assistant",
-        content: finalText,
-        ...(thinkingBlocks.length > 0 && { thinkingBlocks: [...thinkingBlocks] }),
-    };
-}
-export async function resolveCompletionStopPolicy(input) {
-    if (!input.hooks)
-        return null;
-    const stopResult = await input.hooks.invoke("stop", { sessionId: input.sessionId, reason: "completed" });
-    if (stopResult.action === "prevent") {
-        input.log.info(`stop hook prevented continuation: ${stopResult.reason ?? "no reason"}`);
-        return { action: "end", content: input.finalText };
-    }
-    if (stopResult.action === "abort") {
-        const reason = stopResult.reason ?? "Stop hook requested continuation";
-        input.log.info(`stop hook blocking: ${reason}`);
-        const continuationMsg = {
-            role: "user",
-            content: reason,
-        };
-        return {
-            action: "continue",
-            messages: [...input.messages, assistantMessage(input.finalText, input.thinkingBlocks), continuationMsg],
-            stopHookActive: true,
-            transition: { reason: "stop_hook_blocking" },
-        };
-    }
-    return null;
-}