@ashx-j/lunr 0.2.11 → 0.2.13

package/dist/builtin-extensions/pi-subagents/src/slash/slash-commands.js

@@ -4,10 +4,6 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText } from "@ashx-j/lunr";
 import { Key, matchesKey } from "@ashx-j/lunr-tui";
-import { BUILTIN_AGENT_NAMES, discoverAgents, discoverAgentsAll } from "../agents/agents.js";
-import { DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS, applySubagentProfile, checkSubagentProfile, generateProfilesForProvider, listSubagentProfiles, readSubagentProfile, refreshProviderModelCatalog, } from "../profiles/profiles.js";
-import { isDynamicParallelStep, isParallelStep } from "../shared/settings.js";
-import { findModelInfo, toModelInfo } from "../shared/model-info.js";
 import { formatTokens, shortenPath } from "../shared/formatters.js";
 import { listAsyncRuns, formatAsyncRunProgressLabel } from "../runs/background/async-status.js";
 import { scheduledRunStorePath } from "../runs/background/scheduled-runs.js";
@@ -46,6 +42,10 @@ const parseInlineConfig = (raw) => {
             case "model":
                 config.model = val || undefined;
                 break;
+            case "permissions":
+                if (val === "full" || val === "read-only")
+                    config.permissions = val;
+                break;
             case "skill":
             case "skills":
                 config.skill = val === "false" ? false : val.split("+").filter(Boolean);
@@ -91,138 +91,19 @@ const parseAgentToken = (token) => {
 const extractExecutionFlags = (rawArgs) => {
     let args = rawArgs.trim();
     let bg = false;
-    let fork = false;
     while (true) {
         if (args.endsWith(" --bg") || args === "--bg") {
             bg = true;
             args = args === "--bg" ? "" : args.slice(0, -5).trim();
             continue;
         }
-        if (args.endsWith(" --fork") || args === "--fork") {
-            fork = true;
-            args = args === "--fork" ? "" : args.slice(0, -7).trim();
-            continue;
-        }
         break;
     }
-    return { args, bg, fork };
-};
-const makeAgentCompletions = (state, multiAgent) => (prefix) => {
-    if (!state.baseCwd)
-        return null;
-    const agents = discoverAgents(state.baseCwd, "both").agents;
-    if (!multiAgent) {
-        if (prefix.includes(" "))
-            return null;
-        return agents.filter((a) => a.name.startsWith(prefix)).map((a) => ({ value: a.name, label: a.name }));
-    }
-    // Find the start of the current chain step: after the last top-level `->` arrow or `(`,
-    // or after a `|` *inside* a group. A `|` at depth 0 is plain task text (only `(` opens a
-    // group), so it must not restart agent completion — otherwise `scout -- do x | wr` would
-    // wrongly resume suggesting agents past the `--` task. Quotes are tracked so separators
-    // inside a task are ignored.
-    let inSingle = false, inDouble = false, depth = 0, segStart = 0;
-    for (let i = 0; i < prefix.length; i++) {
-        const ch = prefix[i];
-        if (inSingle) {
-            if (ch === "'")
-                inSingle = false;
-            continue;
-        }
-        if (inDouble) {
-            if (ch === '"')
-                inDouble = false;
-            continue;
-        }
-        if (ch === "'") {
-            inSingle = true;
-            continue;
-        }
-        if (ch === '"') {
-            inDouble = true;
-            continue;
-        }
-        if (ch === "(") {
-            if (!prefix.slice(segStart, i).includes(" -- ")) {
-                depth++;
-                segStart = i + 1;
-            }
-        }
-        else if (ch === ")") {
-            if (depth > 0) {
-                depth--;
-                segStart = i + 1;
-            }
-        }
-        else if (ch === "|" && depth > 0)
-            segStart = i + 1;
-        else if (ch === ">" && prefix[i - 1] === "-" && depth === 0)
-            segStart = i + 1;
-    }
-    // Inside an open quote, or once the task has started (`--` / a quote), we are no
-    // longer typing an agent name.
-    if (inSingle || inDouble)
-        return null;
-    const segment = prefix.slice(segStart);
-    if (segment.includes(" -- ") || segment.includes('"') || segment.includes("'"))
-        return null;
-    const lastWord = (segment.match(/(\S*)$/) || ["", ""])[1];
-    let beforeLastWord = prefix.slice(0, prefix.length - lastWord.length);
-    // A bare `->` or `|` just typed (no trailing space) needs a separating space;
-    // `(` glues naturally to the agent name.
-    if (lastWord === "" && /[>|]$/.test(beforeLastWord))
-        beforeLastWord = `${beforeLastWord} `;
-    return agents.filter((a) => a.name.startsWith(lastWord)).map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
-};
-const discoverSavedChains = (cwd) => {
-    const chainsByName = new Map();
-    for (const chain of discoverAgentsAll(cwd).chains) {
-        chainsByName.set(chain.name, chain);
-    }
-    return Array.from(chainsByName.values());
-};
-const makeChainCompletions = (state) => (prefix) => {
-    if (prefix.includes(" ") || !state.baseCwd)
-        return null;
-    return discoverSavedChains(state.baseCwd)
-        .filter((chain) => chain.name.startsWith(prefix))
-        .map((chain) => ({ value: chain.name, label: chain.name }));
-};
-const makeBuiltinAgentNameCompletions = () => (prefix) => {
-    if (prefix.includes(" "))
-        return null;
-    return BUILTIN_AGENT_NAMES
-        .filter((name) => name.startsWith(prefix))
-        .map((name) => ({ value: name, label: name }));
-};
-const makeProviderCompletions = (state) => (prefix) => {
-    if (prefix.includes(" "))
-        return null;
-    const available = state.lastUiContext?.modelRegistry?.getAvailable?.();
-    if (!Array.isArray(available))
-        return null;
-    const providers = [...new Set(available
-            .map((model) => typeof model?.provider === "string" ? model.provider : "")
-            .filter(Boolean))]
-        .sort((a, b) => a.localeCompare(b));
-    return providers
-        .filter((provider) => provider.startsWith(prefix))
-        .map((provider) => ({ value: provider, label: provider }));
+    return { args, bg };
 };
 function sendSlashText(pi, text) {
     pi.sendMessage({ customType: SLASH_TEXT_RESULT_TYPE, content: text, display: true });
 }
-async function withSlashStatus(ctx, text, run) {
-    if (ctx.hasUI)
-        ctx.ui.setStatus("subagent-slash-text", text);
-    try {
-        return await run();
-    }
-    finally {
-        if (ctx.hasUI)
-            ctx.ui.setStatus("subagent-slash-text", undefined);
-    }
-}
 function commandForTarget(target) {
     return target.kind === "scheduled"
         ? `subagent({ action: "schedule-cancel", id: ${JSON.stringify(target.id)} })`
@@ -469,68 +350,6 @@ function buildSubagentCostReport(ctx) {
     lines.push("────────────────────────────", formatCostUsage("Children", childTotal), formatCostUsage("Total", total));
     return lines.join("\n");
 }
-function parseSingleRequiredArg(args, usage) {
-    const parts = args.trim().split(/\s+/).filter(Boolean);
-    if (parts.length !== 1)
-        return { ok: false, message: usage };
-    return { ok: true, value: parts[0] };
-}
-function getProfileWorkerModel(profile) {
-    const model = profile.subagents?.agentOverrides?.worker?.model;
-    return typeof model === "string" && model.trim() ? model.trim() : undefined;
-}
-function loadSavedOutputSchema(chain, stepAgent, outputSchema) {
-    if (outputSchema === undefined)
-        return undefined;
-    if (typeof outputSchema === "string") {
-        const schemaPath = path.isAbsolute(outputSchema)
-            ? outputSchema
-            : path.join(path.dirname(chain.filePath), outputSchema);
-        const parsed = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
-        assertJsonSchemaObject(parsed, `outputSchema for chain '${chain.name}' step '${stepAgent}' (${schemaPath})`);
-        return parsed;
-    }
-    assertJsonSchemaObject(outputSchema, `outputSchema for chain '${chain.name}' step '${stepAgent}'`);
-    return outputSchema;
-}
-const mapSavedChainSteps = (chain, worktree = false) => {
-    return chain.steps.map((step) => {
-        if (isParallelStep(step)) {
-            const parallel = step.parallel.map((task) => {
-                const { outputSchema: rawOutputSchema, ...rest } = task;
-                const outputSchema = loadSavedOutputSchema(chain, task.agent, rawOutputSchema);
-                return { ...rest, ...(outputSchema ? { outputSchema } : {}) };
-            });
-            return { ...step, parallel, ...(worktree ? { worktree: true } : {}) };
-        }
-        if (isDynamicParallelStep(step)) {
-            const { outputSchema: rawOutputSchema, ...parallelRest } = step.parallel;
-            const outputSchema = loadSavedOutputSchema(chain, step.parallel.agent, rawOutputSchema);
-            const collectSchema = loadSavedOutputSchema(chain, `${step.collect.as} collection`, step.collect.outputSchema);
-            return {
-                ...step,
-                parallel: { ...parallelRest, ...(outputSchema ? { outputSchema } : {}) },
-                collect: { ...step.collect, ...(collectSchema ? { outputSchema: collectSchema } : {}) },
-            };
-        }
-        const outputSchema = loadSavedOutputSchema(chain, step.agent, step.outputSchema);
-        return {
-            agent: step.agent,
-            task: step.task || undefined,
-            ...(step.phase ? { phase: step.phase } : {}),
-            ...(step.label ? { label: step.label } : {}),
-            ...(step.as ? { as: step.as } : {}),
-            ...(outputSchema ? { outputSchema } : {}),
-            ...(step.acceptance !== undefined ? { acceptance: step.acceptance } : {}),
-            output: step.output,
-            outputMode: step.outputMode,
-            reads: step.reads,
-            progress: step.progress,
-            skill: step.skill ?? step.skills,
-            model: step.model,
-        };
-    });
-};
 async function requestSlashRun(pi, ctx, requestId, params) {
     return new Promise((resolve, reject) => {
         let done = false;
@@ -955,7 +774,7 @@ export function parseChainExpression(input) {
 }
 const parseAgentArgs = (state, args, command, ctx) => {
     const input = args.trim();
-    const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
+    const usage = `Usage: /${command} description1 "task1" -> description2 "task2"`;
     let steps;
     let sharedTask;
     let perStep = false;
@@ -993,15 +812,8 @@ const parseAgentArgs = (state, args, command, ctx) => {
         ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
         return null;
     }
-    const agents = discoverAgents(state.baseCwd, "both").agents;
-    for (const step of steps) {
-        if (!agents.find((a) => a.name === step.name)) {
-            ctx.ui.notify(`Unknown agent: ${step.name}`, "error");
-            return null;
-        }
-    }
     if (command === "chain" && !steps[0]?.task && (perStep || !sharedTask)) {
-        ctx.ui.notify(`First step must have a task: /chain agent "task" -> agent2`, "error");
+        ctx.ui.notify(`First step must have a task: /chain description "task" -> description2`, "error");
         return null;
     }
     if (command === "parallel" && !steps.some((s) => s.task) && !sharedTask) {
@@ -1041,7 +853,8 @@ const mapParsedTaskToStepObject = (step, fallbackTask, isFirst, opts) => {
     if (config.acceptance !== undefined)
         validateInlineAcceptanceInput(config.acceptance, name);
     return {
-        agent: name,
+        description: name,
+        permissions: config.permissions ?? "full",
         ...(stepTask ? { task: stepTask } : isFirst && fallbackTask ? { task: fallbackTask } : {}),
         ...(config.output !== undefined ? { output: config.output } : {}),
         ...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
@@ -1086,18 +899,10 @@ export function buildChainExpressionSteps(state, input, ctx) {
         notify("Subagent session cwd is not initialized yet");
         return null;
     }
-    const agents = discoverAgents(state.baseCwd, "both").agents;
-    const stepAgentNames = expression.steps.flatMap((step) => step.kind === "group" ? step.tasks.map((t) => t.name) : [step.name]);
-    for (const name of stepAgentNames) {
-        if (!agents.find((a) => a.name === name)) {
-            notify(`Unknown agent: ${name}`);
-            return null;
-        }
-    }
     // Every task inside a parallel group needs its own task; there is no shared-task fallback.
     for (const step of expression.steps) {
         if (step.kind === "group" && step.tasks.some((t) => !t.task)) {
-            notify('Each task in a parallel group needs a task: (agent "a" | agent "b")');
+            notify('Each child in a parallel group needs a task: (description "a" | description2 "b")');
             return null;
         }
     }
@@ -1106,7 +911,7 @@ export function buildChainExpressionSteps(state, input, ctx) {
         ? firstStep.tasks.some((t) => Boolean(t.task))
         : Boolean(firstStep.task);
     if (!firstHasTask) {
-        notify('First step must have a task: /chain agent "task" -> agent2');
+        notify('First step must have a task: /chain description "task" -> description2');
         return null;
     }
     const sharedTask = firstStep.kind === "group"
@@ -1155,32 +960,26 @@ export function registerSlashCommands(pi, state) {
         }
     };
     pi.registerCommand("run", {
-        description: "Run a subagent directly: /run agent[output=file] [task] [--bg]",
-        getArgumentCompletions: makeAgentCompletions(state, false),
+        description: "Run a prompt-defined child: /run description[output=file] task [--bg]",
         handler: async (args, ctx) => {
             const { args: cleanedArgs, bg } = extractExecutionFlags(args);
             const input = cleanedArgs.trim();
             const firstSpace = input.indexOf(" ");
             if (!input) {
-                ctx.ui.notify("Usage: /run <agent> [task] [--bg]", "error");
+                ctx.ui.notify("Usage: /run <description> <task> [--bg]", "error");
                 return;
             }
-            const { name: agentName, config: inline } = parseAgentToken(firstSpace === -1 ? input : input.slice(0, firstSpace));
+            const { name: description, config: inline } = parseAgentToken(firstSpace === -1 ? input : input.slice(0, firstSpace));
             const task = firstSpace === -1 ? "" : input.slice(firstSpace + 1).trim();
-            if (!state.baseCwd) {
-                ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-                return;
-            }
-            const agents = discoverAgents(state.baseCwd, "both").agents;
-            if (!agents.find((a) => a.name === agentName)) {
-                ctx.ui.notify(`Unknown agent: ${agentName}`, "error");
+            if (!description || !task) {
+                ctx.ui.notify("Usage: /run <description> <task> [--bg]", "error");
                 return;
             }
             let finalTask = task;
             if (inline.reads && Array.isArray(inline.reads) && inline.reads.length > 0) {
                 finalTask = `[Read from: ${inline.reads.join(", ")}]\n\n${finalTask}`;
             }
-            const params = { agent: agentName, task: finalTask, clarify: false, agentScope: "both" };
+            const params = { description, permissions: inline.permissions ?? "full", task: finalTask, clarify: false };
             if (inline.output !== undefined)
                 params.output = inline.output;
             if (inline.outputMode !== undefined)
@@ -1195,61 +994,28 @@ export function registerSlashCommands(pi, state) {
         },
     });
     pi.registerCommand("chain", {
-        description: "Run agents in sequence: /chain scout \"task\" -> planner [--bg]",
-        getArgumentCompletions: makeAgentCompletions(state, true),
+        description: "Run prompt-defined children in sequence: /chain inspect \"task\" -> implement [--bg]",
         handler: async (args, ctx) => {
             const { args: cleanedArgs, bg } = extractExecutionFlags(args);
             const built = buildChainExpressionSteps(state, cleanedArgs, ctx);
             if (!built)
                 return;
-            const params = { chain: built.chain, task: built.task, clarify: false, agentScope: "both" };
-            if (bg)
-                params.async = true;
-            await runSlashSubagent(pi, ctx, params);
-        },
-    });
-    pi.registerCommand("run-chain", {
-        description: "Run a saved chain: /run-chain chainName -- task [--bg]",
-        getArgumentCompletions: makeChainCompletions(state),
-        handler: async (args, ctx) => {
-            const { args: cleanedArgs, bg } = extractExecutionFlags(args);
-            const delimiterIndex = cleanedArgs.indexOf(" -- ");
-            const usage = "Usage: /run-chain <chainName> -- <task> [--bg]";
-            if (delimiterIndex === -1) {
-                ctx.ui.notify(usage, "error");
-                return;
-            }
-            const chainName = cleanedArgs.slice(0, delimiterIndex).trim();
-            const task = cleanedArgs.slice(delimiterIndex + 4).trim();
-            if (!chainName || !task) {
-                ctx.ui.notify(usage, "error");
-                return;
-            }
-            if (!state.baseCwd) {
-                ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-                return;
-            }
-            const chain = discoverSavedChains(state.baseCwd).find((candidate) => candidate.name === chainName);
-            if (!chain) {
-                ctx.ui.notify(`Unknown chain: ${chainName}`, "error");
-                return;
-            }
-            const params = { chain: mapSavedChainSteps(chain), task, clarify: false, agentScope: "both" };
+            const params = { chain: built.chain, task: built.task, clarify: false };
             if (bg)
                 params.async = true;
             await runSlashSubagent(pi, ctx, params);
         },
     });
     pi.registerCommand("parallel", {
-        description: "Run agents in parallel: /parallel scout \"task1\" -> reviewer \"task2\" [--bg]",
-        getArgumentCompletions: makeAgentCompletions(state, true),
+        description: "Run prompt-defined children in parallel: /parallel inspect \"task1\" -> review \"task2\" [--bg]",
         handler: async (args, ctx) => {
             const { args: cleanedArgs, bg } = extractExecutionFlags(args);
             const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
             if (!parsed)
                 return;
             const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
-                agent: name,
+                description: name,
+                permissions: config.permissions ?? "full",
                 task: stepTask ?? parsed.task,
                 ...(config.output !== undefined ? { output: config.output } : {}),
                 ...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
@@ -1258,7 +1024,7 @@ export function registerSlashCommands(pi, state) {
                 ...(config.skill !== undefined ? { skill: config.skill } : {}),
                 ...(config.progress !== undefined ? { progress: config.progress } : {}),
             }));
-            const params = { tasks, clarify: false, agentScope: "both" };
+            const params = { tasks, clarify: false };
             if (bg)
                 params.async = true;
             await runSlashSubagent(pi, ctx, params);
@@ -1327,197 +1093,5 @@ export function registerSlashCommands(pi, state) {
         pi,
         run: (params, ctx) => runSlashSubagent(pi, ctx, params),
     });
-    pi.registerCommand("subagents-models", {
-        description: "Show runtime-loaded builtin subagent models",
-        getArgumentCompletions: makeBuiltinAgentNameCompletions(),
-        handler: async (args, ctx) => {
-            const trimmed = args.trim();
-            if (!trimmed) {
-                await runSlashSubagent(pi, ctx, { action: "models" });
-                return;
-            }
-            const parts = trimmed.split(/\s+/).filter(Boolean);
-            if (parts.length !== 1) {
-                ctx.ui.notify("Usage: /subagents-models [builtin-agent-name]", "error");
-                return;
-            }
-            const agent = parts[0];
-            if (!BUILTIN_AGENT_NAMES.includes(agent)) {
-                ctx.ui.notify(`Unknown builtin agent: ${agent}`, "error");
-                return;
-            }
-            await runSlashSubagent(pi, ctx, { action: "models", agent });
-        },
-    });
-    pi.registerCommand("subagents-profiles", {
-        description: "List saved subagent profiles",
-        handler: async (_args, _ctx) => {
-            const profiles = listSubagentProfiles();
-            if (profiles.length === 0) {
-                sendSlashText(pi, "Subagent profiles\n\nNo subagent profiles found in ~/.pi/agent/profiles/pi-subagents/");
-                return;
-            }
-            sendSlashText(pi, `Subagent profiles\n\n${profiles.join("\n")}`);
-        },
-    });
-    pi.registerCommand("subagents-load-profile", {
-        description: "Load a subagent profile into ~/.pi/agent/settings.json",
-        getArgumentCompletions: (prefix) => {
-            if (prefix.includes(" "))
-                return null;
-            return listSubagentProfiles()
-                .filter((name) => name.startsWith(prefix))
-                .map((name) => ({ value: name, label: name }));
-        },
-        handler: async (args, ctx) => {
-            const parsed = parseSingleRequiredArg(args, "Usage: /subagents-load-profile <name>");
-            if (!parsed.ok) {
-                ctx.ui.notify(parsed.message, "error");
-                return;
-            }
-            try {
-                await withSlashStatus(ctx, `Loading profile ${parsed.value}…`, async () => {
-                    const { profile } = readSubagentProfile(parsed.value);
-                    const workerModel = getProfileWorkerModel(profile);
-                    const result = applySubagentProfile(parsed.value);
-                    const lines = [
-                        `Loaded subagent profile: ${parsed.value}`,
-                        `Profile: ${result.filePath}`,
-                        `Updated: ${result.settingsPath}`,
-                    ];
-                    if (workerModel && typeof pi.setModel === "function" && typeof ctx.modelRegistry?.find === "function" && typeof ctx.modelRegistry?.getAvailable === "function") {
-                        const shouldSwitch = await ctx.ui.confirm("", `Profile loaded. Also switch this session to the profile worker model?\n\n${workerModel}`);
-                        if (shouldSwitch) {
-                            const modelInfo = findModelInfo(workerModel, ctx.modelRegistry.getAvailable().map(toModelInfo));
-                            const model = modelInfo ? ctx.modelRegistry.find(modelInfo.provider, modelInfo.id) : undefined;
-                            if (!modelInfo || !model) {
-                                lines.push(`Could not switch current session model: '${workerModel}' is not available in the current model registry.`);
-                            }
-                            else {
-                                const success = await pi.setModel(model);
-                                if (success)
-                                    lines.push(`Current session model switched to: ${modelInfo.fullId}`);
-                                else
-                                    lines.push(`Could not switch current session model to '${workerModel}': no API key or provider access is available.`);
-                            }
-                        }
-                    }
-                    else if (workerModel) {
-                        lines.push(`Profile worker model: ${workerModel}`);
-                    }
-                    sendSlashText(pi, lines.join("\n"));
-                });
-            }
-            catch (error) {
-                ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-            }
-        },
-    });
-    pi.registerCommand("subagents-refresh-provider-models", {
-        description: "Refresh the cached model catalog for one provider",
-        getArgumentCompletions: makeProviderCompletions(state),
-        handler: async (args, ctx) => {
-            const trimmed = args.trim();
-            const force = /(?:^|\s)--force$/.test(trimmed) || /(?:^|\s)force$/.test(trimmed);
-            const withoutForce = trimmed.replace(/(?:^|\s)(?:--force|force)$/, "").trim();
-            const parsed = parseSingleRequiredArg(withoutForce, "Usage: /subagents-refresh-provider-models <provider> [--force]");
-            if (!parsed.ok) {
-                ctx.ui.notify(parsed.message, "error");
-                return;
-            }
-            try {
-                await withSlashStatus(ctx, `Refreshing provider models for ${parsed.value}…`, async () => {
-                    const result = await refreshProviderModelCatalog(pi, ctx, parsed.value, { force, maxAgeDays: DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS });
-                    const lines = [
-                        "Provider model catalog",
-                        `Provider: ${parsed.value}`,
-                        `Status: ${result.reused ? "fresh cache reused" : "refreshed"}`,
-                        `File: ${result.filePath}`,
-                        `Models: ${result.catalog.models.length}`,
-                        `Refreshed at: ${result.catalog.refreshedAt}`,
-                    ];
-                    if (result.heuristicFallbackCount > 0) {
-                        lines.push(`Warning: ${result.heuristicFallbackCount} model${result.heuristicFallbackCount === 1 ? " was" : "s were"} classified with name heuristics fallback.`);
-                    }
-                    sendSlashText(pi, lines.join("\n"));
-                });
-            }
-            catch (error) {
-                ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-            }
-        },
-    });
-    pi.registerCommand("subagents-generate-profiles", {
-        description: "Generate <provider>.quota and <provider>.quality subagent profiles",
-        getArgumentCompletions: makeProviderCompletions(state),
-        handler: async (args, ctx) => {
-            const parsed = parseSingleRequiredArg(args, "Usage: /subagents-generate-profiles <provider>");
-            if (!parsed.ok) {
-                ctx.ui.notify(parsed.message, "error");
-                return;
-            }
-            try {
-                await withSlashStatus(ctx, `Generating profiles for ${parsed.value}…`, async () => {
-                    const result = await generateProfilesForProvider(pi, ctx, parsed.value, { maxAgeDays: DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS });
-                    const lines = [
-                        "Generated subagent profiles",
-                        `Provider: ${parsed.value}`,
-                        `Catalog: ${result.catalogPath}`,
-                        `Quota: ${result.quotaPath}`,
-                        `  cheap=${result.quotaModels.cheap}`,
-                        `  medium=${result.quotaModels.medium}`,
-                        `  strong=${result.quotaModels.strong}`,
-                        `Quality: ${result.qualityPath}`,
-                        `  cheap=${result.qualityModels.cheap}`,
-                        `  medium=${result.qualityModels.medium}`,
-                        `  strong=${result.qualityModels.strong}`,
-                    ];
-                    if (result.selectedHeuristicFallbackCount > 0) {
-                        lines.push(`Warning: generated profiles depend on heuristic-only classification for ${result.selectedHeuristicFallbackCount} selected model${result.selectedHeuristicFallbackCount === 1 ? "" : "s"}.`);
-                    }
-                    else if (result.heuristicFallbackCount > 0) {
-                        lines.push(`Warning: provider catalog still contains ${result.heuristicFallbackCount} heuristic-classified model${result.heuristicFallbackCount === 1 ? "" : "s"}.`);
-                    }
-                    sendSlashText(pi, lines.join("\n"));
-                });
-            }
-            catch (error) {
-                ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-            }
-        },
-    });
-    pi.registerCommand("subagents-check-profile", {
-        description: "Check whether a saved profile still points to usable models",
-        getArgumentCompletions: (prefix) => {
-            if (prefix.includes(" "))
-                return null;
-            return listSubagentProfiles()
-                .filter((name) => name.startsWith(prefix))
-                .map((name) => ({ value: name, label: name }));
-        },
-        handler: async (args, ctx) => {
-            const parsed = parseSingleRequiredArg(args, "Usage: /subagents-check-profile <name>");
-            if (!parsed.ok) {
-                ctx.ui.notify(parsed.message, "error");
-                return;
-            }
-            try {
-                await withSlashStatus(ctx, `Checking profile ${parsed.value}…`, async () => {
-                    const result = await checkSubagentProfile(pi, ctx, parsed.value);
-                    const lines = [
-                        "Subagent profile check",
-                        `Profile: ${result.profileName}`,
-                        `File: ${result.filePath}`,
-                        "",
-                        ...result.results.map((entry) => `${entry.agent} → ${entry.model} — registry ${entry.inRegistry ? "ok" : "missing"}; probe ${entry.probe.status}${entry.probe.message ? ` (${entry.probe.message.split(/\r?\n/, 1)[0]})` : ""}`),
-                    ];
-                    sendSlashText(pi, lines.join("\n"));
-                });
-            }
-            catch (error) {
-                ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-            }
-        },
-    });
 }
 //# sourceMappingURL=slash-commands.js.map