@tea-agent/loop-agent 0.39.0-beta.1 → 0.39.0-beta.10

package/dist/executors/shell-write-guard.js

@@ -98,6 +98,13 @@ export function isEphemeralToolCachePath(filePath) {
     const normalized = normalizePath(filePath);
     if (!normalized)
         return false;
+    // CodeGraph extension sync side effect (plan 2026-08-21 D7): a loaded
+    // pi-codegraph extension keeps an existing .codegraph/ index fresh at
+    // session start; those index files are extension-owned run state, not
+    // writer output, so they never count as write-guard violations.
+    if (normalized === ".codegraph" || normalized.startsWith(".codegraph/")) {
+        return true;
+    }
     if (normalized === ".pytest_cache" ||
         normalized.startsWith(".pytest_cache/")) {
         return true;
@@ -117,6 +124,13 @@ export function isEphemeralToolCachePath(filePath) {
     if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
         return true;
     }
+    // vite/vitest runtime caches live under node_modules/.vite (e.g.
+    // node_modules/.vite/vitest/results.json). node_modules is the gitignored
+    // dependency tree — tool cache writes there are never a writer's product
+    // change and must not trip the write guard.
+    if (normalized.startsWith("node_modules/.vite/")) {
+        return true;
+    }
     if (/(?:^|\/)__pycache__(?:\/|$)/.test(normalized))
         return true;
     if (/\.(?:pyc|pyo)$/.test(normalized))

package/dist/executors/workspace-write-snapshot.js

@@ -0,0 +1,68 @@
+import { createHash } from "node:crypto";
+import { lstat, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathMatchesPattern } from "../shared/git-progress.js";
+const normalize = (value) => value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+function rootBeforeWildcard(pattern) {
+    const value = normalize(pattern);
+    const wildcard = value.search(/[?*]/);
+    if (wildcard < 0)
+        return path.posix.dirname(value);
+    const prefix = value.slice(0, wildcard);
+    return prefix.slice(0, prefix.lastIndexOf("/")) || ".";
+}
+async function walk(rootCwd, relative, files) {
+    let entries;
+    try {
+        entries = await readdir(path.resolve(rootCwd, relative), { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if ([".git", ".harness", "node_modules"].includes(entry.name))
+            continue;
+        const child = normalize(path.posix.join(relative, entry.name));
+        if (entry.isDirectory())
+            await walk(rootCwd, child, files);
+        else if (entry.isFile())
+            files.add(child);
+    }
+}
+export async function captureWorkspaceWriteSnapshot(input) {
+    const candidates = new Set();
+    for (const pattern of input.paths) {
+        await walk(input.rootCwd, rootBeforeWildcard(pattern), candidates);
+        if (!/[?*]/.test(pattern)) {
+            try {
+                if ((await lstat(path.resolve(input.rootCwd, pattern))).isFile())
+                    candidates.add(normalize(pattern));
+            }
+            catch { /* absent target */ }
+        }
+    }
+    const files = {};
+    let totalBytes = 0;
+    for (const relative of [...candidates].filter((file) => input.paths.some((pattern) => pathMatchesPattern(file, pattern))).sort()) {
+        if (Object.keys(files).length >= 20_000)
+            throw new Error("workspace snapshot file limit exceeded");
+        const absolute = path.resolve(input.rootCwd, relative);
+        const stat = await lstat(absolute);
+        if (!stat.isFile())
+            throw new Error(`workspace snapshot encountered non-regular file: ${relative}`);
+        totalBytes += stat.size;
+        if (totalBytes > 64 * 1024 * 1024)
+            throw new Error("workspace snapshot byte limit exceeded");
+        files[relative] = { size: stat.size, sha256: createHash("sha256").update(await readFile(absolute)).digest("hex") };
+    }
+    const body = JSON.stringify(files);
+    return { schemaVersion: 1, controlMode: "filesystem-only", files, sha256: createHash("sha256").update(body).digest("hex") };
+}
+export function diffWorkspaceWriteSnapshots(before, after) {
+    const paths = new Set([...Object.keys(before.files), ...Object.keys(after.files)]);
+    return [...paths].sort().filter((file) => {
+        const left = before.files[file];
+        const right = after.files[file];
+        return !left || !right || left.size !== right.size || left.sha256 !== right.sha256;
+    });
+}

package/dist/infrastructure/harness/atomic-write.js

@@ -2,6 +2,29 @@ import { copyFile, mkdir, readFile, rename, unlink, writeFile } from "node:fs/pr
 import path from "node:path";
 import { assertHarnessWriteAllowed, } from "./completed-facts-guard.js";
 let atomicWriteSequence = 0;
+function isTransientJsonReadError(error) {
+    if (error instanceof SyntaxError)
+        return true;
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    const code = String(error.code ?? "");
+    return code === "EBUSY" || code === "EPERM" || code === "EACCES";
+}
+export async function readJsonWithTransientRetry(targetPath, options = {}) {
+    const attempts = Math.max(1, Math.floor(options.attempts ?? 6));
+    const delayMs = Math.max(0, Math.floor(options.delayMs ?? 20));
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            return JSON.parse(await readFile(targetPath, "utf-8"));
+        }
+        catch (error) {
+            if (attempt === attempts || !isTransientJsonReadError(error))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, delayMs * attempt));
+        }
+    }
+    throw new Error("unreachable transient JSON read state");
+}
 async function writeAtomic(targetPath, content, options) {
     assertHarnessWriteAllowed(targetPath, options);
     const resolved = options?.repoRoot && !path.isAbsolute(targetPath)

package/dist/shared/dag-failure-category.js

@@ -0,0 +1,150 @@
+/**
+ * Pure DAG failure-category classification shared by the workflows kernel and
+ * the Operator Console projection (console sources may not import
+ * src/workflows — security-and-tools boundary test).
+ *
+ * No runtime imports: this module is a leaf safe for both the CLI kernel and
+ * the browser bundle.
+ */
+export const DAG_NORMALIZED_FAILURE_CATEGORY_VALUES = [
+    "success",
+    "validation",
+    "executor",
+    "write-guard",
+    "timeout",
+    "auth",
+    "human-required",
+    "human-rejected",
+    "shell-command",
+    "static-error",
+    "decision-envelope",
+    "skipped",
+    "unknown",
+];
+const RAW_TO_NORMALIZED = {
+    success: "success",
+    "write-guard": "write-guard",
+    timeout: "timeout",
+    // Clean implementer stall with zero writes — still a timeout class for report,
+    // but retryable under WRITER_TRANSPORT_RETRY_POLICY.
+    "writer-clean-timeout": "timeout",
+    "missing-api-key": "auth",
+    auth: "auth",
+    "human-rejected": "human-rejected",
+    "human-required": "human-required",
+    "decision-envelope-invalid": "decision-envelope",
+    "nonzero-exit": "shell-command",
+    "spawn-error": "shell-command",
+    "test-timeout": "timeout",
+    "static-error": "static-error",
+    "invalid-output": "validation",
+    "structured-output-truncated": "validation",
+    "output-too-large": "validation",
+    "structured-repair-exhausted": "validation",
+    "governance-blocked": "validation",
+    "path-violation": "validation",
+    "empty-output": "validation",
+    "verify-failure": "validation",
+    "test-failure": "validation",
+    "verification-plan-stale": "validation",
+    "read-burst": "validation",
+    // Writer persisted real file changes but the final provider call hit a
+    // context overflow; verification never ran. Distinct from empty-output so
+    // the report shows partial success instead of a spec issue.
+    "partial-success-with-context-overflow": "validation",
+    // Writer burned an excessive token budget (unconverged read-edit-test loop)
+    // and still failed; distinct from empty-output for accurate reporting.
+    "writer-budget-exhausted": "validation",
+    network: "executor",
+    quota: "executor",
+    "rate-limit": "executor",
+    unavailable: "executor",
+    // Context window overflow (400 request-too-large): the session needs
+    // compaction / fresh context before retrying — an executor-side
+    // environment condition, not a plan-quality defect.
+    "context-overflow": "executor",
+    // Deterministic capability/policy refusal: missing verified launcher JS
+    // entry, capability allowlist rejection, or missing bounded write tool
+    // profile. These are environment/config defects the operator repairs
+    // before rerunning; classify as executor so recovery recommends
+    // rerun-after-fix WITHOUT forcing a human-decision gate on
+    // standaloneTaskRerun (run-failed same-task rerun).
+    "tool-policy": "executor",
+    unknown: "unknown",
+};
+/** Status inputs are deliberately `string`: projection layers pass bounded
+ *  text from CLI JSON; unmatched values simply fall through to unknown. */
+function isFinishedStatus(status) {
+    return status === "FINISHED" || status === "finished";
+}
+function isInProgressStatus(status) {
+    return (status === "PENDING" ||
+        status === "RUNNING" ||
+        status === "pending" ||
+        status === "running");
+}
+function isFailureStatus(status) {
+    return (status === "ERROR" ||
+        status === "failed" ||
+        status === "partial_failed");
+}
+function mapRawCategory(raw) {
+    const direct = RAW_TO_NORMALIZED[raw];
+    if (direct)
+        return direct;
+    const lower = raw.toLowerCase();
+    if (lower.includes("timeout"))
+        return "timeout";
+    if (lower.includes("validation") ||
+        lower.includes("invalid") ||
+        lower.includes("verification-plan-stale") ||
+        lower.includes("plan-stale"))
+        return "validation";
+    if (lower.includes("auth") || lower.includes("api-key"))
+        return "auth";
+    if (lower.includes("write-guard") || lower.includes("write_guard"))
+        return "write-guard";
+    if (lower.includes("decision-envelope") || lower.includes("decision_envelope"))
+        return "decision-envelope";
+    if (lower.includes("human-rejected"))
+        return "human-rejected";
+    if (lower.includes("human-required"))
+        return "human-required";
+    if (lower.includes("static-error"))
+        return "static-error";
+    if (lower.includes("nonzero-exit") ||
+        lower.includes("spawn-error") ||
+        lower.includes("shell"))
+        return "shell-command";
+    return undefined;
+}
+export function isDagFailureCategory(value) {
+    return DAG_NORMALIZED_FAILURE_CATEGORY_VALUES.includes(value);
+}
+export function normalizeDagFailureCategory(raw, status) {
+    if (status === "SKIPPED") {
+        return "skipped";
+    }
+    if (raw !== undefined) {
+        const mapped = mapRawCategory(raw);
+        if (mapped) {
+            if (mapped === "success") {
+                return isFinishedStatus(status) ? "success" : "unknown";
+            }
+            return mapped;
+        }
+    }
+    if (raw === undefined && isFinishedStatus(status)) {
+        return "success";
+    }
+    if (isInProgressStatus(status)) {
+        return "unknown";
+    }
+    if (isFailureStatus(status)) {
+        return "unknown";
+    }
+    if (raw === "success" && isFinishedStatus(status)) {
+        return "success";
+    }
+    return "unknown";
+}

package/dist/shared/dag-prompt-override.js

@@ -0,0 +1,27 @@
+/**
+ * Internal switch for the experimental "rerun failed node with an edited
+ * prompt" capability. The feature is enabled by default; the environment
+ * variable remains as an emergency kill switch while the feature is internal.
+ */
+export const DAG_RERUN_PROMPT_OVERRIDE_ENV = "HARNESS_DAG_RERUN_PROMPT_OVERRIDE";
+/** Upper bound for an override input body (characters). */
+export const MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS = 65_536;
+export function isDagRerunPromptOverrideEnabled(env = process.env) {
+    const value = env[DAG_RERUN_PROMPT_OVERRIDE_ENV]?.trim().toLowerCase();
+    return value !== "0" && value !== "false" && value !== "off";
+}
+export const DAG_RERUN_PROMPT_ADDENDUM_TAG = "operator_addendum";
+/**
+ * Compose the final subtask_prompt for a rerun override.
+ * - "replace": the operator text becomes the whole prompt (advanced mode).
+ * - "append" (recommended): the frozen base prompt is kept verbatim and the
+ *   operator addendum is appended in a clearly marked block, mirroring the
+ *   rerunFeedback / retry_instruction augmentation semantics — small diffs,
+ *   no risk of dropping template scaffolding.
+ */
+export function composeDagPromptOverridePrompt(input) {
+    if (input.mode === "replace") {
+        return input.text;
+    }
+    return `${input.basePrompt}\n\n<${DAG_RERUN_PROMPT_ADDENDUM_TAG}>\n${input.text.trim()}\n</${DAG_RERUN_PROMPT_ADDENDUM_TAG}>\n`;
+}

package/dist/shared/openspec-spec.js

@@ -12,6 +12,19 @@ export const OPENSPEC_SPEC_DIRS = [
     "openspec/project-specs",
     "ai_workspace",
 ];
+/** Default roots used when a frontend task does not declare specRoots. */
+export const DEFAULT_FRONTEND_SPEC_ROOTS = OPENSPEC_SPEC_DIRS;
+/** A task-owned spec root must be a normalized, repo-relative POSIX directory. */
+export function isValidFrontendSpecRoot(value) {
+    return (Boolean(value) &&
+        !value.includes("\\") &&
+        !value.startsWith("/") &&
+        !value.includes("//") &&
+        !value.split("/").some((segment) => !segment ||
+            segment === "." ||
+            segment === ".." ||
+            /\s/.test(segment)));
+}
 /** Allowed spec file extensions (case-insensitive). */
 export const OPENSPEC_SPEC_EXT_RE = /\.(md|mdx|json|yaml|yml)$/i;
 /**
@@ -43,14 +56,17 @@ export function isGovernanceSubtreePath(filePath, governanceRoot) {
  * directories.  `filePath` must be a repo-relative POSIX path (backslashes are
  * normalised internally).  Directory names are case-sensitive.
  */
-export function isOpenspecSpecPath(filePath) {
+export function isFrontendSpecPath(filePath, specRoots = DEFAULT_FRONTEND_SPEC_ROOTS) {
     const normalized = filePath.replaceAll("\\", "/");
-    for (const dir of OPENSPEC_SPEC_DIRS) {
+    for (const dir of specRoots) {
         if (normalized === dir || normalized.startsWith(dir + "/"))
             return true;
     }
     return false;
 }
+export function isOpenspecSpecPath(filePath) {
+    return isFrontendSpecPath(filePath);
+}
 /**
  * Returns `true` when `filename` (the basename only, not a full path) has an
  * allowed frontend specification extension.
@@ -59,10 +75,13 @@ export function isValidOpenspecExtension(filename) {
     return OPENSPEC_SPEC_EXT_RE.test(filename);
 }
 /** Returns `true` for a supported file inside a canonical openspec spec dir. */
-export function isOpenspecSpecFilePath(filePath) {
-    return (isOpenspecSpecPath(filePath) &&
+export function isFrontendSpecFilePath(filePath, specRoots = DEFAULT_FRONTEND_SPEC_ROOTS) {
+    return (isFrontendSpecPath(filePath, specRoots) &&
         isValidOpenspecExtension(filePath.replaceAll("\\", "/")));
 }
+export function isOpenspecSpecFilePath(filePath) {
+    return isFrontendSpecFilePath(filePath);
+}
 /**
  * Returns `true` when free-form search input references a canonical frontend
  * specification directory with exact lowercase directory names.
@@ -123,3 +142,50 @@ export function extractTaskSourceOpenspecPaths(markdown, governanceRoot = DEFAUL
         !isGovernanceSubtreePath(token, governanceRoot))
         .sort();
 }
+/**
+ * Extract explicit specification-file citations for a task's frozen spec roots.
+ * This is intentionally path-only: source preparation decides which roots are
+ * normative, while DAG execution only consumes that frozen configuration.
+ */
+export function extractTaskSourceFrontendSpecPaths(markdown, specRoots, governanceRoot = DEFAULT_OPENSPEC_GOVERNANCE_ROOT) {
+    if (!markdown)
+        return [];
+    const raw = new Set();
+    const collect = (token) => {
+        const normalized = normalizeCitationToken(token);
+        if (normalized)
+            raw.add(normalized);
+    };
+    for (const match of markdown.matchAll(/`([^`\n]+)`/g))
+        collect(match[1] ?? "");
+    for (const match of markdown.matchAll(/\[[^\]]*\]\(([^)\s]+)\)/g))
+        collect(match[1] ?? "");
+    for (const root of specRoots) {
+        const escaped = root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        for (const match of markdown.matchAll(new RegExp(`(?:^|[\\s\"'([>])(${escaped}/[A-Za-z0-9._/-]+)`, "g"))) {
+            collect(match[1] ?? "");
+        }
+    }
+    return [...raw]
+        .filter((token) => isFrontendSpecFilePath(token, specRoots) && !isGovernanceSubtreePath(token, governanceRoot))
+        .sort();
+}
+/**
+ * Source-preparation helper for explicitly named normative directories. A root
+ * is inferred only on a line that declares a spec/规范/design-system intent;
+ * arbitrary Markdown links never silently broaden task configuration.
+ */
+export function extractDeclaredFrontendSpecRoots(markdown) {
+    const roots = new Set();
+    for (const line of markdown.split(/\r?\n/)) {
+        if (!/(?:规范|规约|标准|设计系统|\bspec(?:ification)?\b|\bdesign[ -]?system\b|\bguidelines?\b|\brules?\b)/i.test(line))
+            continue;
+        for (const match of line.matchAll(/`([^`]+)`|\[[^\]]+\]\(([^)\s]+)\)/g)) {
+            const raw = (match[1] ?? match[2] ?? "").replaceAll("\\", "/").replace(/\/+$/, "");
+            if (!raw || !isValidFrontendSpecRoot(raw))
+                continue;
+            roots.add(isValidOpenspecExtension(raw) ? raw.split("/").slice(0, -1).join("/") : raw);
+        }
+    }
+    return [...roots].filter(isValidFrontendSpecRoot).sort();
+}

package/dist/shared/operator/capabilities.js

@@ -1155,6 +1155,19 @@ export function buildOperatorCapabilitiesDocument() {
             modelCallable: "always",
             humanConfirmation: "none",
         },
+        {
+            action: "dagPromptOverrideConfig",
+            cli: "console dag-prompt-override-config",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [],
+            description: "Read-only probe of the experimental prompt-override rerun switch (env-gated, default off). The browser Recovery UI hides the failed-node prompt editor unless this returns enabled=true. Never mutates.",
+            inputParams: [],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
         {
             action: "dagRerunPlan",
             cli: "loop-agent dag rerun --run-id <id> --from-node <node> --plan --json",
@@ -1177,6 +1190,12 @@ export function buildOperatorCapabilitiesDocument() {
                     required: true,
                     description: "node id to rerun from (prefer failed/attention node from dagReport primaryFailure.nodeId)",
                 },
+                {
+                    name: "promptOverrides",
+                    type: "array",
+                    required: false,
+                    description: "experimental (switch off by default): [{nodeId, prompt, mode?}] — mode append (recommended) keeps the frozen base prompt and appends the text as a marked addendum block, replace swaps the whole subtask_prompt; only FAILED nodes inside the reset closure are admitted and the planHash binds the composed change",
+                },
             ],
             modelCallable: "always",
             humanConfirmation: "none",
@@ -1219,6 +1238,12 @@ export function buildOperatorCapabilitiesDocument() {
                     required: true,
                     description: "why continue from this node (e.g. provider flake; resume from review-pi)",
                 },
+                {
+                    name: "promptOverrides",
+                    type: "array",
+                    required: false,
+                    description: "experimental (switch off by default): must match the dagRerunPlan promptOverrides exactly (same mode/text); the planHash already binds them, any drift is rejected",
+                },
             ],
             // always: fresh eligible dagRerun plans are model-callable (2026-08-11).
             // The CLI keeps enforcing parent lifecycle, fromNode, planHash,
@@ -1822,6 +1847,13 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
         source: "loop-agent",
         exclusionReason: "Not exposed to Operator Chat in M5.",
     },
+    {
+        command: "loop-agent init model-catalog",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Not exposed to Operator Chat in M5.",
+    },
     {
         command: "loop-agent init doctor",
         coverage: "excluded",
@@ -2200,6 +2232,13 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
         source: "loop-agent",
         note: "server-side read-only run-facts check (ineligible plan / explicit rerun-task recommendation) replaces the browser Human Gate (2026-08-11).",
     },
+    {
+        command: "loop-agent dag follow-up",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+        exclusionReason: "Frontend review recovery helper is a direct advanced CLI composition (create/import task and optional advance), not an Operator action endpoint.",
+    },
     {
         command: "loop-agent dag reconcile-tasks",
         coverage: "human-gated-required",

package/dist/shared/playwright-cli-command-policy.js

@@ -9,6 +9,7 @@ export const PLAYWRIGHT_CLI_ALLOWED_COMMANDS = [
     "goto",
     "snapshot",
     "find",
+    "find-unique",
     "click",
     "dblclick",
     "fill",
@@ -35,6 +36,20 @@ export const PLAYWRIGHT_CLI_ALLOWED_COMMANDS = [
     "requests",
     "request",
 ];
+/**
+ * Parse the match count from a playwright-cli find output. The CLI prints
+ * `Found N match(es) for "...":` on success and `No matches found for "...".`
+ * on zero — both with exit code 0, so the count is the only assertion signal.
+ * Returns undefined when the output shape is unrecognized (e.g. error pages).
+ */
+export function parsePlaywrightCliFindMatchCount(output) {
+    const found = /Found\s+(\d+)\s+match(?:es)?\s+for\b/i.exec(output);
+    if (found)
+        return Number(found[1]);
+    if (/No matches found for\b/i.test(output))
+        return 0;
+    return undefined;
+}
 const allowedCommandSet = new Set(PLAYWRIGHT_CLI_ALLOWED_COMMANDS);
 export function isPlaywrightCliCommand(value) {
     return allowedCommandSet.has(value);

package/dist/shared/update/console-notifier.js

@@ -0,0 +1,100 @@
+import { createInterface } from "node:readline/promises";
+import semver from "semver";
+import { acquireUpdateLock, readUpdateState, updateLockPath, updateStatePath, writeUpdateState, } from "./state.js";
+export async function runConsoleDailyUpdateCheck(options) {
+    void options.writeStdout;
+    void options.packageRoot;
+    void options.cwd;
+    const writeStderr = options.writeStderr ?? ((chunk) => process.stderr.write(chunk));
+    const now = options.now ?? (() => new Date());
+    try {
+        if (!canPromptInteractively(options))
+            return;
+        const statePath = updateStatePath(options.homeDir);
+        const today = formatLocalDate(now());
+        const existing = await readUpdateState(statePath);
+        if (existing.lastPromptedLocalDate === today)
+            return;
+        const release = await acquireUpdateLock(updateLockPath(options.homeDir), {
+            now,
+        });
+        if (!release)
+            return;
+        try {
+            const state = await readUpdateState(statePath);
+            if (state.lastPromptedLocalDate === today)
+                return;
+            const check = await options.client.latestVersionCheck();
+            if (!check.ok)
+                return;
+            if (!semver.gt(check.version, options.currentVersion))
+                return;
+            const parsedLatest = semver.parse(check.version);
+            if (!parsedLatest || parsedLatest.prerelease.length > 0)
+                return;
+            await markPromptedToday(statePath, state, today);
+            const answer = await ask(options, `loop-agent 有新版本：${options.currentVersion} → ${check.version}\n现在更新到 ${check.version}？[y/N] `);
+            if (!isYes(answer))
+                return;
+            const proof = await options.client.canAutoInstall();
+            if (!proof.ok) {
+                writeStderr(`当前 loop-agent 不是由此 npm 的正式全局安装管理，无法自动升级。\n请运行：npm install -g @tea-agent/loop-agent@${check.version}\n`);
+                return;
+            }
+            const install = await options.client.installExact(check.version);
+            if (!install.ok) {
+                writeStderr(`loop-agent 更新失败：${install.reason}\n`);
+                return;
+            }
+            const verified = await options.client.verifyInstalled(check.version);
+            if (!verified.ok) {
+                writeStderr(`loop-agent 已尝试安装，但验证失败：${verified.reason}\n`);
+                return;
+            }
+            writeStderr(`loop-agent 已更新到 ${check.version}；新版本将在下一次命令调用时完全生效。\n`);
+        }
+        finally {
+            await release().catch(() => undefined);
+        }
+    }
+    catch (error) {
+        writeStderr(`loop-agent 更新检查已跳过：${error instanceof Error ? error.message : String(error)}\n`);
+    }
+}
+function canPromptInteractively(options) {
+    if (!options.stdinIsTTY || !options.stderrIsTTY)
+        return false;
+    if (options.env.CI)
+        return false;
+    if (options.env.LOOP_AGENT_DISABLE_UPDATE_CHECK === "1")
+        return false;
+    return true;
+}
+function formatLocalDate(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+async function markPromptedToday(statePath, state, today) {
+    await writeUpdateState(statePath, {
+        ...state,
+        lastPromptedLocalDate: today,
+    });
+}
+async function ask(options, prompt) {
+    if (options.readLine) {
+        options.writeStderr?.(prompt);
+        return options.readLine(prompt);
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return await rl.question(prompt);
+    }
+    finally {
+        rl.close();
+    }
+}
+function isYes(answer) {
+    return /^(y|yes)$/i.test(answer.trim());
+}