@tea-agent/loop-agent 0.43.0-next.18 → 0.43.0-next.19

package/dist/task/source-prepare/build-draft.js

@@ -90,6 +90,42 @@ function resolveAllowedRoots(input) {
         return normalized.ok ? normalized.value : raw.trim();
     });
 }
+function resolveInteractionIds(input) {
+    if (input.flags.interactionIds !== undefined) {
+        return input.flags.interactionIds;
+    }
+    if (input.baseDraft?.interactionIds?.length) {
+        return input.baseDraft.interactionIds;
+    }
+    if (input.existing?.interactionIds?.length) {
+        return input.existing.interactionIds;
+    }
+    return undefined;
+}
+function resolveCapabilityBoundary(input) {
+    if (input.flags.capabilityBoundary !== undefined) {
+        return input.flags.capabilityBoundary;
+    }
+    if (input.baseDraft?.capabilityBoundary) {
+        return input.baseDraft.capabilityBoundary;
+    }
+    if (input.existing?.capabilityBoundary) {
+        return input.existing.capabilityBoundary;
+    }
+    return undefined;
+}
+function resolveRequirementOwnership(input) {
+    if (input.flags.requirementOwnership !== undefined) {
+        return input.flags.requirementOwnership;
+    }
+    if (input.baseDraft?.requirementOwnership?.length) {
+        return input.baseDraft.requirementOwnership;
+    }
+    if (input.existing?.requirementOwnership?.length) {
+        return input.existing.requirementOwnership;
+    }
+    return undefined;
+}
 function resolveVerifyCommands(input) {
     if (input.flags.verifyCommands !== undefined) {
         return input.flags.verifyCommands.map((cmd) => ({
@@ -178,6 +214,21 @@ export function buildPrepareDraft(input) {
         baseDraft,
         existing: existingTaskConfig,
     });
+    const interactionIds = resolveInteractionIds({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
+    const capabilityBoundary = resolveCapabilityBoundary({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
+    const requirementOwnership = resolveRequirementOwnership({
+        flags,
+        baseDraft,
+        existing: existingTaskConfig,
+    });
     const pathAssessment = assessPreparePaths({
         allowedPaths,
         forbiddenPaths: finalForbidden,
@@ -215,6 +266,15 @@ export function buildPrepareDraft(input) {
             })),
         },
     };
+    if (requirementOwnership !== undefined) {
+        draft.requirementOwnership = requirementOwnership;
+    }
+    if (capabilityBoundary !== undefined) {
+        draft.capabilityBoundary = capabilityBoundary;
+    }
+    if (interactionIds !== undefined && interactionIds.length > 0) {
+        draft.interactionIds = interactionIds;
+    }
     if (featureId)
         draft.featureId = featureId;
     const backendTest = resolveBackendTest(flags, baseDraft, existingTaskConfig);

package/dist/worker/console/chat/pi-mode-loop-isolation.js

@@ -0,0 +1,155 @@
+/**
+ * Pi-mode loop isolation for loop-agent init projections.
+ *
+ * Pi mode ("自由对话") should not auto-load the governance AGENTS.md managed
+ * block that `loop-agent init` writes into a target project, nor the loop-agent
+ * built-in skills it mirrors into `<cwd>/.agents/skills/`. Manual `/skills:name`
+ * invocation and third-party/custom project skills must stay available; the
+ * Workflow mode is untouched (isolation applied only for `sessionMode ===
+ * "pi"`).
+ *
+ * Everything here is a pure function over discovered resources + persisted
+ * auto-invocation prefs, so it is trivially unit-testable.
+ */
+import path from "node:path";
+import { skillResourceId, } from "./resource-preferences-store.js";
+/** init.ts `MANAGED_BLOCK_START` / `MANAGED_BLOCK_END` (docs/templates/init-managed-agents.md). */
+export const LOOP_AGENTS_MANAGED_BLOCK_START = "<!-- LOOP_AGENT_INIT_START -->";
+export const LOOP_AGENTS_MANAGED_BLOCK_END = "<!-- LOOP_AGENT_INIT_END -->";
+/**
+ * Built-in skill directory names that `loop-agent init` mirrors from the
+ * package's `skills/` into a target project's `.agents/skills/`.
+ *
+ * MUST be kept in sync with the repo-root `skills/` directory; a CI check
+ * asserts they match (see `scripts/check-loop-builtin-skills.sh`).
+ */
+export const LOOP_BUILTIN_SKILL_DIR_NAMES = [
+    "agent-worker",
+    "ai-engineering-context",
+    "analyze-product-dependencies",
+    "analyze-product-requirements",
+    "browser-tools",
+    "code-review-core",
+    "codebase-scout",
+    "fe-test-ui-scout",
+    "frontend-bounded-implement",
+    "frontend-contract",
+    "frontend-design-review",
+    "frontend-plan",
+    "frontend-review",
+    "frontend-scout",
+    "frontend-verification",
+    "grill-me",
+    "grill-with-docs",
+    "improve-codebase-architecture",
+    "init-capability-evolution",
+    "local-jacoco-coverage",
+    "loop-agent",
+    "playwright-cli",
+    "playwright-cli-case-generator",
+    "requesting-code-review",
+    "systematic-debugging",
+    "test-driven-development",
+    "using-git-worktrees",
+    "verification-before-completion",
+    "webapp-testing",
+];
+/* Case-insensitive set for fast membership (paths are compared lower-cased). */
+const LOOP_BUILTIN_SKILL_NAMES_LOWER = new Set(LOOP_BUILTIN_SKILL_DIR_NAMES.map((name) => name.toLowerCase()));
+/** Normalize to forward slashes + lower case for Windows/macOS path compares. */
+function normalizeForCompare(value) {
+    return value.replace(/\\/g, "/").toLowerCase();
+}
+/**
+ * Strip the loop-agent init managed block (inclusive of both markers) from an
+ * AGENTS.md content string.
+ *
+ * Returns the content unchanged when no valid marker pair is present (missing
+ * either marker, or END before START), so user-authored AGENTS.md and non-loop
+ * roots are never touched.
+ */
+export function stripLoopManagedBlock(content) {
+    const start = content.indexOf(LOOP_AGENTS_MANAGED_BLOCK_START);
+    if (start < 0)
+        return content;
+    const end = content.indexOf(LOOP_AGENTS_MANAGED_BLOCK_END, start + LOOP_AGENTS_MANAGED_BLOCK_START.length);
+    if (end < 0)
+        return content;
+    const endPos = end + LOOP_AGENTS_MANAGED_BLOCK_END.length;
+    const before = content.slice(0, start).trimEnd();
+    const after = content.slice(endPos).trimStart();
+    return `${before}${before && after ? "\n\n" : ""}${after}`;
+}
+/**
+ * True when a discovered skill is a loop-agent init projection: its file path
+ * is under `<cwd>/.agents/skills/<builtin-name>/` for a name in the builtin
+ * whitelist. Global user skills (`~/.agents/skills`, `~/.pi/agent/skills`) and
+ * third-party project skills outside the whitelist return false.
+ */
+export function isLoopInitProjectedSkill(skill, cwd) {
+    if (!skill?.filePath)
+        return false;
+    const cwdNorm = normalizeForCompare(path.resolve(cwd));
+    const fileNorm = normalizeForCompare(path.resolve(skill.filePath));
+    const prefix = `${cwdNorm}/.agents/skills/`;
+    if (!fileNorm.startsWith(prefix))
+        return false;
+    const rest = fileNorm.slice(prefix.length);
+    const topSeg = rest.split("/")[0];
+    if (!topSeg)
+        return false;
+    return LOOP_BUILTIN_SKILL_NAMES_LOWER.has(topSeg);
+}
+/**
+ * Pi-mode default isolation over skills: for skills that are loop init
+ * projections, default `disableModelInvocation` to true UNLESS the user has
+ * EXPLICITLY tuned auto-invocation ON for that resource id in the persisted
+ * prefs. Explicitly ON wins over the Pi default; explicit OFF is treated as the
+ * Pi default. Non-loop skills pass through untouched.
+ */
+export function applyPiModeSkillIsolation(skills, prefs, cwd) {
+    return skills.map((skill) => {
+        if (!isLoopInitProjectedSkill(skill, cwd))
+            return skill;
+        const id = skillResourceId(skill);
+        const pref = prefs.skills[id];
+        if (pref?.autoInvocationEnabled === true)
+            return skill;
+        if (skill.disableModelInvocation === true)
+            return skill;
+        return { ...skill, disableModelInvocation: true };
+    });
+}
+/**
+ * Build the pi-mode loop isolation resource-loader option fragments.
+ *
+ * - When `enabled` (session mode pi): returns an `agentsFilesOverride` that
+ *   strips the loop-agent managed AGENTS.md block, and wraps the given
+ *   `skillsOverride` so it ALSO applies Pi-mode default isolation after the
+ *   persisted auto-invocation prefs.
+ * - When disabled (workflow): returns ONLY the provided `skillsOverride`
+ *   unchanged, so workflow session behavior is byte-for-byte identical to today.
+ */
+export function buildPiModeLoopIsolationOptions(options) {
+    if (!options.enabled) {
+        return { skillsOverride: options.skillsOverride };
+    }
+    const { cwd, readPreferences } = options;
+    const agentsFilesOverride = (current) => ({
+        agentsFiles: current.agentsFiles.map((file) => ({
+            ...file,
+            content: stripLoopManagedBlock(file.content),
+        })),
+    });
+    return {
+        agentsFilesOverride,
+        skillsOverride: (current) => {
+            const prefs = readPreferences() ?? { schemaVersion: 1, skills: {} };
+            const withPrefs = options.skillsOverride(current);
+            return {
+                skills: applyPiModeSkillIsolation(withPrefs.skills, prefs, cwd),
+                diagnostics: current.diagnostics,
+            };
+        },
+    };
+}

package/dist/worker/console/chat/pi-runtime/custom-tools/operator-tools.js

@@ -3,6 +3,8 @@
  * Definitions and execute() live here; ConsolePiRuntime owns caching and
  * composition with session-bound tools.
  */
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { scheduledGoalBookingSchema } from "../../scheduled-goal-booking.js";
 import { authorizeChatSessionTool, DEFAULT_CONSOLE_CHAT_SESSION_MODE, } from "../../session-mode.js";
 import { buildModelCallableToolSchemas } from "../../tool-adapter.js";
 /**
@@ -17,7 +19,7 @@ export async function buildCustomOperatorTools(options) {
         import("typebox"),
         import("@earendil-works/pi-coding-agent"),
     ]);
-    const schemas = buildModelCallableToolSchemas();
+    const schemas = buildModelCallableToolSchemas().filter((schema) => schema.toolId !== "prepareScheduledTask");
     const ctx = options.actionContext;
     return schemas.map((schema) => {
         // TypeBox schema is built dynamically; cast through unknown to the builder
@@ -29,22 +31,28 @@ export async function buildCustomOperatorTools(options) {
                 ? { description: param.description }
                 : {};
             let t;
-            switch (param.type) {
-                case "string":
-                    t = Type.String(desc);
-                    break;
-                case "boolean":
-                    t = Type.Boolean(desc);
-                    break;
-                case "number":
-                    t = Type.Number(desc);
-                    break;
-                case "array":
-                    t = Type.Array(Type.String({}), Object.keys(desc).length ? desc : {});
-                    break;
-                default:
-                    t = Type.Object({}, { additionalProperties: true });
+            if (schema.toolId === "prepareScheduledGoal" && param.name === "booking") {
+                // Provider adapters need every nested type (not an opaque object).
+                // Keep the strict service schema as the single input contract.
+                t = zodToJsonSchema(scheduledGoalBookingSchema, { $refStrategy: "none" });
             }
+            else
+                switch (param.type) {
+                    case "string":
+                        t = Type.String(desc);
+                        break;
+                    case "boolean":
+                        t = Type.Boolean(desc);
+                        break;
+                    case "number":
+                        t = Type.Number(desc);
+                        break;
+                    case "array":
+                        t = Type.Array(Type.String({}), Object.keys(desc).length ? desc : {});
+                        break;
+                    default:
+                        t = Type.Object({}, { additionalProperties: true });
+                }
             acc[param.name] = param.required ? t : Type.Optional(t);
             return acc;
         }, {}), { additionalProperties: false });

package/dist/worker/console/chat/pi-runtime/custom-tools/scheduled-goal-tools.js

@@ -0,0 +1,22 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { scheduledTaskRequestSchema } from "../../scheduled-goal-request.js";
+import { buildModelCallableToolSchemas } from "../../tool-adapter.js";
+/** Host-bound identity is not a model parameter and cannot leak across sessions. */
+export async function buildScheduledGoalTools(options) {
+    const { Type } = await import("typebox");
+    const { defineTool } = await import("@earendil-works/pi-coding-agent");
+    const schema = buildModelCallableToolSchemas().find((tool) => tool.action === "prepareScheduledTask");
+    if (!schema)
+        throw new Error("scheduled task capability missing");
+    return [defineTool({
+            name: schema.toolId, label: "准备定时任务", description: schema.description, promptSnippet: schema.description,
+            parameters: Type.Object({ request: zodToJsonSchema(scheduledTaskRequestSchema, { $refStrategy: "none" }) }, { additionalProperties: false }),
+            async execute(callId, params) {
+                const { dispatchChatToolCall } = await import("../../session-store.js");
+                const result = await dispatchChatToolCall({ ...options.actionContext, chatSessionRef: options.sessionId }, schema.toolId, params, callId, "workflow");
+                const value = result.ok ? result.result : { ok: false, error: result.message, code: result.errorCode,
+                    nextAction: "Correct the business request and retry prepareScheduledTask. Do not edit PRD/runtime files, substitute sleep/immediate execution, or claim a booking exists." };
+                return { isError: !result.ok, content: [{ type: "text", text: JSON.stringify(value) }], details: value };
+            },
+        })];
+}

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

@@ -0,0 +1,195 @@
+/** Model exposure only. Capability registry and dispatch remain the authority. */
+import { Type } from "typebox";
+import { buildModelCallableToolSchemas } from "../tool-adapter.js";
+import { computeChatActiveToolNames } from "../session-mode.js";
+import { filterActiveInterviewTools } from "../../interview/tools.js";
+export const TOOL_EXPOSURE_ENTRY = "console-tool-exposure";
+export const TOOL_CATALOG_VERSION = 1;
+export const CORE_WORKFLOW_TOOLS = Object.freeze(`prepareScheduledTask scheduledGoalGet scheduledGoalList newTask importPrd sourceInstructions contractDraftSave contractShow contractValidate contractDiff taskAdvance prepareDagConfirmation prepareDagExecution runDag operationGet operationList operationEventSummary operationWait observeLink dagReport dagDoctor dagRerunPlan dagRerun prepareMutationGate standaloneTaskRerun workerTaskRetry status planList operatorCapabilities`.split(" "));
+const SCHEDULED_BOOKING_READ_TOOLS = new Set(["read", "find", "ls", "grep"]);
+export function isScheduledBookingTurn(text) {
+    return /(?:预约|定时|稍后|分钟后|小时后|schedule(?:d)?|\blater\b)/i.test(text);
+}
+/** Keep booking turns on typed workflow actions and local read-only inspection. */
+export function pinScheduledBookingTurnTools(session) {
+    const allowed = session.getActiveToolNames().filter(name => CORE_WORKFLOW_TOOLS.includes(name) || SCHEDULED_BOOKING_READ_TOOLS.has(name));
+    session.setActiveToolsByName(allowed);
+    return allowed;
+}
+export const WORKFLOW_TOOL_GROUPS = [
+    { id: "scheduling", examples: ["prepareScheduledGoal"], description: "高级预约：已有 DAG/Task 的冻结预约", tools: ["prepareScheduledGoal"] },
+    { id: "diagnostics", examples: ["inspect", "doctor", "dagValidate"], description: "DAG 深度诊断、校验、决策、上下文与初始化检查", tools: ["inspect", "doctor", "statsContext", "spineCheck", "dagRunTask", "dagValidate", "dagPromptOverrideConfig", "dagInterruptEligibility", "dagStatus", "dagDecisionInspect", "dagDecisionValidate"] },
+    { id: "governance", examples: ["planCreate", "docsAudit", "closeoutTask"], description: "计划管理、文档审计、交接覆盖与任务收口", tools: ["planCreate", "planComplete", "planCheck", "docsAudit", "handoffCheck", "handoffCoverage", "coverageReport", "stats", "promoteRun", "closeoutTask", "dagCloseoutDraft"] },
+    { id: "knowledge", examples: ["knowledgeQuery"], description: "查询项目知识", tools: ["knowledgeQuery"] },
+    { id: "worker", examples: ["workerSchedulerStatus", "workerPoolDoctor", "workerReportMorning"], description: "Worker 任务池、功能审查、调度诊断与报表", tools: ["workerPoolDoctor", "workerFeatureReview", "workerFeatureDoctor", "workerTaskValidate", "workerBatchPlanReady", "workerReportMorning", "workerReportMetrics", "workerAdmissionShow", "workerSchedulerList", "workerSchedulerStatus", "workerSchedulerLedger", "workerSchedulerDoctor"] },
+];
+export function configuredToolExposure(value) {
+    if (value === undefined || value === "")
+        return undefined;
+    if (value === "full" || value === "progressive")
+        return value;
+    throw new Error("CONSOLE_CHAT_TOOL_EXPOSURE must be full or progressive");
+}
+/** Fail closed on catalog drift, including duplicate or human-only entries. */
+export function validateWorkflowToolCatalog() {
+    const expected = new Set(buildModelCallableToolSchemas().map(t => t.toolId));
+    const names = [...CORE_WORKFLOW_TOOLS, ...WORKFLOW_TOOL_GROUPS.flatMap(g => [...g.tools])];
+    if (names.length !== new Set(names).size || names.length !== expected.size || names.some(n => !expected.has(n)))
+        throw new Error("WORKFLOW_TOOL_CATALOG_DRIFT");
+}
+export const TOOL_DISCOVERY_DESCRIPTION = "Load a workflow capability missing from the visible tools. Choose target by the user's intent from the capability directory, even when no tool name was mentioned. Pass a group ID or exact tool name; omit target if unsure. After loading, call the matching typed tool in the NEXT model response. Discovery alone does not fulfill the request, execute work or grant approval. Prefer discovery over recreating a workflow with shell or file edits.";
+export class WorkflowToolExposure {
+    override;
+    state;
+    session;
+    interview = false;
+    manager;
+    // Failed persistence must not let the next turn silently undo full fallback.
+    // The active branch must still contain this ancestor; sibling branches do not inherit it.
+    volatileFallback;
+    constructor(manager, override) {
+        this.override = override;
+        this.manager = (manager ?? {});
+        this.state = { version: TOOL_CATALOG_VERSION, mode: override ?? "full", groups: [] };
+        try {
+            this.restore();
+        }
+        catch {
+            this.state = { version: TOOL_CATALOG_VERSION, mode: "full", groups: [], fallbackReason: "TOOL_EXPOSURE_STATE_READ_FAILED" };
+        }
+    }
+    get mode() { return this.state.mode; }
+    get snapshot() { return { ...this.state, groups: [...this.state.groups] }; }
+    restore() {
+        const entries = this.manager.getBranch?.() ?? [];
+        const latest = entries.filter(e => e.type === "custom" && e.customType === TOOL_EXPOSURE_ENTRY).at(-1);
+        if (!latest) {
+            this.state = { version: TOOL_CATALOG_VERSION, mode: this.override ?? "full", groups: [] };
+            return;
+        }
+        const raw = latest.data;
+        if (raw?.version !== TOOL_CATALOG_VERSION || !["full", "progressive"].includes(raw.mode ?? "") || !Array.isArray(raw.groups) || raw.groups.some(id => !WORKFLOW_TOOL_GROUPS.some(g => g.id === id))) {
+            this.state = { version: TOOL_CATALOG_VERSION, mode: "full", groups: [], fallbackReason: "INVALID_SAVED_TOOL_EXPOSURE" };
+            return;
+        }
+        const mode = raw.mode === "full" && raw.fallbackReason ? "full" : (this.override ?? raw.mode);
+        this.state = { version: TOOL_CATALOG_VERSION, mode, groups: [...new Set(raw.groups)], ...(mode === "full" && raw.fallbackReason ? { fallbackReason: raw.fallbackReason } : {}) };
+    }
+    persist() {
+        if (!this.manager.appendCustomEntry || !this.manager.getBranch)
+            throw new Error("TOOL_EXPOSURE_PERSISTENCE_UNAVAILABLE");
+        const previous = this.manager.getBranch().filter(e => e.type === "custom" && e.customType === TOOL_EXPOSURE_ENTRY).at(-1)?.data;
+        if (JSON.stringify(previous) !== JSON.stringify(this.state))
+            this.manager.appendCustomEntry(TOOL_EXPOSURE_ENTRY, this.snapshot);
+    }
+    exposed() {
+        if (this.state.mode === "full")
+            return undefined;
+        return [...CORE_WORKFLOW_TOOLS, ...WORKFLOW_TOOL_GROUPS.filter(g => this.state.groups.includes(g.id)).flatMap(g => [...g.tools])];
+    }
+    apply() {
+        if (!this.session)
+            throw new Error("TOOL_EXPOSURE_SESSION_UNAVAILABLE");
+        const names = computeChatActiveToolNames(this.session, "workflow", this.exposed());
+        const allowed = this.interview ? filterActiveInterviewTools(names).allowed : names;
+        this.session.setActiveToolsByName(allowed);
+        // SDK silently ignores unknown names: verify actual registration, not intent.
+        if (this.session.getAllTools) {
+            const registered = new Set(this.session.getAllTools().map(t => t.name));
+            const actual = new Set(this.session.getActiveToolNames());
+            const required = this.interview ? [] : (this.exposed() ?? CORE_WORKFLOW_TOOLS);
+            if (required.some(name => !registered.has(name) || !actual.has(name)))
+                throw new Error("TOOL_EXPOSURE_REQUIRED_TOOL_MISSING");
+            if (allowed.some(n => registered.has(n) && !actual.has(n)) || [...actual].some(n => !allowed.includes(n)))
+                throw new Error("TOOL_EXPOSURE_ACTIVATION_MISMATCH");
+        }
+    }
+    fallback(reason) {
+        this.state = { version: TOOL_CATALOG_VERSION, mode: "full", groups: [], fallbackReason: reason };
+        this.apply(); // A failure here is fatal; never pretend full mode is active.
+        try {
+            this.persist();
+            this.volatileFallback = undefined;
+        }
+        catch {
+            let anchor;
+            try {
+                anchor = this.manager.getBranch?.().at(-1);
+            }
+            catch { /* Conservatively keep full when branch cannot be read. */ }
+            this.volatileFallback = { anchor, state: this.snapshot };
+        }
+    }
+    pin(session, interview = false) {
+        this.session = session;
+        this.interview = interview;
+        // Reconstruct from the active branch, including after compaction/reopen.
+        try {
+            const pending = this.volatileFallback;
+            const branch = this.manager.getBranch?.() ?? [];
+            if (pending && (!pending.anchor || branch.some(entry => entry === pending.anchor ||
+                (pending.anchor?.id !== undefined && entry.id === pending.anchor.id)))) {
+                this.state = { ...pending.state, groups: [...pending.state.groups] };
+            }
+            else {
+                this.volatileFallback = undefined;
+                this.restore();
+            }
+            validateWorkflowToolCatalog();
+            this.apply();
+            // Full mode also records the session policy when supported.
+            if (this.mode === "progressive" || this.manager.appendCustomEntry) {
+                this.persist();
+                this.volatileFallback = undefined;
+            }
+        }
+        catch {
+            this.fallback(this.state.fallbackReason ?? "TOOL_EXPOSURE_RESTORE_OR_ACTIVATION_FAILED");
+        }
+    }
+    discover(target) {
+        if (this.interview)
+            return { ok: false, code: "TOOL_DISCOVERY_INTERVIEW_DENIED" };
+        const catalog = WORKFLOW_TOOL_GROUPS.map(g => ({ id: g.id, description: g.description, examples: [...g.examples], active: this.mode === "full" || this.state.groups.includes(g.id) }));
+        if (!target)
+            return { ok: true, ...this.snapshot, catalog };
+        if (CORE_WORKFLOW_TOOLS.includes(target)) {
+            if (!this.session?.getActiveToolNames().includes(target))
+                return { ok: false, code: "TOOL_EXPOSURE_REQUIRED_TOOL_MISSING" };
+            return { ok: true, alreadyActive: true, tools: [target] };
+        }
+        const group = WORKFLOW_TOOL_GROUPS.find(g => g.id === target || g.tools.includes(target));
+        if (!group)
+            return { ok: false, code: "TOOL_DISCOVERY_NOT_FOUND", catalog };
+        if (!this.session)
+            return { ok: false, code: "TOOL_EXPOSURE_SESSION_UNAVAILABLE" };
+        const registered = new Set(this.session.getAllTools?.().map(t => t.name) ?? []);
+        if (group.tools.some(n => !registered.has(n))) {
+            this.fallback("TOOL_EXPOSURE_GROUP_UNAVAILABLE");
+            return { ok: false, code: "TOOL_EXPOSURE_GROUP_UNAVAILABLE", ...this.snapshot };
+        }
+        try {
+            this.state = { ...this.state, groups: [...new Set([...this.state.groups, group.id])] };
+            this.apply();
+            this.persist();
+        }
+        catch {
+            this.fallback("TOOL_EXPOSURE_LOAD_FAILED");
+        }
+        return { ok: true, ...this.snapshot, group: group.id, tools: [...group.tools], effective: "next-model-response", guidance: "Use the activated typed tools in your next response. Loading has not executed any business action." };
+    }
+    buildTool(fullTool) {
+        return { name: "operatorCapabilities", label: "发现工作流工具", description: TOOL_DISCOVERY_DESCRIPTION,
+            // One short navigation line; detailed semantics live in schema description.
+            promptSnippet: "工作流能力目录：按用户意图选组；所需能力未显示时先调用 operatorCapabilities(target=组ID)，再调用加载后的业务工具完成请求：" + WORKFLOW_TOOL_GROUPS.map(g => `${g.id}: ${g.description} (${g.examples.join(", ")})`).join("; "),
+            parameters: Type.Object({ target: Type.Optional(Type.String({ maxLength: 80, description: "Group ID or exact tool name; omit to list groups." })) }, { additionalProperties: false }),
+            execute: async (_id, params, signal) => {
+                if (signal?.aborted)
+                    throw new Error("Tool discovery aborted");
+                if (this.mode === "full" && !this.interview && !params.target && fullTool)
+                    return fullTool.execute(_id, {});
+                const result = this.discover(params.target);
+                return { isError: result.ok === false, content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+            } };
+    }
+}