@crouton-kit/crouter 0.3.8 → 0.3.11

package/dist/core/resolver.js

@@ -240,12 +240,62 @@ export function resolveSkill(rawName, opts = {}) {
     const direct = findSkillMatches(skillName, pluginQualifier, effectiveScope, effectivePluginFilter);
     if (direct.length > 0)
         return pickMatch(direct, skillName, pluginQualifier);
+    // Leaf-name fallback: the caller supplied only the final path segment
+    // (e.g. "cli-design" for "ai/interface/cli-design"). A direct path lookup
+    // missed because the skill lives under a nested path. Match by last segment.
+    const byLeaf = findSkillsByLeaf(skillName, pluginQualifier, effectiveScope, effectivePluginFilter);
+    if (byLeaf.length === 1)
+        return byLeaf[0];
+    if (byLeaf.length > 1) {
+        throw ambiguous(formatLeafAmbiguousMessage(skillName, byLeaf), {
+            skill: skillName,
+            candidates: byLeaf.map((m) => ({
+                id: formatSkillId(m),
+                plugin: m.plugin,
+                scope: m.scope,
+                path: m.path,
+            })),
+            next: 'Multiple skills share this leaf name. Re-run with one of the full paths in candidates.',
+        });
+    }
     throw notFound(formatNotFoundMessage(rawName, skillName, pluginQualifier), {
         skill: skillName,
         plugin: pluginQualifier,
         scope: parsed.scope,
     });
 }
+/** Canonical, unambiguous identifier for a skill. Scope-root skills are
+ *  qualified by scope; plugin skills by plugin name. */
+function formatSkillId(s) {
+    return s.plugin === SCOPE_SKILL_PLUGIN ? `${s.scope}/${s.name}` : `${s.plugin}/${s.name}`;
+}
+/** Match skills whose final path segment equals `leaf`. Only meaningful when
+ *  `leaf` is a bare segment (no slash) — a slashed query can never equal a
+ *  single segment, so this returns empty and the caller falls through. */
+function findSkillsByLeaf(leaf, pluginQualifier, scope, pluginFilter) {
+    if (leaf.includes('/'))
+        return [];
+    let all;
+    try {
+        all = scope ? listAllSkills(scope) : listAllSkills();
+    }
+    catch {
+        return [];
+    }
+    return all.filter((s) => {
+        if ((s.name.split('/').pop() ?? s.name) !== leaf)
+            return false;
+        if (pluginQualifier && s.plugin !== pluginQualifier)
+            return false;
+        if (pluginFilter && s.plugin !== pluginFilter)
+            return false;
+        return true;
+    });
+}
+function formatLeafAmbiguousMessage(leaf, matches) {
+    const ids = matches.map(formatSkillId).join(', ');
+    return `ambiguous skill: ${leaf} matches multiple skills: ${ids}`;
+}
 function findSkillMatches(name, pluginQualifier, scope, pluginFilter) {
     const plugins = scope ? listInstalledPlugins(scope) : listAllPlugins();
     const enabledPlugins = plugins.filter((p) => p.enabled);
@@ -332,7 +382,7 @@ function formatNotFoundMessage(rawName, skillName, pluginQualifier) {
         lines.push(`       did you mean: ${formatted.join(', ')}`);
     }
     else {
-        lines.push('       run `crtr skill list` or `crtr skill search <query>` to discover skills');
+        lines.push('       run `crtr skill find list` or `crtr skill find search <query>` to discover skills');
     }
     return lines.join('\n');
 }

package/dist/core/spawn.d.ts

@@ -1,5 +1,5 @@
 export interface SpawnAgentOptions {
-    /** First user message for the new claude session. */
+    /** First user message for the new agent session. */
     prompt: string;
     cwd: string;
     /** crtr job_id injected as CRTR_JOB_ID env var in the pane. */
@@ -10,8 +10,14 @@ export interface SpawnAgentOptions {
     };
     /** Max panes per tmux window before overflowing to a new window. */
     maxPanesPerWindow: number;
-    /** Display name passed to `claude -n`; surfaces in pane title and /resume picker. */
+    /** Display name passed to the agent's `-n` flag; surfaces in pane title and resume picker. */
     name?: string;
+    /** Persona appended via `--append-system-prompt` (subagent body). */
+    systemPrompt?: string;
+    /** Model pattern/id passed via `--model`. */
+    model?: string;
+    /** Tool allow-list passed to pi via `--tools`. */
+    tools?: string[];
 }
 export interface SpawnAgentResult {
     status: 'spawned' | 'spawn-failed' | 'not-in-tmux';
@@ -22,10 +28,11 @@ export interface SpawnAgentResult {
     message: string;
 }
 export interface DetachOptions {
-    /** Inner command to run in the pane. If omitted, build `claude … <prompt>`. */
+    /** Inner command to run in the pane. If omitted, build the detected agent's
+     *  invocation around `<prompt>`. */
     command?: string;
-    /** Full first user message for the new claude session (claude mode only;
-     *  ignored when `command` is set). No custom system prompt. */
+    /** Full first user message for the new agent session (ignored when `command`
+     *  is set). No custom system prompt. */
     prompt?: string;
     cwd: string;
     /** crtr job_id injected as CRTR_JOB_ID env var in the pane and used by the
@@ -42,7 +49,7 @@ export interface DetachOptions {
      *  uses the attached client's currently-focused pane — which drifts if the
      *  user switches windows between kickoff and spawn. */
     targetPane?: string;
-    /** Display name passed to `claude -n`; ignored when `command` is set
+    /** Display name passed to the agent's `-n` flag; ignored when `command` is set
      *  (caller controls the full argv in that mode). */
     name?: string;
 }
@@ -53,18 +60,124 @@ export interface DetachResult {
 }
 export declare function isInTmux(): boolean;
 export declare function shellQuote(s: string): string;
+/** Coding-agent CLIs crtr knows how to spawn as a sibling worker. */
+export type AgentKind = 'claude' | 'pi';
+/**
+ * Detect which coding-agent CLI is hosting the current crtr process so spawns
+ * launch a matching sibling. pi exports `PI_CODING_AGENT=true` into its tool
+ * subprocess environment; Claude Code exports `CLAUDECODE` /
+ * `CLAUDE_CODE_SESSION_ID`. Defaults to claude when no signal is present
+ * (preserves prior behavior).
+ */
+export declare function detectAgentKind(): AgentKind;
+/**
+ * Normalize a `--model` value for the target agent CLI.
+ *
+ * Subagent frontmatter uses Claude Code's bare aliases (`sonnet`, `opus`,
+ * `haiku`, optionally with a `:thinking` suffix). The `claude` CLI resolves
+ * those natively, but `pi` maps a bare alias to its default provider —
+ * `amazon-bedrock` — which most users have not authenticated, so the spawn
+ * dies with "No API key found for amazon-bedrock". These aliases name Anthropic
+ * models, so under pi we pin them to the `anthropic/` provider (preserving any
+ * `:thinking` suffix). Values that already carry a `provider/` prefix or are
+ * concrete model ids are passed through untouched.
+ */
+export declare function normalizeModelForKind(model: string, kind: AgentKind): string;
+export interface AgentCommandOptions {
+    /** First user message delivered to the new agent session. */
+    prompt: string;
+    /** Display name (`-n`); surfaces in the pane title and resume picker. */
+    name?: string;
+    /** Fork an existing session into a fresh one rather than starting clean. */
+    fork?: {
+        sessionId: string;
+    };
+    /** Persona/system prompt appended to the agent's default (`--append-system-prompt`).
+     *  Used to apply a subagent definition's body. */
+    systemPrompt?: string;
+    /** Model pattern/id passed via `--model` (both claude and pi). */
+    model?: string;
+    /** Tool allow-list. Passed to pi via `--tools`; ignored for claude, whose
+     *  tool names and gating flag differ. */
+    tools?: string[];
+}
+/**
+ * Build the agent-CLI invocation (no job wrapper) for the given kind.
+ *
+ *   claude: `claude [-n <name>] [--resume <id> --fork-session] \
+ *            --dangerously-skip-permissions <prompt>`
+ *   pi:     `pi [-n <name>] [--fork <id>] <prompt>`
+ *
+ * pi has no permission popups, so it needs no skip-permissions flag.
+ */
+export declare function buildAgentCommand(opts: AgentCommandOptions, kind?: AgentKind): string;
+export interface AgentPrintArgv {
+    cmd: string;
+    args: string[];
+}
+/**
+ * Argv for a non-interactive print-mode run.
+ *
+ *   claude: `claude [-n <name>] [--resume <id> --fork-session] -p \
+ *            --dangerously-skip-permissions <prompt>`
+ *   pi:     `pi [-n <name>] [--fork <id>] -p <prompt>`
+ *
+ * Returned as a cmd + args array so callers can spawn without a shell.
+ */
+export declare function buildAgentPrintArgv(opts: AgentCommandOptions, kind?: AgentKind): AgentPrintArgv;
+/** Same as buildAgentPrintArgv but rendered as a single shell-quoted string. */
+export declare function buildAgentPrintCommand(opts: AgentCommandOptions, kind?: AgentKind): string;
+export interface HeadlessRunResult {
+    status: 'done' | 'failed';
+    /** Captured stdout on success; stdout+stderr (or an error message) on failure. */
+    output: string;
+    exitCode: number | null;
+}
+/**
+ * Run the agent headlessly and resolve once it exits. A blocking caller awaits
+ * this. stdout is captured as the result; a non-zero exit yields status
+ * 'failed' with the combined output.
+ */
+export declare function runAgentHeadless(opts: {
+    prompt: string;
+    name?: string;
+    cwd: string;
+    systemPrompt?: string;
+    model?: string;
+    tools?: string[];
+}): Promise<HeadlessRunResult>;
+export interface HeadlessDetachResult {
+    status: 'spawned' | 'spawn-failed';
+    pid?: number;
+    message: string;
+}
+/**
+ * Launch a headless agent detached (background). Its print output is captured
+ * and delivered to the job via `crtr job submit`; a non-zero exit marks the job
+ * failed. Returns immediately with the wrapper pid (recorded for crash
+ * detection). No tmux required.
+ */
+export declare function spawnHeadlessDetached(opts: {
+    prompt: string;
+    name?: string;
+    cwd: string;
+    jobId: string;
+    systemPrompt?: string;
+    model?: string;
+    tools?: string[];
+}): HeadlessDetachResult;
 export declare function countPanesInCurrentWindow(): number;
 /**
  * Find a window in the current tmux session with fewer than `maxPanesPerWindow`
- * panes AND where every existing pane has `claude` as a foreground process.
- * Prefers the active window so the spawned pane is visible to the user;
- * otherwise falls back to the first other eligible window. Returns the tmux
- * window id (e.g. `@5`) to pass via `-t`, or null if no window qualifies.
+ * panes AND where every existing pane hosts an agent (claude or pi) as its
+ * foreground process. Prefers the active window so the spawned pane is visible
+ * to the user; otherwise falls back to the first other eligible window. Returns
+ * the tmux window id (e.g. `@5`) to pass via `-t`, or null if no window qualifies.
  *
  * Windows holding non-agent panes (dashboards, log tails, idle shells, editors,
  * REPLs, etc.) are skipped so spawning never disrupts those workflows. A pane
- * qualifies as long as `claude` is among its foreground commands — co-resident
- * helpers like `caffeinate` don't disqualify it.
+ * qualifies as long as an agent comm is among its foreground commands —
+ * co-resident helpers like `caffeinate` don't disqualify it.
  */
 export declare function findWindowWithSpace(maxPanesPerWindow: number): string | null;
 /**
@@ -78,23 +191,27 @@ export declare function findWindowWithSpace(maxPanesPerWindow: number): string |
  */
 export declare function scheduleKillCurrentPane(delaySeconds: number): boolean;
 /**
- * Fire-and-forget: launch an interactive `claude` in a new pane (or window),
+ * Fire-and-forget: launch an interactive agent in a new pane (or window),
  * then schedule the originating pane to be killed after `killAfterSeconds`.
  *
  * No custom system prompt — the task is delivered as the first user message.
- * Returns as soon as the new pane is up; does NOT wait for claude to finish.
+ * Returns as soon as the new pane is up; does NOT wait for the agent to finish.
  */
 export declare function spawnAndDetach(opts: DetachOptions): DetachResult;
+/** Originating pane id + session id of the host (pi/claude) crtr runs under. */
+export declare function originContext(): {
+    pane: string;
+    sessionId: string;
+} | null;
+/** Deterministic subagent session name for an originating pane id (e.g. `%5`). */
+export declare function subagentSessionName(pane: string): string;
 /**
- * Async sibling spawn. Launches a claude session in a tmux pane, progressively
- * filling existing windows up to `maxPanesPerWindow` before creating a new
- * window. Returns immediately with the pane id; the parent stays alive.
- *
- * Placement order:
- *   1. Current window, if it has space.
- *   2. Any other window in the session with space.
- *   3. New window (every existing window at capacity).
+ * Async sibling spawn. Launches an interactive agent (claude or pi, per
+ * detectAgentKind) in the dedicated subagent session, progressively filling
+ * windows up to `maxPanesPerWindow` before creating a new window. Returns
+ * immediately with the pane id; the parent stays alive. Focus is never
+ * switched — the user jumps to the subagent session with Alt-o.
  *
- * If `fork` is set, uses `claude --resume <id> --fork-session`.
+ * If `fork` is set, forks the host session into a fresh one.
  */
 export declare function spawnAgent(opts: SpawnAgentOptions): SpawnAgentResult;