@tea-agent/loop-agent 0.34.2 → 0.34.4

package/dist/worker/console/chat/chat-event-store.js

@@ -221,6 +221,20 @@ function shouldCoalesce(ring, turnId, partial) {
         return false;
     return nowMs - Date.parse(tail.at) <= ring.coalesceWindowMs;
 }
+/** Stable hash of the normalized prompt payload for clientRequestId binding. */
+export function hashChatTurnPayload(input) {
+    const normalized = {
+        text: input.text,
+        images: (input.images ?? []).map((image) => ({
+            type: image.type ?? "image",
+            mimeType: image.mimeType ?? "",
+            data: image.data ?? "",
+        })),
+    };
+    return createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex");
+}
 const DEFAULT_MAX_EVENTS = 2000;
 /** Mirrors pi-web's bounded-ring orientation (2000 events / 10 MiB). */
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
@@ -399,6 +413,24 @@ export function createChatEventStore(options) {
                 eventId: eventIdFor(sessionId, event.seq),
             }));
             const turns = Array.isArray(parsed.turns) ? parsed.turns : [];
+            // New Console epoch: orphan any queued/running turn whose ownerEpoch is
+            // missing or mismatched. Releases the active lease without pretending the
+            // user aborted (CHAT_TURN_OWNER_LOST fence).
+            let orphaned = false;
+            const now = new Date().toISOString();
+            for (const turn of turns) {
+                if (turn.state !== "queued" && turn.state !== "running")
+                    continue;
+                if (turn.ownerEpoch === eventEpoch)
+                    continue;
+                turn.state = "failed";
+                turn.finishedAt = now;
+                turn.error = {
+                    code: "CHAT_TURN_OWNER_LOST",
+                    message: "turn ownership lost after Console restart; previous execution is no longer owned",
+                };
+                orphaned = true;
+            }
             turnCounts.set(sessionId, parsed.turnCount ?? 0);
             const ring = {
                 events,
@@ -415,6 +447,8 @@ export function createChatEventStore(options) {
             // R6: re-check the bounds after a restart — a persisted file may exceed the
             // current limits if it was written by an older config or hand-edited.
             enforceBounds(sessionId, ring);
+            if (orphaned)
+                persist(sessionId, ring);
             return ring;
         }
         catch (error) {
@@ -521,11 +555,35 @@ export function createChatEventStore(options) {
             }
             return { copiedCount };
         },
-        createTurn(sessionId) {
+        createTurn(sessionId, input) {
             const ring = ringFor(sessionId);
+            const clientRequestId = input?.clientRequestId?.trim() || undefined;
+            const payloadHash = input?.payloadHash?.trim() || undefined;
+            if (clientRequestId) {
+                const existing = ring.turns.find((turn) => turn.clientRequestId === clientRequestId);
+                if (existing) {
+                    if (payloadHash &&
+                        existing.payloadHash &&
+                        existing.payloadHash !== payloadHash) {
+                        return {
+                            ok: false,
+                            code: "REQUEST_ID_REUSE_CONFLICT",
+                            message: `clientRequestId ${clientRequestId} was reused with a different payload`,
+                            existingTurn: { ...existing },
+                        };
+                    }
+                    // Same id + same (or missing) payload: idempotent return, no new lease.
+                    return {
+                        ok: true,
+                        turn: { ...existing },
+                        created: false,
+                        idempotent: true,
+                    };
+                }
+            }
             const active = ring.turns.find((turn) => turn.state === "queued" || turn.state === "running");
             if (active)
-                return { ok: false, code: "TURN_ACTIVE", activeTurn: active };
+                return { ok: false, code: "TURN_ACTIVE", activeTurn: { ...active } };
             const ordinal = (turnCounts.get(sessionId) ?? 0) + 1;
             turnCounts.set(sessionId, ordinal);
             const now = new Date().toISOString();
@@ -536,11 +594,14 @@ export function createChatEventStore(options) {
                 ordinal,
                 state: "queued",
                 createdAt: now,
+                ownerEpoch: eventEpoch,
+                ...(clientRequestId ? { clientRequestId } : {}),
+                ...(payloadHash ? { payloadHash } : {}),
             };
             ring.turns.push(turn);
             ring.approxBytes += byteHint(turn);
             persist(sessionId, ring);
-            return { ok: true, turn };
+            return { ok: true, turn: { ...turn }, created: true, idempotent: false };
         },
         setTurnState(sessionId, turnId, state, error) {
             const ring = ringFor(sessionId);
@@ -561,6 +622,27 @@ export function createChatEventStore(options) {
             persist(sessionId, ring);
             return { ...turn };
         },
+        markAbortRequested(sessionId, turnId, at) {
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.find((candidate) => candidate.turnId === turnId);
+            if (!turn)
+                return undefined;
+            const before = JSON.stringify(turn).length;
+            if (!turn.abortRequestedAt)
+                turn.abortRequestedAt = at ?? new Date().toISOString();
+            ring.approxBytes +=
+                (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
+            persist(sessionId, ring);
+            return { ...turn };
+        },
+        findTurnByClientRequestId(sessionId, clientRequestId) {
+            const id = clientRequestId.trim();
+            if (!id)
+                return undefined;
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.find((candidate) => candidate.clientRequestId === id);
+            return turn ? { ...turn } : undefined;
+        },
         getTurn(sessionId, turnId) {
             const ring = ringFor(sessionId);
             const turn = ring.turns.find((candidate) => candidate.turnId === turnId);

package/dist/worker/console/chat/pi-runtime.js

@@ -32,6 +32,7 @@ import { projectCompactSnapshot, } from "./chat-event-store.js";
 import { extractUsageSample } from "./usage.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, authorizeOperatorChatTool, assertNoWriteToolInList, } from "./tools.js";
 import { createOperatorChatResourceLoader, } from "./resource-loader.js";
+import { applySkillAutoInvocationPreferences, isAutoInvocationEnabled, loadResourcePreferences, skillResourceId, } from "./resource-preferences-store.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.js";
 import { filterActiveInterviewTools } from "../interview/tools.js";
@@ -466,7 +467,8 @@ export function projectRuntimeSnapshot(input) {
         ...(skill.baseDir ? { baseDir: field(skill.baseDir, 400) } : {}),
         scope: skill.scope,
         source: field(skill.source, 200) ?? "",
-        enabled: skill.enabled,
+        resourceId: field(skill.resourceId, 200) ?? "",
+        autoInvocationEnabled: skill.autoInvocationEnabled,
         diagnostics: skill.diagnostics.map((diag) => field(diag, 400) ?? ""),
     });
     const projectExtension = (ext) => ({
@@ -645,6 +647,8 @@ export class ConsolePiRuntime {
     revisions = new Map();
     /** RF-01: per-session reload in-flight lock (concurrent second call → PI_SESSION_BUSY). */
     reloadInFlight = new Set();
+    /** Synchronous prompt ownership per session (admission before first await). */
+    promptOwners = new Set();
     /** At most one detached automatic-title task per durable Console session. */
     titleInFlight = new Set();
     /** Composer thinking selection ("auto" = no explicit override). */
@@ -665,6 +669,78 @@ export class ConsolePiRuntime {
         this.loader = createOperatorChatResourceLoader();
         this.bindings = options.bindings ?? createDefaultPiSdkBindings();
     }
+    /** Absolute path for repo-scoped resource preferences (may be undefined in unit tests). */
+    get resourcePreferencesPath() {
+        return this.options.resourcePreferencesPath;
+    }
+    /**
+     * Load repo-scoped skill auto-invocation preferences (fail closed on malformed).
+     * Missing path / missing file → empty prefs (all skills auto-invocation default on).
+     */
+    async loadSkillAutoInvocationPreferences() {
+        const filePath = this.options.resourcePreferencesPath;
+        if (!filePath) {
+            const empty = { schemaVersion: 1, skills: {} };
+            this.cachedSkillPrefs = empty;
+            return empty;
+        }
+        const prefs = await loadResourcePreferences(filePath);
+        this.cachedSkillPrefs = prefs;
+        return prefs;
+    }
+    /**
+     * Build resourceLoaderOptions that inject skillsOverride from stored prefs.
+     * Skills remain in inventory; only disableModelInvocation is forced for
+     * auto-invocation-off preferences. Manual /skill:name is preserved.
+     *
+     * The override re-reads preferences on EVERY invocation so session.reload()
+     * after a PATCH sees the latest resource-preferences.json (not create-time
+     * closure state).
+     */
+    async buildResourceLoaderOptions(base = {}) {
+        const runtime = this;
+        return {
+            ...base,
+            skillsOverride: (current) => {
+                // Synchronous override surface: use last-known prefs via a sync
+                // fail-closed path. Prefer async cache filled by ensurePrefs.
+                const prefs = runtime.cachedSkillPrefs ?? {
+                    schemaVersion: 1,
+                    skills: {},
+                };
+                return {
+                    skills: applySkillAutoInvocationPreferences(current.skills, prefs),
+                    diagnostics: current.diagnostics,
+                };
+            },
+        };
+    }
+    /** Last successfully loaded skill prefs (sync override + snapshot projection). */
+    cachedSkillPrefs;
+    /** Refresh cached prefs before materialization / reload so override sees latest. */
+    async refreshSkillPrefsCache() {
+        const prefs = await this.loadSkillAutoInvocationPreferences();
+        this.cachedSkillPrefs = prefs;
+        return prefs;
+    }
+    /**
+     * Resolve a skill in the current session inventory by server-issued resourceId.
+     * Returns undefined when the id is unknown (caller maps to PI_SKILL_NOT_FOUND).
+     */
+    async findSkillByResourceId(sessionId, resourceId) {
+        const snapshot = await this.getRuntimeSnapshot(sessionId);
+        if (!snapshot)
+            return undefined;
+        const skill = snapshot.skills.find((entry) => entry.resourceId === resourceId);
+        if (!skill)
+            return undefined;
+        return {
+            resourceId: skill.resourceId,
+            name: skill.name,
+            path: skill.path,
+            autoInvocationEnabled: skill.autoInvocationEnabled,
+        };
+    }
     get sessionDir() {
         return this.options.sessionDir;
     }
@@ -820,13 +896,15 @@ export class ConsolePiRuntime {
             ...(init.systemPromptSuffix ? [init.systemPromptSuffix] : []),
         ];
         // Single services construction for formal materialization (+ optional
-        // default-model resolve from the same modelRuntime).
+        // default-model resolve from the same modelRuntime). Repo-scoped skill
+        // auto-invocation prefs inject skillsOverride without touching SKILL.md.
+        await this.refreshSkillPrefsCache().catch(() => undefined);
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
-            resourceLoaderOptions: {
+            resourceLoaderOptions: await this.buildResourceLoaderOptions({
                 appendSystemPrompt,
-            },
+            }),
         });
         if (this.disposedSessions.has(sessionId))
             return;
@@ -1176,6 +1254,9 @@ export class ConsolePiRuntime {
         }
         this.reloadInFlight.add(sessionId);
         try {
+            // Refresh prefs cache so skillsOverride applied during reload sees
+            // the latest resource-preferences.json written by PATCH.
+            await this.refreshSkillPrefsCache().catch(() => undefined);
             await session.reload();
         }
         catch (error) {
@@ -1283,9 +1364,33 @@ export class ConsolePiRuntime {
             catch (error) {
                 resourceFailure("context files", error);
             }
+            // Preferences are the source of truth for UI auto-invocation state;
+            // loader disableModelInvocation may also reflect frontmatter. Prefer
+            // explicit preference (default on) when projecting autoInvocationEnabled.
+            let skillPrefs = { schemaVersion: 1, skills: {} };
+            try {
+                skillPrefs = await this.loadSkillAutoInvocationPreferences();
+            }
+            catch (error) {
+                diagnostics.push({
+                    type: "error",
+                    code: "PI_RESOURCE_PREFERENCES_MALFORMED",
+                    message: error instanceof Error ? error.message : String(error),
+                    retryable: true,
+                });
+            }
             try {
                 const skillsResult = resourceLoader.getSkills?.();
                 for (const skill of skillsResult?.skills ?? []) {
+                    const resourceId = skillResourceId({
+                        name: skill.name,
+                        filePath: skill.filePath,
+                    });
+                    // Preference off always means autoInvocationEnabled=false even if
+                    // loader already applied disableModelInvocation. Frontmatter-only
+                    // disable (no preference) also surfaces as autoInvocationEnabled=false.
+                    const prefEnabled = isAutoInvocationEnabled(skillPrefs, resourceId);
+                    const autoInvocationEnabled = prefEnabled && skill.disableModelInvocation !== true;
                     skills.push({
                         name: skill.name,
                         description: skill.description ?? "",
@@ -1293,7 +1398,8 @@ export class ConsolePiRuntime {
                         ...(skill.baseDir ? { baseDir: skill.baseDir } : {}),
                         scope: skill.sourceInfo?.scope ?? "unknown",
                         source: skill.sourceInfo?.source ?? "",
-                        enabled: !skill.disableModelInvocation,
+                        resourceId,
+                        autoInvocationEnabled,
                         diagnostics: [],
                     });
                     resolvedResources.push({
@@ -1620,12 +1726,13 @@ export class ConsolePiRuntime {
             OPERATOR_CHAT_SYSTEM_PROMPT_BASE,
             ...(init.systemPromptSuffix ? [init.systemPromptSuffix] : []),
         ];
+        await this.refreshSkillPrefsCache().catch(() => undefined);
         const { services } = await this.bindings.createServices({
             cwd: this.options.cwd,
             agentDir,
-            resourceLoaderOptions: {
+            resourceLoaderOptions: await this.buildResourceLoaderOptions({
                 appendSystemPrompt,
-            },
+            }),
         });
         const modelRuntime = services.modelRuntime;
         const resolvedModel = init.model
@@ -1669,81 +1776,142 @@ export class ConsolePiRuntime {
     hasSession(sessionId) {
         return this.sessions.has(sessionId);
     }
+    /**
+     * Live runtime busy facts for /state reconcile. isPromptRunning is owned by
+     * this Console admission fence; other flags mirror the Pi session when present.
+     */
+    getSessionBusyFacts(sessionId) {
+        const session = this.sessions.get(sessionId);
+        const isPromptRunning = this.promptOwners.has(sessionId);
+        return {
+            isStreaming: session?.isStreaming === true || isPromptRunning,
+            isPromptRunning,
+            isCompacting: session?.isCompacting === true,
+            isBashRunning: session?.isBashRunning === true ||
+                session?.hasPendingBashMessages === true,
+        };
+    }
     /**
      * Send a prompt and stream events. Gate 3: each tool invocation is
      * re-authorized by authorizeOperatorChatTool before the dispatcher runs it
      * (the dispatcher is wired by the HTTP layer, see chat-session.ts).
+     *
+     * Prompt ownership is acquired synchronously before the first await so two
+     * concurrent prompts on the same Session cannot both enter the SDK path.
      */
     async prompt(sessionId, text, onEvent, options) {
-        // First message while creating waits on the same materialization promise.
-        await this.ensureSessionReady(sessionId);
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`chat session not found: ${sessionId}`);
+        // Synchronous admission fence — before any await.
+        if (this.promptOwners.has(sessionId)) {
+            throw new Error("CHAT_TURN_ACTIVE");
         }
-        // Gate 2 (re-pin before each turn): interview turns pass through the
-        // existing closed interview allow/deny registry. The next ordinary turn
-        // explicitly restores the normal Operator Chat set (baseline + extension
-        // tools, ADR 0012).
-        const requestedTools = OPERATOR_CHAT_ACTIVE_TOOL_NAMES();
-        const activeTools = options?.mode === "requirement-interview"
-            ? filterActiveInterviewTools(requestedTools).allowed
-            : computeOperatorChatActiveToolNames(session);
-        session.setActiveToolsByName(activeTools);
-        const unsub = session.subscribe((event) => {
-            const mapped = mapSdkEvent(sessionId, event);
-            if (mapped)
-                onEvent(mapped);
-            // Pi puts per-assistant-message usage on `message.usage` ({ input, output,
-            // cacheRead, cacheWrite, totalTokens, cost }). Emit on message_end so
-            // multi-step tool turns accumulate like pi-web SessionInfoBar; turn_end
-            // repeats the final message and must not double-count.
-            if (event.type === "message_end") {
-                const usage = extractUsageSample(event);
-                if (usage)
-                    onEvent({ type: "usage", sessionId, usage });
-            }
-        });
+        this.promptOwners.add(sessionId);
+        let unsub;
+        let abortPromise;
         const onAbort = () => {
-            // M1 T08: Stop must abort only the current turn, NOT dispose the
-            // session. SDK AgentSession.abort() aborts the current operation and
-            // waits for the agent to become idle, keeping the session reusable for
-            // the next turn. Only fall back to dispose if the session has no abort()
-            // (e.g. a minimal stub), since a stuck turn should not leak forever.
+            // M1 T08 / AC-R3-003: Stop must abort only the current turn, NEVER
+            // dispose the session. Await session.abort() so ownership settles
+            // after the SDK reports idle. When abort is unavailable, fail closed
+            // non-destructively — Session stays reusable; terminal closeout or
+            // /state reconcile still converges ownership.
+            const session = this.sessions.get(sessionId);
+            if (!session)
+                return;
             try {
                 if (typeof session.abort === "function") {
-                    void session.abort();
-                }
-                else {
-                    session.dispose();
+                    abortPromise = Promise.resolve(session.abort()).catch(() => undefined);
                 }
+                // else: do not call session.dispose() — Stop never destroys Session.
             }
             catch {
                 // ignore
             }
         };
-        options?.signal?.addEventListener("abort", onAbort);
         try {
-            await session.prompt(text, options?.images?.length ? { images: options.images } : undefined);
-            // Wait until the session reports idle / not streaming. The SDK prompt()
-            // resolves when the agent turn completes, but post-turn continuation
-            // (auto-compaction / follow-up) may still be in flight. We poll isIdle.
-            // While polling we emit periodic heartbeat events so the SSE stream
-            // keeps proxies/browsers from timing out (no other data is flowing).
-            await waitForIdle(session, {
-                signal: options?.signal,
-                onHeartbeat: () => onEvent({ type: "heartbeat", sessionId }),
+            // AC-FIX-002: if Stop already fired before readiness, never start model work.
+            if (options?.signal?.aborted) {
+                return;
+            }
+            // First message while creating waits on the same materialization promise.
+            await this.ensureSessionReady(sessionId);
+            // Abort may land during readiness (or between readiness and prompt).
+            if (options?.signal?.aborted) {
+                return;
+            }
+            const session = this.sessions.get(sessionId);
+            if (!session) {
+                throw new Error(`chat session not found: ${sessionId}`);
+            }
+            // Gate 2 (re-pin before each turn): interview turns pass through the
+            // existing closed interview allow/deny registry. The next ordinary turn
+            // explicitly restores the normal Operator Chat set (baseline + extension
+            // tools, ADR 0012).
+            const requestedTools = OPERATOR_CHAT_ACTIVE_TOOL_NAMES();
+            const activeTools = options?.mode === "requirement-interview"
+                ? filterActiveInterviewTools(requestedTools).allowed
+                : computeOperatorChatActiveToolNames(session);
+            session.setActiveToolsByName(activeTools);
+            // Final pre-prompt fence: abort after tool pin must still skip session.prompt.
+            if (options?.signal?.aborted) {
+                return;
+            }
+            unsub = session.subscribe((event) => {
+                const mapped = mapSdkEvent(sessionId, event);
+                if (mapped)
+                    onEvent(mapped);
+                // Pi puts per-assistant-message usage on `message.usage` ({ input, output,
+                // cacheRead, cacheWrite, totalTokens, cost }). Emit on message_end so
+                // multi-step tool turns accumulate like pi-web SessionInfoBar; turn_end
+                // repeats the final message and must not double-count.
+                if (event.type === "message_end") {
+                    const usage = extractUsageSample(event);
+                    if (usage)
+                        onEvent({ type: "usage", sessionId, usage });
+                }
             });
-            onEvent({ type: "agent_settled", sessionId });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            onEvent({ type: "error", sessionId, message });
-            throw error;
+            options?.signal?.addEventListener("abort", onAbort);
+            if (options?.signal?.aborted) {
+                onAbort();
+                if (abortPromise)
+                    await abortPromise.catch(() => undefined);
+                return;
+            }
+            try {
+                await session.prompt(text, options?.images?.length ? { images: options.images } : undefined);
+                // Wait until the session reports idle / not streaming. The SDK prompt()
+                // resolves when the agent turn completes, but post-turn continuation
+                // (auto-compaction / follow-up) may still be in flight. We poll isIdle.
+                // While polling we emit periodic heartbeat events so the SSE stream
+                // keeps proxies/browsers from timing out (no other data is flowing).
+                await waitForIdle(session, {
+                    signal: options?.signal,
+                    onHeartbeat: () => onEvent({ type: "heartbeat", sessionId }),
+                });
+                if (abortPromise)
+                    await abortPromise;
+                // User abort is closed out as Turn state `aborted`; do not publish a
+                // red ordinary error event for intentional Stop.
+                if (!options?.signal?.aborted) {
+                    onEvent({ type: "agent_settled", sessionId });
+                }
+            }
+            catch (error) {
+                if (abortPromise)
+                    await abortPromise.catch(() => undefined);
+                if (options?.signal?.aborted) {
+                    // User abort: swallow ordinary error publication (AC-FIX-003).
+                    return;
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                onEvent({ type: "error", sessionId, message });
+                throw error;
+            }
+            finally {
+                options?.signal?.removeEventListener("abort", onAbort);
+                unsub?.();
+            }
         }
         finally {
-            options?.signal?.removeEventListener("abort", onAbort);
-            unsub();
+            this.promptOwners.delete(sessionId);
         }
     }
     /** Generate exactly one title in an isolated in-memory, tool-less LOW session. */