@tea-agent/loop-agent 0.34.3 → 0.34.4

package/dist/worker/console/chat/routes.js

@@ -15,8 +15,9 @@
 import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, } from "./tools.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle } from "./session-store.js";
-import { projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
+import { hashChatTurnPayload, projectChatToolEventPayload, projectCompactSnapshot, } from "./chat-event-store.js";
 import { THINKING_LEVELS, RuntimeSnapshotUnavailableError, } from "./pi-runtime.js";
+import { ResourcePreferencesError, setSkillAutoInvocationPreference, } from "./resource-preferences-store.js";
 import { ComposerDraftStore } from "./composer-draft-store.js";
 import { walkRepoFiles } from "./repo-walk.js";
 import { isSensitivePath, scrubSecrets } from "./explore-tools.js";
@@ -33,6 +34,23 @@ import { projectTaskContext } from "./context-panel.js";
 import { contractApplyPayloadHash, issueHumanGateToken, verifyHumanGateToken, } from "../human-gate-token.js";
 import { sendJson } from "../routes.js";
 import { openSseResponse, writeSseEvent } from "../operation-sse.js";
+function turnSummary(turn) {
+    return {
+        turnId: turn.turnId,
+        clientRequestId: turn.clientRequestId ?? null,
+        state: turn.state,
+        ordinal: turn.ordinal,
+        createdAt: turn.createdAt,
+        startedAt: turn.startedAt ?? null,
+        finishedAt: turn.finishedAt ?? null,
+        error: turn.error ?? null,
+        abortRequestedAt: turn.abortRequestedAt ?? null,
+    };
+}
+function isTerminalTurnState(state) {
+    return state === "settled" || state === "aborted" || state === "failed";
+}
+const DEFAULT_ABORT_WAIT_MS = 8_000;
 /** Parse Chat's `<epoch>:<seq>` SSE cursor. Legacy `<sessionId>:<seq>` has
  * the same wire shape; its prefix intentionally fails the current process
  * epoch comparison and triggers safe snapshot recovery (M5.1). */
@@ -648,13 +666,25 @@ export async function handleGetChatSessionState(_req, res, deps, sessionId) {
     }
     const active = deps.events.getActiveTurn(sessionId);
     const latest = deps.events.latestTurn(sessionId);
+    const runtimeFacts = typeof deps.runtime.getSessionBusyFacts === "function"
+        ? deps.runtime.getSessionBusyFacts(sessionId)
+        : {
+            isStreaming: false,
+            isPromptRunning: false,
+            isCompacting: false,
+            isBashRunning: false,
+        };
     sendJson(res, 200, {
         ok: true,
         state: {
+            // Legacy flat fields retained for older clients.
             activeTurnId: active?.turnId ?? null,
             activeTurnState: active?.state ?? null,
             latestTurnId: latest?.turnId ?? null,
             latestTurnState: latest?.state ?? null,
+            activeTurn: active ? turnSummary(active) : null,
+            latestTurn: latest ? turnSummary(latest) : null,
+            runtime: runtimeFacts,
         },
     });
 }
@@ -862,12 +892,25 @@ export async function handleChatPrompt(req, res, deps, sessionId) {
     // prompt SSE route uses the same durable Turn resource as POST /turns.
     const createdTurn = deps.events.createTurn(sessionId);
     if (!createdTurn.ok) {
+        if (createdTurn.code === "REQUEST_ID_REUSE_CONFLICT") {
+            sendJson(res, 409, {
+                ok: false,
+                accepted: false,
+                error: {
+                    code: createdTurn.code,
+                    message: createdTurn.message,
+                },
+            });
+            return;
+        }
         sendJson(res, 409, {
             ok: false,
+            accepted: false,
             error: {
                 code: "TURN_ACTIVE",
-                message: `chat turn already active: ${createdTurn.activeTurn.turnId}`,
+                message: "上一轮仍在运行，已返回当前 activeTurn；请重新连接或稍后再试。",
             },
+            activeTurn: turnSummary(createdTurn.activeTurn),
         });
         return;
     }
@@ -1009,6 +1052,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     if (!gate.ok) {
         sendJson(res, gate.status, {
             ok: false,
+            accepted: false,
             error: { code: gate.code, message: gate.message },
         });
         return;
@@ -1020,6 +1064,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     catch (error) {
         sendJson(res, 400, {
             ok: false,
+            accepted: false,
             error: {
                 code: "INVALID_INPUT",
                 message: error instanceof Error ? error.message : String(error),
@@ -1028,6 +1073,9 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
         return;
     }
     const text = typeof body.text === "string" ? body.text.trim() : "";
+    const clientRequestId = typeof body.clientRequestId === "string" && body.clientRequestId.trim()
+        ? body.clientRequestId.trim()
+        : undefined;
     let images;
     try {
         images = parseChatImages(body.images);
@@ -1035,6 +1083,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     catch (error) {
         sendJson(res, 400, {
             ok: false,
+            accepted: false,
             error: {
                 code: "INVALID_ATTACHMENT",
                 message: error instanceof Error ? error.message : String(error),
@@ -1045,6 +1094,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     if (!text) {
         sendJson(res, 400, {
             ok: false,
+            accepted: false,
             error: { code: "INVALID_INPUT", message: "text is required" },
         });
         return;
@@ -1054,6 +1104,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
         if (!record) {
             sendJson(res, 404, {
                 ok: false,
+                accepted: false,
                 error: {
                     code: "NOT_FOUND",
                     message: `chat session not found: ${sessionId}`,
@@ -1075,6 +1126,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
             });
             sendJson(res, mapped.status, {
                 ok: false,
+                accepted: false,
                 error: { code: mapped.code, message: mapped.message },
             });
             return;
@@ -1084,6 +1136,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
     if (!actionContext) {
         sendJson(res, 503, {
             ok: false,
+            accepted: false,
             error: {
                 code: "CHAT_NO_ACTION_CONTEXT",
                 message: "Chat runtime has no operator action context wired",
@@ -1091,30 +1144,78 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
         });
         return;
     }
-    const created = deps.events.createTurn(sessionId);
+    const payloadHash = hashChatTurnPayload({ text, images });
+    const created = deps.events.createTurn(sessionId, {
+        clientRequestId,
+        payloadHash,
+    });
     if (!created.ok) {
+        if (created.code === "REQUEST_ID_REUSE_CONFLICT") {
+            sendJson(res, 409, {
+                ok: false,
+                accepted: false,
+                error: {
+                    code: created.code,
+                    message: created.message,
+                },
+            });
+            return;
+        }
         sendJson(res, 409, {
             ok: false,
+            accepted: false,
             error: {
                 code: "TURN_ACTIVE",
-                message: `chat turn already active: ${created.activeTurn.turnId}`,
+                message: "上一轮仍在运行，已返回当前 activeTurn；请重新连接或稍后再试。",
             },
+            activeTurn: turnSummary(created.activeTurn),
         });
         return;
     }
     const turn = created.turn;
+    // Idempotent retry of an already-accepted request: return the same Turn and
+    // never re-run the prompt (even if it already finished).
+    if (created.idempotent) {
+        sendJson(res, 202, {
+            ok: true,
+            accepted: true,
+            idempotent: true,
+            turnId: turn.turnId,
+            ordinal: turn.ordinal,
+            state: turn.state,
+            turn: turnSummary(turn),
+        });
+        return;
+    }
+    const controller = new AbortController();
+    const execution = deps.turnExecutions?.register({
+        sessionId,
+        turnId: turn.turnId,
+        clientRequestId,
+        controller,
+    });
     deps.events.setTurnState(sessionId, turn.turnId, "running");
+    const running = deps.events.getTurn(sessionId, turn.turnId) ?? {
+        ...turn,
+        state: "running",
+    };
     sendJson(res, 202, {
         ok: true,
-        turnId: turn.turnId,
-        ordinal: turn.ordinal,
-        state: "running",
+        accepted: true,
+        idempotent: false,
+        turnId: running.turnId,
+        ordinal: running.ordinal,
+        state: running.state,
+        turn: turnSummary(running),
     });
     // Deliberately detached from the request lifecycle: closing the POST
     // response cannot abort the prompt; clients follow GET /events instead.
+    // Abort ownership lives in the execution registry (real Stop path).
     void (async () => {
         const { runChatTurn } = await import("./session-store.js");
         let firstUserText;
+        let terminalState = "failed";
+        let terminalError;
         try {
             const outcome = await runChatTurn({
                 runtime: deps.runtime,
@@ -1123,6 +1224,7 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
                 sessionId,
                 text,
                 images,
+                signal: controller.signal,
                 onUserMessagePersisted: (record) => {
                     const users = record.messages.filter((message) => message.role === "user");
                     if (users.length !== 1)
@@ -1147,24 +1249,142 @@ export async function handleCreateChatTurn(req, res, deps, sessionId) {
                 },
             });
             ensureAgentEndEvent(deps, sessionId, turn.turnId);
-            deps.events.setTurnState(sessionId, turn.turnId, outcome.ok ? "settled" : "failed", outcome.error);
-            if (outcome.ok && firstUserText)
-                scheduleAutomaticTitle(deps, { sessionId, turnId: turn.turnId, firstUserText });
+            if (controller.signal.aborted) {
+                terminalState = "aborted";
+                terminalError = {
+                    code: "CLIENT_ABORTED",
+                    message: "turn aborted by client",
+                };
+                deps.events.setTurnState(sessionId, turn.turnId, "aborted", terminalError);
+            }
+            else if (outcome.ok) {
+                terminalState = "settled";
+                deps.events.setTurnState(sessionId, turn.turnId, "settled");
+                if (firstUserText)
+                    scheduleAutomaticTitle(deps, {
+                        sessionId,
+                        turnId: turn.turnId,
+                        firstUserText,
+                    });
+            }
+            else {
+                terminalState = "failed";
+                terminalError = outcome.error;
+                deps.events.setTurnState(sessionId, turn.turnId, "failed", outcome.error);
+            }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            deps.events.append(sessionId, turn.turnId, {
-                kind: "error",
-                data: { message },
-            });
-            ensureAgentEndEvent(deps, sessionId, turn.turnId);
-            deps.events.setTurnState(sessionId, turn.turnId, "failed", {
-                code: "CHAT_TURN_FAILED",
-                message,
+            if (controller.signal.aborted) {
+                terminalState = "aborted";
+                terminalError = {
+                    code: "CLIENT_ABORTED",
+                    message: "turn aborted by client",
+                };
+                ensureAgentEndEvent(deps, sessionId, turn.turnId);
+                deps.events.setTurnState(sessionId, turn.turnId, "aborted", terminalError);
+            }
+            else {
+                terminalState = "failed";
+                terminalError = { code: "CHAT_TURN_FAILED", message };
+                deps.events.append(sessionId, turn.turnId, {
+                    kind: "error",
+                    data: { message },
+                });
+                ensureAgentEndEvent(deps, sessionId, turn.turnId);
+                deps.events.setTurnState(sessionId, turn.turnId, "failed", terminalError);
+            }
+        }
+        finally {
+            execution?.resolveCompletion({
+                ok: terminalState === "settled",
+                state: terminalState,
+                error: terminalError,
             });
+            deps.turnExecutions?.clear(sessionId, turn.turnId);
         }
     })();
 }
+/** Real server-side abort: invokes Pi session.abort via the execution registry. */
+export async function handleAbortChatTurn(req, res, deps, sessionId, turnId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, {
+            ok: false,
+            accepted: false,
+            error: { code: gate.code, message: gate.message },
+        });
+        return;
+    }
+    const turn = deps.events.getTurn(sessionId, turnId);
+    if (!turn) {
+        sendJson(res, 404, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: "NOT_FOUND",
+                message: `chat turn not found: ${turnId}`,
+            },
+        });
+        return;
+    }
+    if (isTerminalTurnState(turn.state)) {
+        sendJson(res, 200, {
+            ok: true,
+            accepted: true,
+            idempotent: true,
+            turn: turnSummary(turn),
+        });
+        return;
+    }
+    const execution = deps.turnExecutions?.get(sessionId, turnId);
+    if (!execution) {
+        // Active durable Turn without process ownership (restart orphan / detached).
+        const closed = deps.events.setTurnState(sessionId, turnId, "failed", {
+            code: "CHAT_TURN_OWNER_LOST",
+            message: "turn ownership lost; cannot abort a turn this process does not own",
+        });
+        sendJson(res, 409, {
+            ok: false,
+            accepted: false,
+            error: {
+                code: "CHAT_TURN_OWNER_LOST",
+                message: "turn ownership lost; cannot abort a turn this process does not own",
+            },
+            turn: closed ? turnSummary(closed) : turnSummary(turn),
+        });
+        return;
+    }
+    deps.events.markAbortRequested?.(sessionId, turnId);
+    if (!execution.controller.signal.aborted)
+        execution.controller.abort();
+    const waited = await (deps.turnExecutions?.waitForCompletion(sessionId, turnId, DEFAULT_ABORT_WAIT_MS) ?? Promise.resolve({ status: "missing" }));
+    if (waited.status === "completed") {
+        const finalTurn = deps.events.getTurn(sessionId, turnId) ??
+            {
+                ...turn,
+                state: waited.outcome.state,
+            };
+        sendJson(res, 200, {
+            ok: true,
+            accepted: true,
+            idempotent: false,
+            turn: turnSummary(finalTurn),
+        });
+        return;
+    }
+    // Timeout or missing completion: keep non-terminal; client reconciles via /state.
+    const pending = deps.events.getTurn(sessionId, turnId) ?? turn;
+    sendJson(res, 202, {
+        ok: false,
+        accepted: false,
+        error: {
+            code: "TURN_ABORT_PENDING",
+            message: "abort requested; turn has not yet reached a terminal state",
+        },
+        turn: turnSummary(pending),
+    });
+}
 export async function handleGetChatTurn(_req, res, deps, sessionId, turnId) {
     const turn = deps.events.getTurn(sessionId, turnId);
     if (!turn) {
@@ -1636,6 +1856,159 @@ export async function ensureActiveSession(deps, sessionId) {
     }
     return { ok: true };
 }
+/**
+ * PATCH /sessions/:id/skills/:resourceId/auto-invocation
+ * Persist repo-scoped preference, then try immediate reloadSession when idle.
+ * Busy sessions keep preferenceSaved=true and reloadApplied=false (no abort).
+ */
+export async function handleSkillAutoInvocation(req, res, deps, sessionId, resourceId) {
+    const gate = gateMutation(req, deps);
+    if (!gate.ok) {
+        sendJson(res, gate.status, {
+            ok: false,
+            error: { code: gate.code, message: gate.message },
+        });
+        return;
+    }
+    const ensured = await ensureActiveSession(deps, sessionId);
+    if (!ensured.ok) {
+        sendJson(res, ensured.status, {
+            ok: false,
+            error: { code: ensured.code, message: ensured.message },
+        });
+        return;
+    }
+    const id = resourceId.trim();
+    if (!id) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: "resourceId is required",
+            },
+        });
+        return;
+    }
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    if (typeof body.autoInvocationEnabled !== "boolean") {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: "autoInvocationEnabled boolean is required",
+            },
+        });
+        return;
+    }
+    const found = await deps.runtime.findSkillByResourceId(sessionId, id);
+    if (!found) {
+        sendJson(res, 404, {
+            ok: false,
+            error: {
+                code: "PI_SKILL_NOT_FOUND",
+                message: `skill resourceId not in current session inventory: ${id}`,
+            },
+        });
+        return;
+    }
+    const prefsPath = deps.appData.resourcePreferences;
+    if (!prefsPath) {
+        sendJson(res, 500, {
+            ok: false,
+            error: {
+                code: "PI_RESOURCE_PREFERENCES_WRITE_FAILED",
+                message: "resourcePreferences path is not configured",
+            },
+        });
+        return;
+    }
+    try {
+        await setSkillAutoInvocationPreference({
+            filePath: prefsPath,
+            resourceId: id,
+            autoInvocationEnabled: body.autoInvocationEnabled,
+        });
+    }
+    catch (error) {
+        if (error instanceof ResourcePreferencesError) {
+            const status = error.code === "PI_RESOURCE_PREFERENCES_MALFORMED" ? 500 : 500;
+            sendJson(res, status, {
+                ok: false,
+                error: { code: error.code, message: error.message },
+            });
+            return;
+        }
+        sendJson(res, 500, {
+            ok: false,
+            error: {
+                code: "PI_RESOURCE_PREFERENCES_WRITE_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    const reload = await deps.runtime.reloadSession(sessionId);
+    if (!reload.ok) {
+        if (reload.code === "PI_SESSION_BUSY") {
+            // Preference is durable; do not abort the busy turn or pretend reload applied.
+            sendJson(res, 200, {
+                ok: true,
+                preferenceSaved: true,
+                reloadApplied: false,
+                error: { code: reload.code, message: reload.message },
+            });
+            return;
+        }
+        sendJson(res, reload.code === "PI_SESSION_NOT_FOUND" ? 404 : 500, {
+            ok: false,
+            preferenceSaved: true,
+            reloadApplied: false,
+            error: { code: reload.code, message: reload.message },
+        });
+        return;
+    }
+    let snapshot;
+    try {
+        snapshot = await deps.runtime.getRuntimeSnapshot(sessionId);
+    }
+    catch (error) {
+        if (sendRuntimeUnavailable(res, error))
+            return;
+        throw error;
+    }
+    if (!snapshot) {
+        sendJson(res, 503, {
+            ok: false,
+            preferenceSaved: true,
+            reloadApplied: true,
+            error: {
+                code: "PI_RUNTIME_UNAVAILABLE",
+                message: `chat session not active after reload: ${sessionId}`,
+            },
+        });
+        return;
+    }
+    sendJson(res, 200, {
+        ok: true,
+        preferenceSaved: true,
+        reloadApplied: true,
+        revision: reload.revision,
+        snapshot,
+    });
+}
 /**
  * POST /sessions/:id/reload (AC-05 / AC-06): official session.reload() with
  * structured busy/failure semantics. Never aborts, never silently queues.
@@ -2551,6 +2924,11 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleMutationHumanGate(req, res, deps, decodeURIComponent(mutationHumanGate[1]));
         return true;
     }
+    const skillAutoInvocation = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/skills\/([^/]+)\/auto-invocation$/);
+    if (method === "PATCH" && skillAutoInvocation) {
+        await handleSkillAutoInvocation(req, res, deps, decodeURIComponent(skillAutoInvocation[1]), decodeURIComponent(skillAutoInvocation[2]));
+        return true;
+    }
     const m4Route = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/(draft|files|runtime-context|runtime-snapshot|models|model|reload)$/);
     if (m4Route) {
         const id = decodeURIComponent(m4Route[1]);
@@ -2609,6 +2987,11 @@ export async function handleChatRequest(req, res, deps, pathname) {
         await handleCreateChatTurn(req, res, deps, decodeURIComponent(sessionTurn[1]));
         return true;
     }
+    const sessionTurnAbort = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/turns\/([^/]+)\/abort$/);
+    if (method === "POST" && sessionTurnAbort) {
+        await handleAbortChatTurn(req, res, deps, decodeURIComponent(sessionTurnAbort[1]), decodeURIComponent(sessionTurnAbort[2]));
+        return true;
+    }
     const sessionTurnDetail = pathname.match(/^\/api\/operator\/v1\/chat\/sessions\/([^/]+)\/turns\/([^/]+)$/);
     if (method === "GET" && sessionTurnDetail) {
         await handleGetChatTurn(req, res, deps, decodeURIComponent(sessionTurnDetail[1]), decodeURIComponent(sessionTurnDetail[2]));

package/dist/worker/console/chat/turn-execution-registry.js

@@ -0,0 +1,82 @@
+/**
+ * Session-scoped ownership of in-flight Chat Turn executions.
+ *
+ * Registry entries must exist before HTTP 202 is returned, and every
+ * completion path (success / abort / failure) must clear them in finally so
+ * durable active leases cannot outlive the owning process.
+ */
+function keyFor(sessionId, turnId) {
+    return `${sessionId}\0${turnId}`;
+}
+export function createChatTurnExecutionRegistry() {
+    const entries = new Map();
+    const bySession = new Map();
+    return {
+        register(input) {
+            const existingSession = bySession.get(input.sessionId);
+            if (existingSession && existingSession !== input.turnId) {
+                throw new Error(`CHAT_TURN_EXECUTION_ACTIVE: ${input.sessionId} already owns ${existingSession}`);
+            }
+            const key = keyFor(input.sessionId, input.turnId);
+            const prior = entries.get(key);
+            if (prior)
+                return prior;
+            let resolveCompletion;
+            const completion = new Promise((resolve) => {
+                resolveCompletion = resolve;
+            });
+            // Prevent unhandled rejection if nobody awaits.
+            void completion.catch(() => undefined);
+            const entry = {
+                sessionId: input.sessionId,
+                turnId: input.turnId,
+                clientRequestId: input.clientRequestId,
+                controller: input.controller ?? new AbortController(),
+                completion,
+                resolveCompletion,
+            };
+            entries.set(key, entry);
+            bySession.set(input.sessionId, input.turnId);
+            return entry;
+        },
+        get(sessionId, turnId) {
+            return entries.get(keyFor(sessionId, turnId));
+        },
+        getBySession(sessionId) {
+            const turnId = bySession.get(sessionId);
+            if (!turnId)
+                return undefined;
+            return entries.get(keyFor(sessionId, turnId));
+        },
+        clear(sessionId, turnId) {
+            const key = keyFor(sessionId, turnId);
+            entries.delete(key);
+            if (bySession.get(sessionId) === turnId)
+                bySession.delete(sessionId);
+        },
+        async waitForCompletion(sessionId, turnId, timeoutMs) {
+            const entry = entries.get(keyFor(sessionId, turnId));
+            if (!entry)
+                return { status: "missing" };
+            let timer;
+            try {
+                const outcome = await Promise.race([
+                    entry.completion.then((value) => ({ kind: "done", value })),
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+                    }),
+                ]);
+                if (outcome.kind === "timeout")
+                    return { status: "timeout" };
+                return { status: "completed", outcome: outcome.value };
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        },
+        size() {
+            return entries.size;
+        },
+    };
+}

package/dist/worker/console/dag-execution-receipt.js

@@ -22,6 +22,19 @@ import path from "node:path";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "./app-data.js";
 import { hashDagBytes, } from "./dag-confirmation.js";
+/**
+ * Structured verification command patterns for the G2 autonomous-execution
+ * gate. A DAG is only eligible for autonomous execution when it carries at
+ * least one shell verification node whose id or command is recognized as a
+ * real test/verification suite (not just an arbitrary shell command).
+ *
+ * Covers the Console workflow kinds: standard/frontend (npm run test/lint/
+ * typecheck, vitest, check-repo.sh), backend-test (pytest) and frontend-test
+ * (playwright). Ids ending in -verify / -verification / -validate / -gate are
+ * treated as verification shells by the caller; commands broaden the match to
+ * framework invocations that don't embed the word "verify".
+ */
+export const STRUCTURED_VERIFICATION_COMMAND_RE = /\b(vitest|jest|playwright|cypress|pytest|py-test|go\s+test|cargo\s+test|npm\s+run\s+(lint|typecheck|test|verify)|npm\s+(test|run\s+test)|check-repo\.sh|loop-agent-standard-verify)\b/i;
 export const DEFAULT_EXECUTION_RECEIPT_TTL_MS = 30 * 60 * 1000;
 function normalizePathEntry(entry) {
     return entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
@@ -145,7 +158,7 @@ export function deriveEligibilityFactsFromDagSpec(input) {
         if (/verify|verification/i.test(task.id ?? ""))
             return true;
         const commands = stringList(task.shell.commands);
-        return commands.some((command) => /(vitest|npm run (lint|typecheck|test)|check-repo\.sh|loop-agent-standard-verify)/.test(command));
+        return commands.some((command) => STRUCTURED_VERIFICATION_COMMAND_RE.test(command));
     });
     return {
         writersWriteSets: writers,