@co0ontty/wand 1.43.7 → 1.44.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "e30a59c36bbf6143ba83af70d01db35a7fb449b3",
-  "builtAt": "2026-05-31T08:35:33.496Z",
-  "version": "1.43.7",
+  "commit": "82bf2e6b3f7f01bbee5ee3213967f3316020601b",
+  "builtAt": "2026-05-31T13:20:33.303Z",
+  "version": "1.44.0",
   "channel": "stable"
 }

package/dist/env-utils.d.ts

@@ -1,3 +1,5 @@
+/** 是否以 root 身份运行（uid 或 euid 为 0）。供 PTY runner 与 structured runner 共用。 */
+export declare function isRunningAsRoot(): boolean;
 /**
  * 根据 inheritEnv 配置组装子进程的环境变量。
  *

package/dist/env-utils.js

@@ -19,6 +19,10 @@ const MINIMAL_ENV_KEYS = [
     "TEMP",
     "PWD",
 ];
+/** 是否以 root 身份运行（uid 或 euid 为 0）。供 PTY runner 与 structured runner 共用。 */
+export function isRunningAsRoot() {
+    return process.getuid?.() === 0 || process.geteuid?.() === 0;
+}
 /**
  * 根据 inheritEnv 配置组装子进程的环境变量。
  *

package/dist/git-quick-commit.d.ts

@@ -10,6 +10,11 @@ interface QuickCommitOptions {
     /** When `tag` is empty, ask Claude to generate one based on the diff + commit message. */
     autoTag?: boolean;
     push?: boolean;
+    /**
+     * 是否把 commit / tag / push 递归进入各 submodule 内部。默认 false：
+     * 只处理父仓库自身（含已变化的 submodule 指针），不碰 submodule 内部 dirty。
+     */
+    submodule?: boolean;
 }
 export declare class QuickCommitError extends Error {
     readonly code: QuickCommitErrorCode;
@@ -35,6 +40,10 @@ interface PushOptions {
     cwd: string;
     pushCommits?: boolean;
     pushTags?: boolean;
+    /** 是否同时把各 submodule 的 HEAD（+ 同名 tag）分别推送到各自远端分支。 */
+    submodule?: boolean;
+    /** `submodule` + `pushTags` 时，要连带推送到 submodule 的同名 tag。 */
+    tagName?: string;
 }
 export declare function runPush(opts: PushOptions): Promise<PushResult>;
 export declare function runQuickCommit(opts: QuickCommitOptions): Promise<QuickCommitResult>;

package/dist/git-quick-commit.js

@@ -241,6 +241,8 @@ export function getGitStatus(cwd) {
         behind,
         lastCommit,
         latestTag,
+        // 基于全量 allEntries 判定（不受 files 的 200 条 slice 影响），供前端决定是否渲染 Submodule 球。
+        hasSubmodule: allEntries.some((e) => e.isSubmodule),
     };
 }
 export class QuickCommitError extends Error {
@@ -445,6 +447,7 @@ ${diff}`;
  */
 function doPush(opts) {
     const { cwd, pushCommits, pushTags } = opts;
+    const recurseFlag = `--recurse-submodules=${opts.recurseSubmodules ?? "check"}`;
     let pushedCommits = false;
     let pushedTags = false;
     let hasUpstream = false;
@@ -459,10 +462,10 @@ function doPush(opts) {
     try {
         if (pushCommits) {
             if (hasUpstream) {
-                runGit(["push", "--recurse-submodules=on-demand"], cwd, GIT_PUSH_TIMEOUT_MS);
+                runGit(["push", recurseFlag], cwd, GIT_PUSH_TIMEOUT_MS);
             }
             else {
-                runGit(["push", "-u", "--recurse-submodules=on-demand", pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
+                runGit(["push", "-u", recurseFlag, pushRemote, "HEAD"], cwd, GIT_PUSH_TIMEOUT_MS);
             }
             pushedCommits = true;
         }
@@ -538,19 +541,63 @@ export async function runTagHead(opts) {
     };
 }
 export async function runPush(opts) {
-    const { cwd, pushCommits = true, pushTags = false } = opts;
+    const { cwd, pushCommits = true, pushTags = false, submodule = false, tagName } = opts;
     assertGitWorkTree(cwd);
     if (!pushCommits && !pushTags) {
         throw new QuickCommitError("没有要推送的内容。", "NOTHING_TO_PUSH");
     }
-    const outcome = doPush({ cwd, pushCommits, pushTags });
+    // 纳入 submodule：逐个把声明的 submodule 的 HEAD 推到各自远端分支（已是最新则 git 自身 no-op）。
+    // 这覆盖「先 commit（含 submodule）后补 Push & Close」的场景——此时 submodule 已 clean、
+    // status 看不到，但本地可能仍领先远端。父仓库随后用 recurse=no 推送。
+    let subPushErrors = [];
+    if (submodule) {
+        const { base, infos } = collectSubmodulesForPush(cwd);
+        if (infos.length > 0) {
+            const subPush = pushSubmodules(base, infos, { pushTags: !!(pushTags && tagName), tagName });
+            subPushErrors = subPush.errors;
+        }
+    }
+    const outcome = doPush({ cwd, pushCommits, pushTags, recurseSubmodules: submodule ? "no" : "check" });
     return {
-        ok: !outcome.error,
+        ok: !outcome.error && subPushErrors.length === 0,
         pushedCommits: outcome.pushedCommits,
         pushedTags: outcome.pushedTags,
-        error: outcome.error,
+        error: outcome.error || (subPushErrors.length ? subPushErrors.join("；") : undefined),
     };
 }
+/**
+ * 解析一个 submodule 当前 HEAD 应推到哪个远端分支。submodule 经 `git submodule update`
+ * 后通常处于 detached HEAD，不能直接 `git push`，必须显式 `HEAD:<branch>`，否则父仓库
+ * `--recurse-submodules=on-demand` 会以「HEAD does not match the named branch」整体失败。
+ * 优先取远端默认分支（`<remote>/HEAD` 指向）→ 当前命名分支 → 回退 main/master。
+ */
+function resolveSubmodulePushBranch(subCwd, remote) {
+    const prefix = `${remote}/`;
+    try {
+        const ref = runGit(["symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`], subCwd);
+        const name = (ref.startsWith(prefix) ? ref.slice(prefix.length) : ref).trim();
+        if (name)
+            return name;
+    }
+    catch {
+        // ignore — fall through
+    }
+    try {
+        const cur = runGit(["branch", "--show-current"], subCwd);
+        if (cur)
+            return cur;
+    }
+    catch {
+        // ignore
+    }
+    try {
+        runGit(["rev-parse", "--verify", `refs/remotes/${remote}/main`], subCwd);
+        return "main";
+    }
+    catch {
+        return "master";
+    }
+}
 /**
  * 在 commit 父仓库之前，先在每个内部 dirty / untracked 的 submodule 里
  * 执行一次 `git add -A` + `git commit -m <msg>`，让父仓库的 add -A
@@ -615,12 +662,109 @@ function commitDirtySubmodules(parentCwd, message) {
             hash = runGit(["rev-parse", "--short", "HEAD"], subCwd);
         }
         catch { /* ignore */ }
-        commits.push({ path: entry.path, hash });
+        const remote = resolvePushRemote(subCwd);
+        const branch = resolveSubmodulePushBranch(subCwd, remote);
+        commits.push({ path: entry.path, hash, remote, branch });
     }
     return { commits, errors };
 }
+/** 对刚提交的 submodule 打上与父仓库同名的 tag。已存在同名 tag 则记为非致命跳过。 */
+function tagSubmodules(parentCwd, subInfos, tagName) {
+    const tagged = [];
+    const errors = [];
+    for (const info of subInfos) {
+        const subCwd = `${parentCwd}/${info.path}`;
+        try {
+            runGit(["rev-parse", "--verify", `refs/tags/${tagName}`], subCwd);
+            errors.push(`submodule ${info.path} 已存在 tag ${tagName}，跳过`);
+            continue;
+        }
+        catch {
+            // 不存在 → 继续打 tag
+        }
+        try {
+            runGit(["tag", tagName], subCwd);
+            tagged.push(info.path);
+        }
+        catch (error) {
+            errors.push(`submodule ${info.path} 打 tag 失败：${getGitErrorMessage(error)}`);
+        }
+    }
+    return { tagged, errors };
+}
+/**
+ * 对每个 submodule 单独把当前 HEAD 推送到其远端分支（`HEAD:refs/heads/<branch>`），
+ * 解决 detached HEAD 无法直接 push 的问题；`pushTags` 时连带把同名 tag 推上去。
+ * 单个 submodule 失败收集为非致命错误。
+ */
+function pushSubmodules(parentCwd, subInfos, opts) {
+    const pushed = [];
+    const errors = [];
+    for (const info of subInfos) {
+        const subCwd = `${parentCwd}/${info.path}`;
+        if (!existsSync(subCwd)) {
+            errors.push(`submodule ${info.path} 路径不存在`);
+            continue;
+        }
+        try {
+            runGit(["push", info.remote, `HEAD:refs/heads/${info.branch}`], subCwd, GIT_PUSH_TIMEOUT_MS);
+        }
+        catch (error) {
+            errors.push(`submodule ${info.path} 推送失败：${getGitErrorMessage(error)}`);
+            continue;
+        }
+        if (opts.pushTags && opts.tagName) {
+            try {
+                runGit(["push", info.remote, `refs/tags/${opts.tagName}`], subCwd, GIT_PUSH_TIMEOUT_MS);
+            }
+            catch (error) {
+                errors.push(`submodule ${info.path} 推送 tag 失败：${getGitErrorMessage(error)}`);
+            }
+        }
+        pushed.push(info.path);
+    }
+    return { pushed, errors };
+}
+/**
+ * 枚举仓库声明的全部 submodule（读 repo 根的 .gitmodules），为「单独 push」准备
+ * remote + 目标分支。用于结果面板的 Push & Close：此时 submodule 多已 clean，
+ * status 里看不到，但本地 HEAD 可能仍领先远端，需要逐个尝试推送（up-to-date 则 no-op）。
+ */
+function collectSubmodulesForPush(cwd) {
+    let base;
+    try {
+        base = runGit(["rev-parse", "--show-toplevel"], cwd);
+    }
+    catch {
+        base = cwd;
+    }
+    let raw;
+    try {
+        raw = runGitAllowEmpty(["config", "-f", `${base}/.gitmodules`, "--get-regexp", "\\.path$"], base);
+    }
+    catch {
+        return { base, infos: [] };
+    }
+    const infos = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // 行格式：submodule.<name>.path <relpath>
+        const rel = trimmed.split(/\s+/).slice(1).join(" ").trim();
+        if (!rel)
+            continue;
+        const subCwd = `${base}/${rel}`;
+        if (!existsSync(subCwd))
+            continue;
+        const remote = resolvePushRemote(subCwd);
+        const branch = resolveSubmodulePushBranch(subCwd, remote);
+        infos.push({ path: rel, hash: "", remote, branch });
+    }
+    return { base, infos };
+}
 export async function runQuickCommit(opts) {
-    const { cwd, language, autoMessage, customMessage, tag, autoTag, push } = opts;
+    const { cwd, language, autoMessage, customMessage, tag, autoTag, push, submodule } = opts;
     assertGitWorkTree(cwd);
     // 先 add 一次让我们能在 collectStagedDiff 看到完整改动（包含 submodule 指针），
     // AI 生成 message 时也基于这个 staged diff。
@@ -646,7 +790,11 @@ export async function runQuickCommit(opts) {
         submoduleHasDirty = parsePorcelainV2(porcelain).some((e) => e.isSubmodule && (e.submoduleState?.hasTrackedChanges || e.submoduleState?.hasUntracked));
     }
     catch { /* keep submoduleHasDirty=false */ }
-    if (!parentHasStaged && !submoduleHasDirty) {
+    // 默认不纳入 submodule：只有显式 opts.submodule 时，submodule 内部 dirty 才计入「有改动」。
+    if (!parentHasStaged && !(submodule && submoduleHasDirty)) {
+        if (submoduleHasDirty && !submodule) {
+            throw new QuickCommitError("父仓库没有改动；检测到 submodule 内部有改动，拖入 Submodule 球可一起提交。", "NOTHING_TO_COMMIT");
+        }
         throw new QuickCommitError("没有任何改动可以提交。", "NOTHING_TO_COMMIT");
     }
     let message;
@@ -659,22 +807,25 @@ export async function runQuickCommit(opts) {
             throw new QuickCommitError("commit message 不能为空。", "EMPTY_MESSAGE");
         }
     }
-    // 先提交 submodule 内部改动；父仓库随后再 add 一次，picks up 新的 submodule 指针。
-    const submoduleOutcome = commitDirtySubmodules(cwd, message);
-    if (submoduleOutcome.commits.length > 0) {
-        try {
-            runGit(["add", "-A"], cwd, 5000);
-        }
-        catch (error) {
-            throw new QuickCommitError(`父仓库 add submodule 指针失败：${getGitErrorMessage(error)}`, "GIT_ADD_FAILED");
-        }
-        // 重新评估父仓库是否有 staged 内容：如果 submodule 是新引入的或指针变了，
-        // 这里应当为真；如果完全没变就走 commit --allow-empty 路径不合适，直接报错。
-        try {
-            stagedFiles = runGitAllowEmpty(["diff", "--cached", "--name-only"], cwd).trim();
-            parentHasStaged = stagedFiles.length > 0;
+    // 仅当用户显式纳入 submodule 时，才进入各 submodule 内部提交其 dirty 改动；
+    // 父仓库随后再 add 一次，picks up 新的 submodule 指针。
+    let submoduleOutcome = { commits: [], errors: [] };
+    if (submodule) {
+        submoduleOutcome = commitDirtySubmodules(cwd, message);
+        if (submoduleOutcome.commits.length > 0) {
+            try {
+                runGit(["add", "-A"], cwd, 5000);
+            }
+            catch (error) {
+                throw new QuickCommitError(`父仓库 add submodule 指针失败：${getGitErrorMessage(error)}`, "GIT_ADD_FAILED");
+            }
+            // 重新评估父仓库是否有 staged 内容：submodule 指针变了这里应为真。
+            try {
+                stagedFiles = runGitAllowEmpty(["diff", "--cached", "--name-only"], cwd).trim();
+                parentHasStaged = stagedFiles.length > 0;
+            }
+            catch { /* keep stale value */ }
         }
-        catch { /* keep stale value */ }
     }
     if (!parentHasStaged) {
         // submodule 都提交了但父仓库还是没有 staged —— 通常意味着 .gitmodules 没动
@@ -710,18 +861,32 @@ export async function runQuickCommit(opts) {
         catch (error) {
             throw new QuickCommitError(`git tag 失败：${getGitErrorMessage(error)}`, "GIT_TAG_FAILED");
         }
+        // 纳入 submodule 时给刚提交的 submodule 打同名 tag（非致命，失败不阻断父仓库流程）。
+        if (submodule && submoduleOutcome.commits.length > 0) {
+            tagSubmodules(cwd, submoduleOutcome.commits, tagName);
+        }
     }
     let pushed = false;
     let pushError;
     if (push) {
+        // 纳入 submodule：先把各 submodule 的 HEAD（+ 同名 tag）分别推到各自远端分支，
+        // 解决 detached HEAD 无法被父仓库 on-demand 递归推送的问题；父仓库随后用
+        // recurse=no 单独推（submodule 已就绪）。否则父仓库用 recurse=check 做安全校验。
+        const includeSub = !!submodule && submoduleOutcome.commits.length > 0;
+        let subPushErrors = [];
+        if (includeSub) {
+            const subPush = pushSubmodules(cwd, submoduleOutcome.commits, { pushTags: !!tagName, tagName });
+            subPushErrors = subPush.errors;
+        }
         const outcome = doPush({
             cwd,
             pushCommits: true,
             // Push only the freshly-created tag — avoids surprising users by pushing stale local tags.
             pushTags: tagName ? [tagName] : false,
+            recurseSubmodules: includeSub ? "no" : "check",
         });
-        pushed = outcome.pushedCommits && (tagName ? outcome.pushedTags : true);
-        pushError = outcome.error;
+        pushed = outcome.pushedCommits && (tagName ? outcome.pushedTags : true) && subPushErrors.length === 0;
+        pushError = outcome.error || (subPushErrors.length ? subPushErrors.join("；") : undefined);
     }
     return {
         ok: true,

package/dist/language-prompt.d.ts

@@ -15,3 +15,8 @@
  * 英文模式（"English"）下 Claude 默认就用英文，只补一句 subagent 透传。
  */
 export declare function buildLanguageDirective(language: string): string;
+/**
+ * 完全托管自主模式的系统提示：供 PTY runner 与 structured runner（CLI + SDK）共用，
+ * 避免两处各抄一份中英双语文案导致改一处漏一处。
+ */
+export declare function buildManagedAutonomyDirective(isChinese: boolean): string;

package/dist/language-prompt.js

@@ -66,3 +66,12 @@ export function buildLanguageDirective(language) {
         `Subagent: when you dispatch a subagent via the Task tool, you MUST explicitly instruct the subagent in its prompt to also respond in ${trimmed}.`,
     ].join("\n");
 }
+/**
+ * 完全托管自主模式的系统提示：供 PTY runner 与 structured runner（CLI + SDK）共用，
+ * 避免两处各抄一份中英双语文案导致改一处漏一处。
+ */
+export function buildManagedAutonomyDirective(isChinese) {
+    return isChinese
+        ? "你正在完全托管的自主模式下运行。用户可能无法及时回复问题或确认。你必须独立做出所有决策——自行选择最佳方案，而不是向用户询问偏好、确认或澄清。如果有多种可行方案，选择你认为最合适的并继续执行。除非任务本身存在根本性的歧义且无法合理推断，否则不要等待用户输入。果断行动，自主决策。"
+        : "You are running in a fully managed, autonomous mode. The user may not be available to respond to questions or confirmations in a timely manner. You MUST make all decisions independently — choose the best approach yourself instead of asking the user for preferences, confirmations, or clarifications. If multiple approaches are viable, pick the one you judge most appropriate and proceed. Never block on user input unless the task is fundamentally ambiguous and cannot be reasonably inferred. Be decisive and self-directed.";
+}

package/dist/models.d.ts

@@ -1,4 +1,4 @@
-import { ClaudeModelInfo, SessionProvider } from "./types.js";
+import { ClaudeModelInfo } from "./types.js";
 interface ModelCache {
     models: ClaudeModelInfo[];
     codexModels: ClaudeModelInfo[];
@@ -7,9 +7,4 @@ interface ModelCache {
 }
 export declare function getCachedModels(): ModelCache;
 export declare function refreshModels(): Promise<ModelCache>;
-export declare function getModelsForProvider(provider: SessionProvider): ClaudeModelInfo[];
-/** 返回可用于 claude CLI 的全部已知 model id（含别名） */
-export declare function knownModelIds(): string[];
-/** 判断传入值是否是已知模型；允许自由文本，因此总是返回 true。保留接口以便将来严格校验。 */
-export declare function isKnownModel(_value: string): boolean;
 export {};

package/dist/models.js

@@ -1,5 +1,6 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import { extractSemver } from "./version-utils.js";
 const execAsync = promisify(exec);
 const CLAUDE_MODELS = [
     { id: "default", label: "default（跟随 Claude Code 默认）", alias: true },
@@ -21,8 +22,7 @@ function cloneClaudeModels() {
 async function probeClaudeVersion() {
     try {
         const { stdout } = await execAsync("claude --version", { timeout: 5000 });
-        const match = stdout.match(/\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?/);
-        return match ? match[0] : stdout.trim().slice(0, 64) || null;
+        return extractSemver(stdout) ?? (stdout.trim().slice(0, 64) || null);
     }
     catch {
         return null;
@@ -78,15 +78,3 @@ export async function refreshModels() {
     };
     return cache;
 }
-export function getModelsForProvider(provider) {
-    const cached = getCachedModels();
-    return provider === "codex" ? cached.codexModels : cached.models;
-}
-/** 返回可用于 claude CLI 的全部已知 model id（含别名） */
-export function knownModelIds() {
-    return CLAUDE_MODELS.map((m) => m.id);
-}
-/** 判断传入值是否是已知模型；允许自由文本，因此总是返回 true。保留接口以便将来严格校验。 */
-export function isKnownModel(_value) {
-    return true;
-}

package/dist/npm-update-utils.d.ts

@@ -58,4 +58,3 @@ export declare function installPackageGloballySync(pkg: string, timeoutMs: numbe
  * （npm 全局 bin 里的符号链接，node 跟随软链一样能跑）。都找不到返回 null。
  */
 export declare function resolveGlobalWandCli(): string | null;
-export declare const NPM_UPDATE_PACKAGE_NAME = "@co0ontty/wand";

package/dist/npm-update-utils.js

@@ -17,6 +17,7 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { promisify } from "node:util";
+import { whichSync } from "./path-repair.js";
 const execFileAsync = promisify(execFile);
 const PACKAGE_NAME = "@co0ontty/wand";
 const PACKAGE_SCOPE = "@co0ontty";
@@ -407,18 +408,8 @@ export function resolveGlobalWandCli() {
             /* ignore */
         }
     }
-    try {
-        const tool = process.platform === "win32" ? "where" : "which";
-        const r = spawnSync(tool, ["wand"], { encoding: "utf8", timeout: 10_000, env: getChildEnv() });
-        if (r.status === 0) {
-            const first = (r.stdout || "").split(/\r?\n/).find((line) => line.trim().length > 0);
-            if (first)
-                return first.trim();
-        }
-    }
-    catch {
-        /* ignore */
-    }
+    const found = whichSync("wand", { env: getChildEnv(), timeoutMs: 10_000 });
+    if (found)
+        return found;
     return null;
 }
-export const NPM_UPDATE_PACKAGE_NAME = PACKAGE_NAME;

package/dist/path-repair.d.ts

@@ -68,6 +68,10 @@ export declare function deepRepairRuntimePath(result: PathRepairResult, opts?: {
     shell?: string;
     timeoutMs?: number;
 }): Promise<PathRepairResult>;
+export declare function whichSync(cmd: string, options?: {
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}): string | null;
 /**
  * 把修复结果格式化为一行可读摘要（startServer 启动日志用）。
  *

package/dist/path-repair.js

@@ -1,4 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
+import { compareSemver } from "./version-utils.js";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -84,24 +85,13 @@ function listLatestVersions(base, limit) {
         const entries = readdirSync(base);
         return entries
             .filter((e) => /^v?\d+\.\d+\.\d+/.test(e))
-            .sort((a, b) => semverCompare(b, a))
+            .sort((a, b) => compareSemver(b, a))
             .slice(0, limit);
     }
     catch {
         return [];
     }
 }
-function semverCompare(a, b) {
-    const pa = a.replace(/^v/, "").split(/[.\-+]/).map((x) => Number(x) || 0);
-    const pb = b.replace(/^v/, "").split(/[.\-+]/).map((x) => Number(x) || 0);
-    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-        const da = pa[i] ?? 0;
-        const db = pb[i] ?? 0;
-        if (da !== db)
-            return da - db;
-    }
-    return 0;
-}
 /**
  * 把候选目录中"存在 + 未在 PATH 中"的追加到 process.env.PATH。
  *
@@ -328,12 +318,12 @@ function probeCommands() {
     }
     return out;
 }
-function whichSync(cmd) {
-    // Windows 用 `where`，POSIX 用 `which`；都走 process.env.PATH，因此一定要在
-    // repairRuntimePath() 追加完 PATH 之后再调。
+export function whichSync(cmd, options) {
+    // Windows 用 `where`，POSIX 用 `which`。默认走 process.env.PATH（因此一定要在
+    // repairRuntimePath() 追加完 PATH 之后再调）；options.env 可覆盖（如用 buildChildEnv 的 PATH）。
     const tool = process.platform === "win32" ? "where" : "which";
     try {
-        const res = spawnSync(tool, [cmd], { encoding: "utf8" });
+        const res = spawnSync(tool, [cmd], { encoding: "utf8", env: options?.env, timeout: options?.timeoutMs });
         if (res.status !== 0)
             return null;
         const first = (res.stdout || "").split(/\r?\n/).find((line) => line.trim().length > 0);

package/dist/process-manager.d.ts

@@ -144,8 +144,6 @@ export declare class ProcessManager extends EventEmitter {
      * Handle events from ClaudePtyBridge
      */
     private handleBridgeEvent;
-    /** Check if a command is a Claude CLI command */
-    private isClaudeCommand;
     private mustGet;
     private buildShellArgs;
     private shouldAutoApprovePermissions;

package/dist/process-manager.js

@@ -9,17 +9,14 @@ import { SessionLogger } from "./session-logger.js";
 import { ClaudePtyBridge } from "./claude-pty-bridge.js";
 import { truncateMessagesForTransport } from "./message-truncator.js";
 import { appendWindow, hasExplicitConfirmSyntax, hasPermissionActionContext, normalizePromptText, PTY_OUTPUT_MAX_SIZE } from "./pty-text-utils.js";
-import { buildChildEnv } from "./env-utils.js";
-import { buildLanguageDirective } from "./language-prompt.js";
+import { buildChildEnv, isRunningAsRoot } from "./env-utils.js";
+import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
 import { getCodexResumeCommandSessionId, getResumeCommandSessionId } from "./resume-policy.js";
 import { applyThinkingEffortToPrompt, normalizeThinkingEffort } from "./structured-session-manager.js";
 function resolveProviderFromCommand(command) {
     return /^codex\b/.test(command.trim()) ? "codex" : "claude";
 }
-function isRunningAsRoot() {
-    return typeof process.getuid === "function" && process.getuid() === 0;
-}
 export class SessionInputError extends Error {
     code;
     sessionId;
@@ -1866,11 +1863,6 @@ export class ProcessManager extends EventEmitter {
                 break;
         }
     }
-    /** Check if a command is a Claude CLI command */
-    isClaudeCommand(command) {
-        const trimmed = command.trim();
-        return /^claude\b/.test(trimmed);
-    }
     mustGet(id) {
         const record = this.sessions.get(id);
         if (!record) {
@@ -1953,9 +1945,7 @@ export class ProcessManager extends EventEmitter {
         const language = this.config.language?.trim();
         const isChinese = language === "中文";
         if (mode === "managed") {
-            const autonomousPrompt = isChinese
-                ? "你正在完全托管的自主模式下运行。用户可能无法及时回复问题或确认。你必须独立做出所有决策——自行选择最佳方案，而不是向用户询问偏好、确认或澄清。如果有多种可行方案，选择你认为最合适的并继续执行。除非任务本身存在根本性的歧义且无法合理推断，否则不要等待用户输入。果断行动，自主决策。"
-                : "You are running in a fully managed, autonomous mode. The user may not be available to respond to questions or confirmations in a timely manner. You MUST make all decisions independently — choose the best approach yourself instead of asking the user for preferences, confirmations, or clarifications. If multiple approaches are viable, pick the one you judge most appropriate and proceed. Never block on user input unless the task is fundamentally ambiguous and cannot be reasonably inferred. Be decisive and self-directed.";
+            const autonomousPrompt = buildManagedAutonomyDirective(isChinese);
             const escaped = autonomousPrompt.replace(/'/g, "'\\''");
             result += ` --append-system-prompt '${escaped}'`;
         }

package/dist/pty-text-utils.d.ts

@@ -22,8 +22,6 @@ export declare function isNoiseLine(line: string): boolean;
  * The returned buffer may be slightly shorter than maxSize.
  */
 export declare function appendWindow(buffer: string, chunk: string, maxSize: number): string;
-/** Slice keeping the last ~maxSize chars on a safe boundary. Exported for tests. */
-export declare function safeSliceTail(text: string, maxSize: number): string;
 /**
  * Strip a string down to the printable codepoints used for echo matching.
  * Removes control characters, whitespace and ANSI escapes; keeps all other

package/dist/pty-text-utils.js

@@ -137,8 +137,8 @@ export function appendWindow(buffer, chunk, maxSize) {
         return next;
     return safeSliceTail(next, maxSize);
 }
-/** Slice keeping the last ~maxSize chars on a safe boundary. Exported for tests. */
-export function safeSliceTail(text, maxSize) {
+/** Slice keeping the last ~maxSize chars on a safe boundary. */
+function safeSliceTail(text, maxSize) {
     if (text.length <= maxSize)
         return text;
     let start = text.length - maxSize;

package/dist/resume-policy.d.ts

@@ -1,4 +1,2 @@
-import { ConversationTurn } from "./types.js";
-export declare function hasRealConversationMessages(messages: ConversationTurn[] | undefined): boolean;
 export declare function getResumeCommandSessionId(command: string): string | null;
 export declare function getCodexResumeCommandSessionId(command: string): string | null;

package/dist/resume-policy.js

@@ -1,17 +1,6 @@
-const REAL_CONVERSATION_MIN_MESSAGES = 2;
 const UUID_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 const RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)--resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
 const CODEX_RESUME_COMMAND_ID_PATTERN = new RegExp(`(?:^|\\s)resume\\s+(${UUID_PATTERN})(?:\\s|$)`, "i");
-export function hasRealConversationMessages(messages) {
-    if (!messages || messages.length < REAL_CONVERSATION_MIN_MESSAGES) {
-        return false;
-    }
-    const hasUser = messages.some((turn) => turn.role === "user"
-        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
-    const hasAssistant = messages.some((turn) => turn.role === "assistant"
-        && turn.content.some((block) => block.type === "text" && block.text.trim().length > 0));
-    return hasUser && hasAssistant;
-}
 export function getResumeCommandSessionId(command) {
     const match = RESUME_COMMAND_ID_PATTERN.exec(command);
     return match?.[1] ?? null;