@tea-agent/loop-agent 0.43.0-next.4 → 0.43.0-next.5

package/dist/worker/console/chat/scm-service.js

@@ -0,0 +1,253 @@
+/**
+ * Operator Chat — source control service (DSH-style SCM).
+ *
+ * Workspace-scoped git operations shared by the Console UI panel and the
+ * model-facing tools:
+ *   - status: porcelain + branch + ahead/behind, parsed into typed changes
+ *   - diff:   working tree / staged, per-path or whole tree (bounded)
+ *   - stage / unstage / discard (path-scoped)
+ *   - commit (message required), log (bounded), branch list/switch/create
+ *   - push / pull (remote ops, explicit user/model intent only)
+ *
+ * All git invocations are fixed-argv execFile (no shell), bounded output and
+ * timeout, scoped to the workspace repoRoot. Failures return typed errors
+ * instead of throwing raw.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 20_000;
+const MAX_OUTPUT_CHARS = 200_000;
+function gitEnv() {
+    return {
+        ...process.env,
+        // Deterministic porcelain output regardless of user locale config.
+        GIT_PAGER: "cat",
+        LC_ALL: "C",
+    };
+}
+export class ScmService {
+    repoRoot;
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+    }
+    async git(args, opts) {
+        try {
+            const { stdout } = await execFileAsync("git", args, {
+                cwd: this.repoRoot,
+                encoding: "utf8",
+                maxBuffer: 4 * 1024 * 1024,
+                timeout: opts?.timeoutMs ?? GIT_TIMEOUT_MS,
+                windowsHide: true,
+                env: gitEnv(),
+            });
+            const cap = opts?.maxOutputChars ?? MAX_OUTPUT_CHARS;
+            return { ok: true, stdout: stdout.length > cap ? stdout.slice(0, cap) : stdout };
+        }
+        catch (e) {
+            const err = e;
+            return {
+                ok: false,
+                code: err.killed ? "GIT_TIMEOUT" : "GIT_FAILED",
+                message: err.killed
+                    ? `git ${args[0]} timed out`
+                    : err.message ?? String(e),
+                stderr: typeof err.stderr === "string" ? err.stderr.slice(0, 2000) : undefined,
+            };
+        }
+    }
+    /** `git rev-parse --is-inside-work-tree` — cheap repo probe. */
+    async isRepo() {
+        const r = await this.git(["rev-parse", "--is-inside-work-tree"], { timeoutMs: 5_000 });
+        return r.ok && r.stdout.trim() === "true";
+    }
+    async status() {
+        // -uall: expand untracked directories to individual files (VS Code style);
+        // renames surface as R rows (with fromPath) only when git's rename
+        // detection is active, which is the default for status since git 2.9.
+        const porcelain = await this.git([
+            "status", "--porcelain=v1", "-z", "--branch", "-uall",
+        ]);
+        if (!porcelain.ok)
+            return porcelain;
+        const changes = [];
+        // porcelain v1 -z: NUL-separated fields. Header is
+        // "## branch...upstream [ahead N, behind M]"; status rows "XY path";
+        // rename/copy rows "XY newpath" followed by a bare "oldpath" field.
+        const fields = porcelain.stdout.split("\0").filter((s) => s !== "");
+        let branch = "";
+        let upstream;
+        let ahead;
+        let behind;
+        for (const field of fields) {
+            if (field.startsWith("## ")) {
+                const header = field.slice(3);
+                const track = header.split(/\s+/)[0] ?? "";
+                const dot = track.indexOf("...");
+                if (dot >= 0) {
+                    branch = track.slice(0, dot);
+                    upstream = track.slice(dot + 3);
+                }
+                else {
+                    branch = track;
+                }
+                const aheadM = /\[ahead (\d+)/.exec(header);
+                const behindM = /behind (\d+)\]/.exec(header);
+                if (aheadM)
+                    ahead = Number(aheadM[1]);
+                if (behindM)
+                    behind = Number(behindM[1]);
+                continue;
+            }
+            if (field.startsWith("#"))
+                continue;
+            // Bare path field: from-path of the previous rename/copy row.
+            const prev = changes[changes.length - 1];
+            if (prev && prev.xy.match(/[RC]/) && !prev.fromPath && !/^[ MADRCU?!]{1,2} /.test(field)) {
+                prev.fromPath = field;
+                continue;
+            }
+            const xy = field.slice(0, 2);
+            const path = field.slice(3);
+            changes.push({
+                path,
+                xy,
+                staged: xy[0] !== " " && xy[0] !== "?" && xy[0] !== "!",
+                unstaged: xy[1] !== " " && xy[1] !== "?",
+                untracked: xy === "??",
+            });
+        }
+        const head = await this.git(["rev-parse", "--short", "HEAD"], { timeoutMs: 5_000 });
+        return {
+            ok: true,
+            repoRoot: this.repoRoot,
+            branch,
+            head: head.ok ? head.stdout.trim() : "",
+            upstream,
+            ahead,
+            behind,
+            changes,
+            stagedCount: changes.filter((c) => c.staged).length,
+            unstagedCount: changes.filter((c) => c.unstaged).length,
+            untrackedCount: changes.filter((c) => c.untracked).length,
+        };
+    }
+    /** Unified diff for one path (or whole tree when path omitted). */
+    async diff(options) {
+        const args = ["diff"];
+        if (options.staged)
+            args.push("--cached");
+        args.push(`-U${options.contextLines ?? 3}`);
+        if (options.path) {
+            args.push("--", options.path);
+        }
+        else {
+            args.push("--stat");
+        }
+        const r = await this.git(args);
+        if (!r.ok)
+            return r;
+        return { ok: true, diff: r.stdout };
+    }
+    /** Stage paths (`git add --` / `git add -A --` for "."). */
+    async stage(paths, all = false) {
+        if (!all && paths.length === 0) {
+            return { ok: false, code: "NO_PATHS", message: "stage requires paths or all=true" };
+        }
+        const args = ["add"];
+        if (all) {
+            args.push("-A");
+        }
+        else {
+            args.push("--");
+            args.push(...paths);
+        }
+        return this.git(args);
+    }
+    /** Unstage paths (`git reset HEAD --`). */
+    async unstage(paths) {
+        if (paths.length === 0) {
+            return { ok: false, code: "NO_PATHS", message: "unstage requires paths" };
+        }
+        return this.git(["reset", "HEAD", "--", ...paths]);
+    }
+    /** Discard worktree changes for paths (`git checkout --`). DANGEROUS. */
+    async discard(paths) {
+        if (paths.length === 0) {
+            return { ok: false, code: "NO_PATHS", message: "discard requires paths" };
+        }
+        return this.git(["checkout", "--", ...paths]);
+    }
+    async commit(message) {
+        const trimmed = message.trim();
+        if (!trimmed) {
+            return { ok: false, code: "EMPTY_MESSAGE", message: "commit message required" };
+        }
+        const r = await this.git(["commit", "-m", trimmed]);
+        if (!r.ok)
+            return r;
+        const sha = await this.git(["rev-parse", "--short", "HEAD"], { timeoutMs: 5_000 });
+        return { ok: true, commit: sha.ok ? sha.stdout.trim() : "" };
+    }
+    async log(limit = 30) {
+        const r = await this.git([
+            "log",
+            `--max-count=${limit}`,
+            "--pretty=format:%H\u0001%h\u0001%s\u0001%an\u0001%aI\u0001%D",
+        ]);
+        if (!r.ok)
+            return r;
+        const commits = [];
+        for (const line of r.stdout.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [sha, short, subject, author, date, refs] = line.split("\u0001");
+            if (!sha)
+                continue;
+            commits.push({
+                sha: short ?? sha,
+                subject: subject ?? "",
+                author: author ?? "",
+                date: date ?? "",
+                refs: refs?.trim() || undefined,
+            });
+        }
+        return { ok: true, commits };
+    }
+    async branchList() {
+        const r = await this.git(["branch", "--list", "--format=%(HEAD)%02%(refname:short)"]);
+        if (!r.ok)
+            return r;
+        const branches = [];
+        for (const line of r.stdout.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [headMark, name] = line.split("\x02");
+            if (!name)
+                continue;
+            branches.push({ name: name.trim(), current: headMark?.trim() === "*" });
+        }
+        const current = branches.find((b) => b.current)?.name ?? "";
+        return { ok: true, current, branches };
+    }
+    async branchCreate(name) {
+        if (!/^[\w.\-/]+$/.test(name)) {
+            return { ok: false, code: "INVALID_NAME", message: `invalid branch name: ${name}` };
+        }
+        return this.git(["checkout", "-b", name]);
+    }
+    async branchSwitch(name) {
+        if (!/^[\w.\-/]+$/.test(name)) {
+            return { ok: false, code: "INVALID_NAME", message: `invalid branch name: ${name}` };
+        }
+        return this.git(["checkout", name]);
+    }
+    async push() {
+        const r = await this.git(["push"], { timeoutMs: 120_000 });
+        return r.ok ? { ok: true, output: r.stdout } : r;
+    }
+    async pull() {
+        const r = await this.git(["pull", "--no-edit"], { timeoutMs: 120_000 });
+        return r.ok ? { ok: true, output: r.stdout } : r;
+    }
+}

package/dist/worker/console/chat/scm-tools.js

@@ -0,0 +1,111 @@
+/**
+ * Operator Chat — model-facing source control tool (DSH-style SCM).
+ *
+ * Registers `scm` (single tool, multi-action) so the model can inspect and
+ * drive git in the workspace repo: status / diff / stage / unstage / commit /
+ * log / branch / push / pull. Read actions are cheap and safe; write actions
+ * (commit/push) are the model's explicit intent, mirroring DSH's SCM tool.
+ *
+ * All operations go through ScmService (fixed-argv git, no shell, bounded),
+ * scoped to the workspace repoRoot.
+ */
+const TOOL_DESCRIPTION = "Inspect and drive git source control in the workspace repo. " +
+    "Actions: 'status' (branch + working-tree changes), 'diff' (one path or whole tree; staged=1 for the index), " +
+    "'stage'/'unstage' (paths array; all=true stages everything), 'discard' (DESTRUCTIVE: revert worktree changes of paths), " +
+    "'commit' (message required), 'log' (recent commits), 'branch' (list; name+create to create/switch), 'push', 'pull'. " +
+    "Use status/diff before proposing commits; prefer committing focused changesets. push/pull contact the remote — call them only when the user asks.";
+export async function buildScmTools(deps) {
+    const [{ Type }, { defineTool }] = await Promise.all([
+        import("typebox"),
+        import("@earendil-works/pi-coding-agent"),
+    ]);
+    function result(body) {
+        return { content: [{ type: "text", text: JSON.stringify(body) }], details: body };
+    }
+    function errText(e) {
+        return JSON.stringify({ ok: false, code: e.code, message: e.message, ...(e.stderr ? { stderr: e.stderr } : {}) });
+    }
+    const tool = defineTool({
+        name: "scm",
+        label: "SCM",
+        description: TOOL_DESCRIPTION,
+        promptSnippet: "scm: git source control (status/diff/stage/unstage/discard/commit/log/branch/push/pull) for the workspace repo.",
+        parameters: Type.Object({
+            action: Type.Union([
+                Type.Literal("status"),
+                Type.Literal("diff"),
+                Type.Literal("stage"),
+                Type.Literal("unstage"),
+                Type.Literal("discard"),
+                Type.Literal("commit"),
+                Type.Literal("log"),
+                Type.Literal("branch"),
+                Type.Literal("push"),
+                Type.Literal("pull"),
+            ], { description: "Which git operation to run." }),
+            path: Type.Optional(Type.String({ description: "For diff: repo-relative path (default whole tree --stat)." })),
+            staged: Type.Optional(Type.Boolean({ description: "For diff: diff the staging area (index) instead of the worktree." })),
+            paths: Type.Optional(Type.Array(Type.String(), { description: "For stage/unstage/discard: repo-relative paths." })),
+            all: Type.Optional(Type.Boolean({ description: "For stage: stage all changes (git add -A)." })),
+            message: Type.Optional(Type.String({ description: "For commit: commit message (required)." })),
+            limit: Type.Optional(Type.Number({ description: "For log: max commits (default 30)." })),
+            name: Type.Optional(Type.String({ description: "For branch: branch name to create or switch to." })),
+            create: Type.Optional(Type.Boolean({ description: "For branch: create the branch instead of switching." })),
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params) {
+            const paths = Array.isArray(params.paths) ? params.paths.slice(0, 500) : [];
+            switch (params.action) {
+                case "status":
+                    return result(await deps.scm.status());
+                case "diff": {
+                    const r = await deps.scm.diff({
+                        ...(params.path ? { path: params.path } : {}),
+                        ...(params.staged ? { staged: true } : {}),
+                    });
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "stage": {
+                    const r = params.all === true ? await deps.scm.stage([], true) : await deps.scm.stage(paths);
+                    return r.ok ? result({ ok: true, staged: params.all === true ? "all" : paths }) : result({ error: errText(r) });
+                }
+                case "unstage": {
+                    const r = await deps.scm.unstage(paths);
+                    return r.ok ? result({ ok: true, unstaged: paths }) : result({ error: errText(r) });
+                }
+                case "discard": {
+                    const r = await deps.scm.discard(paths);
+                    return r.ok ? result({ ok: true, discarded: paths }) : result({ error: errText(r) });
+                }
+                case "commit": {
+                    const r = await deps.scm.commit(params.message ?? "");
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "log": {
+                    const r = await deps.scm.log(params.limit ?? 30);
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "branch": {
+                    if (params.name) {
+                        const r = params.create === true
+                            ? await deps.scm.branchCreate(params.name)
+                            : await deps.scm.branchSwitch(params.name);
+                        return r.ok ? result({ ok: true, ...(params.create === true ? { created: params.name } : { switched: params.name }) }) : result({ error: errText(r) });
+                    }
+                    const r = await deps.scm.branchList();
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "push": {
+                    const r = await deps.scm.push();
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                case "pull": {
+                    const r = await deps.scm.pull();
+                    return r.ok ? result(r) : result({ error: errText(r) });
+                }
+                default:
+                    return result({ error: `unknown action: ${params.action}` });
+            }
+        },
+    });
+    return [tool];
+}

package/dist/worker/console/chat/session-catalog.js

@@ -36,6 +36,7 @@ export class ChatSessionCatalog {
             deferredTurns: projectDeferredTurnSummaries(record.deferredTurns ?? []),
             isBlank: isBlankChatSession(record),
             ...(workspaceId ? { workspaceId } : {}),
+            sessionMode: record.sessionMode,
         });
     }
     remove(sessionId) {

package/dist/worker/console/chat/session-mode-view.js

@@ -0,0 +1,48 @@
+/**
+ * Browser-safe session-mode types and copy.
+ *
+ * Keep this module free of Node/runtime tool policy so the Console UI
+ * bundle can import it without pulling operator registries.
+ */
+export const CONSOLE_CHAT_SESSION_MODES = ["workflow", "pi"];
+export const DEFAULT_CONSOLE_CHAT_SESSION_MODE = "workflow";
+export const SESSION_MODE_COPY = {
+    workflow: {
+        id: "workflow",
+        label: "工作流",
+        shortLabel: "工作流",
+        description: "规划并推进工作流",
+        createLabel: "新建工作流会话",
+        bannerTitle: "工作流",
+        bannerBody: "用自然语言编排 loop-agent / agent-worker 的全部能力。这是 Operator 面：默认具备完整 Pi 工具与受策略约束的 operator action。软约束：大改与高风险变更优先走受治 DAG。",
+        landingTitle: "开始一段新的对话",
+        landingBody: "用自然语言编排 loop-agent：查询状态、诊断问题、创建与恢复任务。可先点选下方建议，或选择工作流 / Pi 模式新建会话。",
+        emptyTitle: "今天想推进什么？",
+        emptyBody: "会话已就绪。点选建议快速开场，或在下方输入框直接描述目标。业务写入仍经受治理 DAG。",
+    },
+    pi: {
+        id: "pi",
+        label: "Pi",
+        shortLabel: "Pi",
+        description: "保留压缩与 Explore，直接协作编码",
+        createLabel: "新建 Pi 会话",
+        bannerTitle: "Pi",
+        bannerBody: "保留 Console 压缩与 Explore，直接协作编码。不注入工作流业务指令、业务工具或 Goal 驱动。",
+        landingTitle: "开始一段 Pi 协作",
+        landingBody: "Pi 模式保留压缩、Explore、认证与 SDD 接入，取消工作流业务注入。适合有人监督的直接编码与调试。",
+        emptyTitle: "直接协作编码",
+        emptyBody: "会话已就绪。使用 Pi 工具读写仓库；Explore 负责只读深挖。本会话不加载任务 / DAG 工作流工具。",
+    },
+};
+/** Slash actions that only exist in workflow sessions. Browser-safe: pure
+ *  string constants, no runtime/tool policy imports. */
+export const WORKFLOW_EXCLUSIVE_SLASH_ACTIONS = Object.freeze([
+    "focus-panel:task",
+    "focus-panel:contract",
+    "focus-panel:dag",
+    "focus:interview",
+    "goal",
+]);
+export function isWorkflowExclusiveSlashAction(action) {
+    return WORKFLOW_EXCLUSIVE_SLASH_ACTIONS.includes(action);
+}

package/dist/worker/console/chat/session-mode.js

@@ -0,0 +1,218 @@
+/**
+ * Console Chat session modes (workflow | pi).
+ *
+ * sessionMode is a durable session identity, independent of per-turn
+ * operator | requirement-interview and of UI layout mode. Record is the
+ * source of truth; runtime, catalog, list/detail and the browser cache
+ * all project this field.
+ */
+import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS, OPERATOR_CHAT_PI_BUILTIN_TOOLS, authorizeOperatorChatTool, isOperatorChatToolDenied, } from "./tools.js";
+import { OPERATOR_CHAT_AGENT_TOOL_NAME } from "./subagents/types.js";
+import { CONSOLE_CHAT_SESSION_MODES, DEFAULT_CONSOLE_CHAT_SESSION_MODE, } from "./session-mode-view.js";
+export { CONSOLE_CHAT_SESSION_MODES, DEFAULT_CONSOLE_CHAT_SESSION_MODE, SESSION_MODE_COPY, } from "./session-mode-view.js";
+export const SESSION_MODE_INVALID_CODE = "INVALID_SESSION_MODE";
+export const SESSION_MODE_UNKNOWN_CODE = "UNKNOWN_SESSION_MODE";
+export const SESSION_MODE_ACTION_DENIED_CODE = "SESSION_MODE_ACTION_DENIED";
+export const SESSION_MODE_IMMUTABLE_CODE = "SESSION_MODE_IMMUTABLE";
+export class InvalidChatSessionModeError extends Error {
+    value;
+    code = SESSION_MODE_INVALID_CODE;
+    constructor(value) {
+        super(`sessionMode must be "workflow" or "pi"${value === undefined || value === null || value === ""
+            ? ""
+            : `; got ${String(value)}`}`);
+        this.value = value;
+        this.name = "InvalidChatSessionModeError";
+    }
+}
+export class UnknownChatSessionModeError extends Error {
+    value;
+    code = SESSION_MODE_UNKNOWN_CODE;
+    constructor(value) {
+        super(`chat session record has unknown sessionMode ${JSON.stringify(value)}; refusing to run as workflow`);
+        this.value = value;
+        this.name = "UnknownChatSessionModeError";
+    }
+}
+const MODE_SET = new Set(CONSOLE_CHAT_SESSION_MODES);
+function isSessionMode(value) {
+    return typeof value === "string" && MODE_SET.has(value);
+}
+/**
+ * Create-path parser. Missing / null / "" → workflow. Explicit illegal
+ * values fail closed and must not silently degrade.
+ */
+export function parseCreateSessionMode(value) {
+    if (value === undefined || value === null || value === "") {
+        return DEFAULT_CONSOLE_CHAT_SESSION_MODE;
+    }
+    if (isSessionMode(value))
+        return value;
+    throw new InvalidChatSessionModeError(value);
+}
+/**
+ * Restore-path parser. Missing field → workflow (stock-data rule, not a
+ * compatibility shim). Present but unknown → fail closed.
+ */
+export function readStoredSessionMode(value) {
+    if (value === undefined || value === null || value === "") {
+        return DEFAULT_CONSOLE_CHAT_SESSION_MODE;
+    }
+    if (isSessionMode(value))
+        return value;
+    throw new UnknownChatSessionModeError(value);
+}
+export function isWorkflowSessionMode(mode) {
+    return mode === "workflow";
+}
+export function isPiSessionMode(mode) {
+    return mode === "pi";
+}
+/** Shared Console foundations that both modes keep. Not a native-only prompt. */
+export const PI_CHAT_SYSTEM_PROMPT_BASE = [
+    "You are Console Chat in Pi mode: a coding assistant with Pi tools plus Console shared foundations.",
+    "Use read/write/edit/bash/grep/find/ls to inspect and change the workspace. apply_patch, full-tools, shell and coding-chat are denied.",
+    "Agent (Explore) is a built-in read-only subagent for path-uncertain codebase search. Do not use it for a known single-file read. Prefer safe-read/safe-grep for secret-safe probes.",
+    "ask_user_question pauses for a real user answer. todo_write tracks the current work and is restored after compression; it is not a workflow auto-continue signal. The persistent terminal tool is available.",
+    "This session keeps Console compression (L0/L1/L2, sift, strict checkpoint) and existing Aimax / SDD access. Do not create tasks, run DAGs, drive Goals, or start requirement interviews from this session.",
+    "Obey repository AGENTS.md, skills and extensions when they apply. Choosing Pi mode is not extra write authorization and does not bypass Console access control or output scrubbing.",
+].join("\n");
+export const CHAT_SAFE_EXPLORE_TOOL_IDS = Object.freeze([
+    "safe-read",
+    "safe-grep",
+    "git-status",
+    "git-diff",
+]);
+export const PI_CHAT_GENERIC_HELPER_TOOLS = Object.freeze([
+    "ask_user_question",
+    "todo_write",
+]);
+export const PI_CHAT_WORKFLOW_TOOL_IDS = Object.freeze([
+    "get_goal",
+    "create_goal",
+    "update_goal",
+]);
+const CHAT_EXTENSION_DENIED_TOOL_IDS = new Set([
+    "apply_patch",
+    "apply-patch",
+    "full-tools",
+    "full_tools",
+    "coding-chat",
+    "coding_chat",
+    "shell",
+].map((name) => name.toLowerCase()));
+const WORKFLOW_OPERATOR_TOOL_IDS = new Set(OPERATOR_CHAT_ALLOWED_TOOLS.map((name) => name.toLowerCase()));
+const PI_GOAL_TOOL_IDS = new Set(PI_CHAT_WORKFLOW_TOOL_IDS.map((name) => name.toLowerCase()));
+export function workflowActiveToolBaseline() {
+    return [
+        ...OPERATOR_CHAT_ALLOWED_TOOLS,
+        ...OPERATOR_CHAT_PI_BUILTIN_TOOLS,
+        ...CHAT_SAFE_EXPLORE_TOOL_IDS,
+        ...OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS,
+    ];
+}
+export function piActiveToolBaseline() {
+    return [
+        ...OPERATOR_CHAT_PI_BUILTIN_TOOLS,
+        ...CHAT_SAFE_EXPLORE_TOOL_IDS,
+        ...OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS,
+        ...PI_CHAT_GENERIC_HELPER_TOOLS,
+    ];
+}
+export function chatActiveToolBaseline(sessionMode) {
+    return sessionMode === "pi"
+        ? piActiveToolBaseline()
+        : workflowActiveToolBaseline();
+}
+/**
+ * Gate 2 pin: mode baseline plus user/project extension tools. Pi mode must
+ * not re-add operator actions or Goal tools via the extras pass.
+ */
+export function computeChatActiveToolNames(session, sessionMode) {
+    const baseline = chatActiveToolBaseline(sessionMode);
+    if (!session?.getAllTools)
+        return baseline;
+    const baselineLower = new Set(baseline.map((name) => name.toLowerCase()));
+    const extras = [];
+    for (const tool of session.getAllTools()) {
+        const name = tool?.name;
+        if (!name || typeof name !== "string")
+            continue;
+        const lower = name.toLowerCase();
+        if (baselineLower.has(lower))
+            continue;
+        if (CHAT_EXTENSION_DENIED_TOOL_IDS.has(lower))
+            continue;
+        if (sessionMode === "pi" && WORKFLOW_OPERATOR_TOOL_IDS.has(lower))
+            continue;
+        if (sessionMode === "pi" && PI_GOAL_TOOL_IDS.has(lower))
+            continue;
+        extras.push(name);
+    }
+    return extras.length > 0 ? [...baseline, ...extras] : baseline;
+}
+export function authorizeChatSessionTool(toolId, sessionMode) {
+    if (sessionMode === "workflow")
+        return authorizeOperatorChatTool(toolId);
+    const id = toolId.trim();
+    if (!id) {
+        return {
+            ok: false,
+            code: "tool-unknown",
+            toolId: id,
+            message: "empty tool id is not allowed in Pi mode",
+        };
+    }
+    if (isOperatorChatToolDenied(id)) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is denied in Pi mode (no apply_patch/full-tools/shell/coding-chat)`,
+        };
+    }
+    const lower = id.toLowerCase();
+    if (WORKFLOW_OPERATOR_TOOL_IDS.has(lower) || PI_GOAL_TOOL_IDS.has(lower)) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is a workflow action and is not available in Pi mode`,
+        };
+    }
+    const authorized = new Set(piActiveToolBaseline().map((name) => name.toLowerCase()));
+    if (authorized.has(lower))
+        return { ok: true, toolId: id };
+    return {
+        ok: false,
+        code: "tool-unknown",
+        toolId: id,
+        message: `tool "${id}" is not registered for Pi mode`,
+    };
+}
+export function composeChatSystemPromptParts(input) {
+    const base = input.sessionMode === "pi"
+        ? PI_CHAT_SYSTEM_PROMPT_BASE
+        : input.workflowPrompt;
+    const suffix = input.sessionMode === "workflow" ? input.systemPromptSuffix?.trim() : "";
+    return suffix ? [base, suffix] : [base];
+}
+export function composeChatSystemPrompt(input) {
+    return composeChatSystemPromptParts(input).join("\n\n");
+}
+export const PI_TODO_WRITE_DESCRIPTION = "Record and update a structured task list for the current work. Send the ENTIRE list every call — it REPLACES the previous list (no partial updates, no per-item edits). Before starting multi-step work, add one todo per concrete step. Keep at least one todo `in_progress` while work remains. Mark a todo `completed` immediately when it is done (do not batch completions) and resend the full list as progress advances. Skip the list for simple Q&A, read-only lookups, and single-step tasks. Statuses: `pending` / `in_progress` / `completed`.";
+// Slash gating lives in the browser-safe view module (shortcuts.ts is in the
+// UI bundle); re-export here for Node-side consumers.
+export { WORKFLOW_EXCLUSIVE_SLASH_ACTIONS, isWorkflowExclusiveSlashAction, } from "./session-mode-view.js";
+export function shouldLoadWorkflowBusinessTools(sessionMode) {
+    return sessionMode === "workflow";
+}
+export function shouldInjectGoalContinuation(sessionMode) {
+    return sessionMode === "workflow";
+}
+export function shouldAcceptOperatorSnapshot(sessionMode) {
+    return sessionMode === "workflow";
+}
+export const SESSION_MODE_ACTION_DENIED_MESSAGE = "this action is only available in workflow sessions";
+/** Stable tool name used by tests and catalogs for the Explore subagent. */
+export const PI_CHAT_AGENT_TOOL_NAME = OPERATOR_CHAT_AGENT_TOOL_NAME;