jeo-code 0.5.2 → 0.5.3

package/README.ja.md

@@ -150,11 +150,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.5.3]** (2026-06-15) — `$` chains multiple skills in one line (all run, in order), plus multi-line prompt input — paste-merge and gated Shift+Enter.
 - **[0.5.2]** (2026-06-14) — `$skill` prompt invocation with prefix/fuzzy suggestions, and a per-session input-box hue (amber in cmd-mode).
 - **[0.5.1]** (2026-06-14) — cmd-mode `!<command>` shell escape — run a shell command without engaging the agent.
 - **[0.5.0]** (2026-06-14) — Performance: workspace-scan, workflow-state, and DNA-Claw HUD caches; plus a credential-safety fix that never wipes OAuth over an invalid config.
 - **[0.4.9]** (2026-06-14) — Live-frame width-clamp (content-sized height) replaces the constant-height approach, typed text shows during a running turn, and a docs/AGENTS refresh.
-- **[0.4.8]** (2026-06-14) — Live-frame stability: constant-height live turn, renderer self-heal off-by-one fix, and frame-safe child-stdout sanitizing — no more duplicate model bar or torn escapes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -150,11 +150,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.5.3]** (2026-06-15) — `$` chains multiple skills in one line (all run, in order), plus multi-line prompt input — paste-merge and gated Shift+Enter.
 - **[0.5.2]** (2026-06-14) — `$skill` prompt invocation with prefix/fuzzy suggestions, and a per-session input-box hue (amber in cmd-mode).
 - **[0.5.1]** (2026-06-14) — cmd-mode `!<command>` shell escape — run a shell command without engaging the agent.
 - **[0.5.0]** (2026-06-14) — Performance: workspace-scan, workflow-state, and DNA-Claw HUD caches; plus a credential-safety fix that never wipes OAuth over an invalid config.
 - **[0.4.9]** (2026-06-14) — Live-frame width-clamp (content-sized height) replaces the constant-height approach, typed text shows during a running turn, and a docs/AGENTS refresh.
-- **[0.4.8]** (2026-06-14) — Live-frame stability: constant-height live turn, renderer self-heal off-by-one fix, and frame-safe child-stdout sanitizing — no more duplicate model bar or torn escapes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -150,11 +150,11 @@ Required npm token permissions (repository secret `NPM_TOKEN`):
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.5.3]** (2026-06-15) — `$` chains multiple skills in one line (all run, in order), plus multi-line prompt input — paste-merge and gated Shift+Enter.
 - **[0.5.2]** (2026-06-14) — `$skill` prompt invocation with prefix/fuzzy suggestions, and a per-session input-box hue (amber in cmd-mode).
 - **[0.5.1]** (2026-06-14) — cmd-mode `!<command>` shell escape — run a shell command without engaging the agent.
 - **[0.5.0]** (2026-06-14) — Performance: workspace-scan, workflow-state, and DNA-Claw HUD caches; plus a credential-safety fix that never wipes OAuth over an invalid config.
 - **[0.4.9]** (2026-06-14) — Live-frame width-clamp (content-sized height) replaces the constant-height approach, typed text shows during a running turn, and a docs/AGENTS refresh.
-- **[0.4.8]** (2026-06-14) — Live-frame stability: constant-height live turn, renderer self-heal off-by-one fix, and frame-safe child-stdout sanitizing — no more duplicate model bar or torn escapes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -150,11 +150,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.5.3]** (2026-06-15) — `$` chains multiple skills in one line (all run, in order), plus multi-line prompt input — paste-merge and gated Shift+Enter.
 - **[0.5.2]** (2026-06-14) — `$skill` prompt invocation with prefix/fuzzy suggestions, and a per-session input-box hue (amber in cmd-mode).
 - **[0.5.1]** (2026-06-14) — cmd-mode `!<command>` shell escape — run a shell command without engaging the agent.
 - **[0.5.0]** (2026-06-14) — Performance: workspace-scan, workflow-state, and DNA-Claw HUD caches; plus a credential-safety fix that never wipes OAuth over an invalid config.
 - **[0.4.9]** (2026-06-14) — Live-frame width-clamp (content-sized height) replaces the constant-height approach, typed text shows during a running turn, and a docs/AGENTS refresh.
-- **[0.4.8]** (2026-06-14) — Live-frame stability: constant-height live turn, renderer self-heal off-by-one fix, and frame-safe child-stdout sanitizing — no more duplicate model bar or torn escapes.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/commands/launch.ts

@@ -1,4 +1,6 @@
 import { createInterface } from "node:readline/promises";
+import { emitKeypressEvents } from "node:readline";
+import { PassThrough } from "node:stream";
 import { runAgentLoop, executorSystemPrompt, DEFAULT_TOOLS, TOOL_PROTOCOL, WORKING_DISCIPLINE, type AgentLoopEvents } from "../agent/engine";
 import { initialDynamicStepLimit } from "../agent/step-budget";
 import { memoryPromptSection, spawnDetachedDistill } from "../agent/memory";
@@ -11,7 +13,7 @@ import { runDeepInterviewEngine } from "./deep-interview";
 import { runRalplanEngine } from "./ralplan";
 import { runTeamEngine } from "./team";
 import { runUltragoalEngine } from "./ultragoal";
-import { skillsPromptSection, loadSkills, formatSkill, buildSkillTask, getSkillFrom, skillSlashAliases, workflowSkillsForPrompt, parseSkillInvocation, looksLikeSkillEcho, skillInvocationCard, type SkillDoc } from "../skills/catalog";
+import { skillsPromptSection, loadSkills, formatSkill, buildSkillTask, getSkillFrom, skillSlashAliases, workflowSkillsForPrompt, parseSkillInvocation, parseSkillChain, looksLikeSkillEcho, skillInvocationCard, type SkillDoc, type SkillInvocation } from "../skills/catalog";
 import { formatForgeBox } from "../tui/components/forge";
 import { interactiveOAuthLogin } from "./auth";
 import { logoutOAuth } from "../auth";
@@ -1594,13 +1596,14 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         return;
       }
     }
-    const skillInvocation = parseSkillInvocation(messageContent, resolvedSkills);
-    if (skillInvocation) {
-      const isBundleWorkflow = ["deep-interview", "ralplan", "team", "ultragoal"].includes(skillInvocation.skill.name);
+    // One skill run (bundle workflow → engine; regular skill → agent turn). Shared by the
+    // single-invocation path and the `$a $b …` chain path so every `$` skill actually runs.
+    const runOneSkillShot = async (inv: SkillInvocation): Promise<void> => {
+      const isBundleWorkflow = ["deep-interview", "ralplan", "team", "ultragoal"].includes(inv.skill.name);
       if (isBundleWorkflow) {
         const startMsg: Message = {
           role: "system",
-          content: `[workflow:${skillInvocation.skill.name}:start]${skillInvocation.intent ? ` intent: ${skillInvocation.intent}` : ""}`
+          content: `[workflow:${inv.skill.name}:start]${inv.intent ? ` intent: ${inv.intent}` : ""}`
         };
         history.push(startMsg);
         if (sessionId) {
@@ -1623,18 +1626,18 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               console.log(line);
             }
           },
-          args: skillInvocation.skill.name === "deep-interview" ? (skillInvocation.intent ? skillInvocation.intent.split(/\s+/) : []) : undefined
+          args: inv.skill.name === "deep-interview" ? (inv.intent ? inv.intent.split(/\s+/) : []) : undefined
         };
 
         let ok = false;
         let reason: string | undefined;
         try {
           let res: { ok: boolean; reason?: string };
-          if (skillInvocation.skill.name === "deep-interview") {
+          if (inv.skill.name === "deep-interview") {
             res = await runDeepInterviewEngine(opts);
-          } else if (skillInvocation.skill.name === "ralplan") {
+          } else if (inv.skill.name === "ralplan") {
             res = await runRalplanEngine(opts);
-          } else if (skillInvocation.skill.name === "team") {
+          } else if (inv.skill.name === "team") {
             res = await runTeamEngine(opts);
           } else {
             res = await runUltragoalEngine(opts);
@@ -1650,9 +1653,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
         const endMsg: Message = {
           role: "system",
-          content: ok 
-            ? `[workflow:${skillInvocation.skill.name}:finish]` 
-            : `[workflow:${skillInvocation.skill.name}:abort]${reason ? ` reason: ${reason}` : ""}`
+          content: ok
+            ? `[workflow:${inv.skill.name}:finish]`
+            : `[workflow:${inv.skill.name}:abort]${reason ? ` reason: ${reason}` : ""}`
         };
         if (sessionId) {
           await appendMessage(sessionId, endMsg, cwd);
@@ -1662,12 +1665,32 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
 
       const useOneShotTui = shouldUseOneShotTui(flags.noTui);
       if (!useOneShotTui) {
-        console.log(`▶ Running skill: ${skillInvocation.skill.name}${skillInvocation.intent ? ` — ${skillInvocation.intent}` : ""}`);
+        console.log(`▶ Running skill: ${inv.skill.name}${inv.intent ? ` — ${inv.intent}` : ""}`);
       }
-      const task = buildSkillTask(skillInvocation.skill, skillInvocation.intent, skillInvocation.invokedAs);
+      const task = buildSkillTask(inv.skill, inv.intent, inv.invokedAs);
       const { reply, rendered, usage } = await runTurn(task, useOneShotTui);
       if (!rendered) console.log(stripMarkdown(renderMarkdownTables(reply)) + usage);
       else if (usage) console.log(usage.trim());
+    };
+
+    // `$a $b … [intent]` — run every resolved skill in order; a lone `$skill` is a chain of 1.
+    const skillChain = parseSkillChain(messageContent, resolvedSkills);
+    if (skillChain && skillChain.invocations.length) {
+      if (skillChain.unresolved.length) {
+        console.log(`(skipping unknown skill${skillChain.unresolved.length > 1 ? "s" : ""}: ${skillChain.unresolved.map(u => `$${u}`).join(", ")})`);
+      }
+      if (skillChain.invocations.length > 1) {
+        console.log(`▶ Chaining ${skillChain.invocations.length} skills: ${skillChain.invocations.map(i => `$${i.skill.name}`).join(" → ")}`);
+      }
+      for (const inv of skillChain.invocations) {
+        await runOneSkillShot(inv);
+      }
+      return;
+    }
+    // Slash / file-path / `/skill:` entrypoints (non-`$`) still resolve to a single skill.
+    const skillInvocation = parseSkillInvocation(messageContent, resolvedSkills);
+    if (skillInvocation) {
+      await runOneSkillShot(skillInvocation);
       return;
     }
     try {
@@ -1891,8 +1914,50 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // scrollback before the boxed footer takes over.
   let promptActive = false;
   let pickerActive = false;
+  // ── Multi-line input (JEO_MULTILINE=1, gated) ──────────────────────────────────
+  // Shift+Enter inserts a newline instead of submitting. ghostty (and most terminals)
+  // send Shift+Enter as a distinct escape sequence (\x1b[27;2;13~ legacy, \x1b[13;2u
+  // kitty) that node:readline otherwise mangles into garbage. We route stdin through a
+  // filter that rewrites those sequences to a private-use SENTINEL char BEFORE readline
+  // sees them — readline inserts it as an ordinary character (no submit), and we render
+  // it as a real line break and expand it to "\n" on submit. Default OFF: when disabled
+  // the prompt reads process.stdin directly, exactly as before (zero risk).
+  const SENTINEL = "\uE000";
+  const SHIFT_ENTER_SEQS = ["\u001b[27;2;13~", "\u001b[13;2u"];
+  const multilineInput = jeoEnv("MULTILINE") === "1" && !!process.stdin.isTTY;
+  const expandSentinel = (s: string): string => (multilineInput ? s.split(SENTINEL).join("\n") : s);
+  let keyFilter: PassThrough | undefined;
+  if (multilineInput) {
+    const kf = new PassThrough();
+    (kf as unknown as { isTTY: boolean }).isTTY = true;
+    (kf as unknown as { setRawMode: (m: boolean) => unknown }).setRawMode = (m: boolean) => {
+      try { (process.stdin as { setRawMode?(r: boolean): void }).setRawMode?.(m); } catch { /* terminal gone */ }
+      return kf;
+    };
+    Object.defineProperty(kf, "isRaw", { get: () => (process.stdin as { isRaw?: boolean }).isRaw });
+    // Forward stdin → filter, rewriting Shift+Enter into the newline sentinel BEFORE
+    // readline sees it. Three encodings are handled so it works across setups:
+    //   • a lone "\n" (0x0a) chunk — what ghostty's `keybind = shift+enter=text:\n`
+    //     sends; a normal byte that passes through tmux UNCHANGED (works even with
+    //     tmux extended-keys off). Enter sends "\r" in raw mode, so a lone "\n" is
+    //     unambiguously Shift+Enter. This is the reliable ghostty+tmux path.
+    //   • the xterm legacy "\x1b[27;2;13~" and kitty "\x1b[13;2u" sequences — direct
+    //     terminal (no tmux) or tmux with extended-keys on. (Sent atomically, so a
+    //     per-chunk replace suffices; no partial buffering that could swallow ESC.)
+    process.stdin.on("data", (chunk: Buffer) => {
+      let data = chunk.toString("utf8");
+      if (data === "\n") data = SENTINEL;
+      else for (const seq of SHIFT_ENTER_SEQS) if (data.includes(seq)) data = data.split(seq).join(SENTINEL);
+      kf.write(data);
+    });
+    keyFilter = kf;
+    // readline now decodes keypresses on `keyFilter`; keep process.stdin emitting
+    // 'keypress' too so the footer-redraw / paste-marker / picker listeners (registered
+    // on process.stdin below) still fire.
+    emitKeypressEvents(process.stdin);
+  }
   const rl = createInterface({
-    input: process.stdin,
+    input: keyFilter ?? process.stdin,
     // Single-box input: gate readline's output while the boxed footer is armed so its own
     // `jeo>` prompt/echo is suppressed and ONLY our box shows. (Bun exposes no
     // `_writeToOutput` to patch, so gating the shared output stream is the portable fix.)
@@ -1937,10 +2002,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // outside it keep the existing contracts (typed-line prefill fold on a TTY,
   // in-order auto-serve for piped stdin).
   let promptPasteActive = false;
+  // PASTE-MERGE: a multi-line bracketed paste must arrive as ONE message, not split into
+  // one command per line. Lines that fire WHILE a paste is open are buffered here instead
+  // of run individually; promptInput joins them with the trailing residual on resolve.
+  // `endWaiters` wake that merge the moment the 201~ paste-end marker arrives.
+  const pasteMerge: { buf: string[]; endWaiters: Array<() => void> } = { buf: [], endWaiters: [] };
+  let pasteLineFired = false; // the line that resolved rl.question came from inside a paste
   if (process.stdin.isTTY) {
     process.stdin.on("keypress", (_ch: string, key: { name?: string } | undefined) => {
-      if (key?.name === "paste-start") promptPasteActive = true;
-      else if (key?.name === "paste-end") promptPasteActive = false;
+      if (key?.name === "paste-start") { promptPasteActive = true; pasteMerge.buf = []; }
+      else if (key?.name === "paste-end") {
+        promptPasteActive = false;
+        for (const w of pasteMerge.endWaiters.splice(0)) w();
+      }
     });
     // Enable bracketed paste for the REPL lifetime (restored on exit below):
     // terminals only wrap pastes in the 200~/201~ markers once the app opts in.
@@ -1949,7 +2023,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   }
   rl.on("line", l => {
     if (promptPasteActive) {
-      queuedPromptInput.pastedLines.push(l);
+      // Inside a bracketed paste: buffer the line, never run it on its own.
+      pasteMerge.buf.push(l);
+      pasteLineFired = true;
       return;
     }
     if (!interactiveTurnActive) pendingStdinLines.push(l);
@@ -1989,8 +2065,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       return "/exit";
     }
     promptActive = true;
+    pasteLineFired = false;
     try {
-      return await Promise.race([
+      const value = await Promise.race([
         rl.question(prompt),
         new Promise<string>(resolve => {
           notifyStdinClosed = () => {
@@ -1999,6 +2076,29 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           };
         }),
       ]);
+      // PASTE-MERGE: if the resolving line came from inside a bracketed paste, the rest of
+      // the paste (buffered in pasteMerge.buf) plus the trailing residual still in the line
+      // buffer belong to the SAME message. Wait for paste-end, then join them with newlines
+      // and return ONE multi-line input instead of running line 1 and queuing the rest.
+      if (pasteLineFired) {
+        if (promptPasteActive) {
+          await new Promise<void>(resolve => {
+            if (!promptPasteActive) { resolve(); return; }
+            pasteMerge.endWaiters.push(resolve);
+            setTimeout(resolve, 250); // safety: never hang if the 201~ marker is dropped
+          });
+        }
+        const residual = (rl as unknown as { line?: string }).line ?? "";
+        // Clear the residual so it does NOT prefill (and re-submit) the next prompt.
+        try { rl.write(null, { ctrl: true, name: "u" }); } catch { /* best-effort */ }
+        try { (rl as unknown as { line: string; cursor: number }).line = ""; (rl as unknown as { cursor: number }).cursor = 0; } catch { /* best-effort */ }
+        const parts = [...pasteMerge.buf];
+        if (residual !== "") parts.push(residual);
+        pasteMerge.buf = [];
+        pasteLineFired = false;
+        return expandSentinel(parts.join("\n"));
+      }
+      return expandSentinel(value);
     } finally {
       promptActive = false;
       notifyStdinClosed = undefined;
@@ -2204,7 +2304,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const rli = rl as unknown as { line?: string; cursor?: number };
     const caret = rli.line === line && typeof rli.cursor === "number" ? rli.cursor : line.length;
     const { accent: boxAccent, shadow: boxShadow } = boxAccents(line);
-    const frame = renderInputFrame(line, {
+    const frame = renderInputFrame(expandSentinel(line), {
       cols,
       color: true,
       unicode: true,
@@ -4129,6 +4229,25 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
         continue;
       }
+      // `$a $b ... [intent]` — run EVERY resolved skill in the leading run, in order, each
+      // with the shared trailing intent. A lone `$skill` is just a chain of length 1.
+      const dollarChain = input.startsWith("$") ? parseSkillChain(input, resolvedSkills) : null;
+      if (dollarChain && dollarChain.invocations.length) {
+        if (dollarChain.unresolved.length) {
+          console.log(`(skipping unknown skill${dollarChain.unresolved.length > 1 ? "s" : ""}: ${dollarChain.unresolved.map(u => `$${u}`).join(", ")})`);
+        }
+        if (dollarChain.invocations.length > 1) {
+          console.log(`▶ Chaining ${dollarChain.invocations.length} skills: ${dollarChain.invocations.map(i => `$${i.skill.name}`).join(" → ")}`);
+        }
+        for (const inv of dollarChain.invocations) {
+          try {
+            await runSkillInvocation(inv.skill, inv.intent, inv.invokedAs);
+          } catch (err) {
+            console.log(`! ${(err as Error).message}`);
+          }
+        }
+        continue;
+      }
       const aliasInvocation = parseSkillInvocation(input, resolvedSkills);
       if (aliasInvocation?.invokedAs) {
         try {
@@ -4139,11 +4258,19 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         continue;
       }
       // Unresolved `$skill` → suggest precisely, never silently send the typo to the model.
-      // `$exact`/`$prefix` already ran above; a leftover `$word` is a missed skill attempt,
-      // EXCEPT `$UPPERCASE` env-var-style tokens (e.g. `$HOME`), which pass through untouched.
+      // `$exact`/`$prefix`/chains already ran above; a leftover `$word` is a missed skill
+      // attempt, EXCEPT `$UPPERCASE` env-var-style tokens (e.g. `$HOME`) which pass through.
       if (input.startsWith("$")) {
-        const token = (input.split(/\s+/, 1)[0] ?? "").slice(1);
-        if (token && !/^[A-Z_][A-Z0-9_]*$/.test(token)) {
+        const unresolved = (dollarChain?.unresolved.length
+          ? dollarChain.unresolved
+          : [(input.split(/\s+/, 1)[0] ?? "").slice(1)]
+        ).filter(t => t && !/^[A-Z_][A-Z0-9_]*$/.test(t));
+        if (unresolved.length > 1) {
+          console.log(`No skills: ${unresolved.map(u => `$${u}`).join(", ")}.  (Type $ to autocomplete.)`);
+          continue;
+        }
+        if (unresolved.length === 1) {
+          const token = unresolved[0]!;
           const lc = token.toLowerCase();
           const prefix = resolvedSkills.filter(s => s.name.toLowerCase().startsWith(lc));
           if (prefix.length) {

package/src/skills/catalog.ts

@@ -556,6 +556,38 @@ export function parseSkillInvocation(input: string, skills: SkillDoc[]): SkillIn
   }
   return skill ? { skill, intent: trimmed.slice(command.length).trim(), invokedAs: command } : null;
 }
+
+/** Parse a LEADING run of `$skill` tokens into an ordered chain that shares the trailing
+ *  text as one intent: `$ralplan $team build auth` → [ralplan, team] each with intent
+ *  "build auth". This is what lets `$` invoke several skills in one line — they all run,
+ *  in order. Scanning stops at the first non-`$` token, OR a `$UPPERCASE` env-var-style
+ *  token (e.g. `$HOME`), which is left in the intent so shell-style references pass through.
+ *  Each `$name` resolves by exact name then unique prefix; names that resolve to nothing go
+ *  into `unresolved` (so the REPL can report every typo, not just the first). Returns null
+ *  only when the input opens with no parseable `$skill` token at all. */
+export function parseSkillChain(
+  input: string,
+  skills: SkillDoc[],
+): { invocations: SkillInvocation[]; unresolved: string[] } | null {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("$")) return null;
+  const tokens = trimmed.split(/\s+/);
+  const invocations: SkillInvocation[] = [];
+  const unresolved: string[] = [];
+  let i = 0;
+  for (; i < tokens.length; i++) {
+    const tok = tokens[i] ?? "";
+    if (!tok.startsWith("$") || tok.length < 2) break;
+    const name = tok.slice(1);
+    if (/^[A-Z_][A-Z0-9_]*$/.test(name)) break; // env-var-style → boundary; keep in intent
+    const skill = getSkillFrom(skills, name) ?? uniquePrefixSkill(skills, name);
+    if (skill) invocations.push({ skill, intent: "", invokedAs: tok });
+    else unresolved.push(name);
+  }
+  if (invocations.length === 0 && unresolved.length === 0) return null;
+  const intent = tokens.slice(i).join(" ").trim();
+  return { invocations: invocations.map(inv => ({ ...inv, intent })), unresolved };
+}
 export function looksLikeSkillEcho(reply: string, skills: SkillDoc[]): boolean {
   if (reply.length < 80) {
     return false;