dsh-loop-engine 1.0.0-rc2 → 1.0.0-rc4

package/lib/index.js

@@ -45,10 +45,10 @@ var __callDispose = (stack, error, hasError) => {
 };
 
 // src/index.ts
-import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
 import { mkdir, readFile as readFile4, rename, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { dirname as dirname3, join as join6 } from "node:path";
+import { dirname as dirname4, join as join8 } from "node:path";
 import z5 from "@deepseek-ai/schemastery";
 import { installSettingsSection } from "@deepseek-ai/dsh-settings";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
@@ -3650,7 +3650,8 @@ var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
 // src/settings.ts
 var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi"];
 var LOOP_ENGINE_SETTINGS_SCHEMA = z4.object({
-  engine: z4.union([z4.const("in-process"), z4.const("claude-code"), z4.const("codex"), z4.const("pi")]).default("in-process")
+  engine: z4.union([z4.const("in-process"), z4.const("claude-code"), z4.const("codex"), z4.const("pi")]).default("in-process"),
+  showInComposer: z4.boolean().default(true)
 });
 function loopEngineSettingsNamespace() {
   return settingsNamespace(LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL);
@@ -3710,48 +3711,89 @@ ${block}`;
 }
 
 // src/commands.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+import { createUserMessage as createUserMessage4 } from "@deepseek-ai/dsh-llm";
+var COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
+function forwardClaudeCodeCommand(name2) {
+  return (invocation) => {
+    invocation.agent.followup(createUserMessage4({
+      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
+      source: { kind: "user" }
+    }));
+    return { kind: "success" };
+  };
+}
+function builtin(name2, description) {
+  return { name: name2, description, handler: forwardClaudeCodeCommand(name2) };
+}
 var CLAUDE_CODE_COMMANDS = [
-  {
-    name: "help",
-    description: "Show help about Claude Code commands",
-    handler: async () => ({ kind: "success" })
-  },
-  {
-    name: "compact",
-    description: "Compact the conversation to reduce context usage",
-    handler: async () => ({ kind: "success" })
-  },
-  {
-    name: "clear",
-    description: "Clear the conversation and start fresh",
-    handler: async () => ({ kind: "success" })
-  },
-  {
-    name: "review",
-    description: "Review recent changes (git diff)",
-    handler: async () => ({ kind: "success" })
-  },
-  {
-    name: "explain",
-    description: "Explain the selected code",
-    handler: async () => ({ kind: "success" })
-  },
-  {
-    name: "fix",
-    description: "Fix issues in the code",
-    handler: async () => ({ kind: "success" })
-  },
-  {
-    name: "tests",
-    description: "Add tests for the selected code",
-    handler: async () => ({ kind: "success" })
-  }
+  builtin("help", "Show help about Claude Code commands"),
+  builtin("compact", "Compact the conversation to reduce context usage"),
+  builtin("clear", "Clear the conversation and start fresh"),
+  builtin("review", "Review recent changes (git diff)"),
+  builtin("explain", "Explain the selected code"),
+  builtin("fix", "Fix issues in the code"),
+  builtin("tests", "Add tests for the selected code")
 ];
+function discoverUserSlashCommands() {
+  let entries;
+  try {
+    entries = readdirSync(userCommandsDir(), { encoding: "utf8" });
+  } catch {
+    return [];
+  }
+  const definitions = [];
+  const seen = new Set(CLAUDE_CODE_COMMANDS.map((command) => command.name));
+  for (const entry of entries.sort()) {
+    if (!entry.endsWith(".md")) continue;
+    const name2 = entry.slice(0, -".md".length);
+    if (!COMMAND_NAME.test(name2) || seen.has(name2)) continue;
+    const path = join3(userCommandsDir(), entry);
+    let raw;
+    try {
+      raw = readFileSync2(path, "utf8");
+    } catch {
+      continue;
+    }
+    const description = commandDescription(raw);
+    if (description === void 0) continue;
+    seen.add(name2);
+    definitions.push({ name: name2, description, handler: forwardClaudeCodeCommand(name2) });
+  }
+  return definitions;
+}
+function userCommandsDir() {
+  return join3(homedir(), ".claude", "commands");
+}
+function commandDescription(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  let body = trimmed;
+  if (trimmed.startsWith("---\n")) {
+    const closing = trimmed.indexOf("\n---");
+    if (closing <= 0) return void 0;
+    for (const line of trimmed.slice(4, closing).split("\n")) {
+      const colon = line.indexOf(":");
+      if (colon < 0 || line.slice(0, colon).trim() !== "description") continue;
+      const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+      if (value.length > 0) return value;
+    }
+    body = trimmed.slice(closing + 4);
+  }
+  for (const line of body.split("\n")) {
+    const candidate = line.trim();
+    if (candidate.length === 0 || candidate.startsWith("#")) continue;
+    return candidate.length > 120 ? `${candidate.slice(0, 119)}\u2026` : candidate;
+  }
+  return void 0;
+}
 
 // src/skills.ts
 import { readFile, readdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join as join3, resolve } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join4, resolve } from "node:path";
 var SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var PROVIDER_NAME = "claude-code";
 var CLAUDE_CODE_RANK = 150;
@@ -3861,10 +3903,10 @@ var ClaudeCodeSkillProvider = class {
     const cwd = options.cwd;
     if (cwd !== void 0) {
       const projectRoot = await findProjectRoot(resolve(cwd));
-      await collectSkillsDir(join3(projectRoot, ".claude", "skills"), CLAUDE_CODE_RANK, candidates);
+      await collectSkillsDir(join4(projectRoot, ".claude", "skills"), CLAUDE_CODE_RANK, candidates);
       await collectClaudeMd(projectRoot, candidates);
     }
-    await collectSkillsDir(join3(homedir(), ".claude", "skills"), CLAUDE_CODE_USER_RANK, candidates);
+    await collectSkillsDir(join4(homedir2(), ".claude", "skills"), CLAUDE_CODE_USER_RANK, candidates);
     if (this.control.signal.aborted) return [];
     return candidates;
   }
@@ -3898,11 +3940,11 @@ async function collectSkillsDir(skillsDir, rank, candidates) {
     return;
   }
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    const entryPath = join3(skillsDir, entry.name);
+    const entryPath = join4(skillsDir, entry.name);
     const info = await stat(entryPath).catch(() => void 0);
     if (info === void 0) continue;
     if (info.isDirectory()) {
-      const path = join3(entryPath, "SKILL.md");
+      const path = join4(entryPath, "SKILL.md");
       const skill2 = await tryParseSkill(path);
       if (skill2 === void 0) continue;
       candidates.push(toCandidate(skill2, path, rank, entryPath));
@@ -3915,7 +3957,7 @@ async function collectSkillsDir(skillsDir, rank, candidates) {
   }
 }
 async function collectClaudeMd(projectRoot, candidates) {
-  const claudeMd = join3(projectRoot, "CLAUDE.md");
+  const claudeMd = join4(projectRoot, "CLAUDE.md");
   try {
     const info = await stat(claudeMd);
     if (!info.isFile()) return;
@@ -3952,7 +3994,7 @@ async function findProjectRoot(cwd) {
   let current = cwd;
   while (true) {
     try {
-      await stat(join3(current, ".git"));
+      await stat(join4(current, ".git"));
       return current;
     } catch {
     }
@@ -3963,12 +4005,81 @@ async function findProjectRoot(cwd) {
 }
 
 // src/engine-codex/skills.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join4, resolve as resolve2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join6 } from "node:path";
+
+// src/driver-core/context-files.ts
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { join as join5, resolve as resolve2 } from "node:path";
+async function projectAncestors(cwd) {
+  const root = await findProjectRoot(resolve2(cwd));
+  const dirs = [];
+  let current = resolve2(cwd);
+  while (true) {
+    dirs.push(current);
+    if (current === root) return dirs;
+    current = resolve2(current, "..");
+  }
+}
+async function collectProjectContextFiles(cwd, policy) {
+  const files = [];
+  for (const dir of await projectAncestors(cwd)) {
+    const chosen = await dirContextFile(dir, policy);
+    if (chosen !== void 0) files.push(chosen);
+  }
+  return files;
+}
+async function dirContextFile(dir, policy) {
+  if (policy.override !== void 0) {
+    const override = join5(dir, policy.override);
+    if (await pathExists(override)) return override;
+  }
+  for (const name2 of policy.primary) {
+    const candidate = join5(dir, name2);
+    if (await pathExists(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function pathExists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile2(path, { encoding: "utf8" });
+  } catch {
+    return void 0;
+  }
+}
+async function anySourceNonEmpty(paths) {
+  for (const path of paths) {
+    const raw = await readOptionalFile(path);
+    if (raw !== void 0 && raw.trim().length > 0) return true;
+  }
+  return false;
+}
+async function fileNonEmpty(path) {
+  const raw = await readOptionalFile(path);
+  return raw !== void 0 && raw.trim().length > 0;
+}
+async function readSources(paths) {
+  const parts = [];
+  for (const path of paths) {
+    const raw = await readOptionalFile(path);
+    if (raw !== void 0 && raw.trim().length > 0) parts.push(raw);
+  }
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+
+// src/engine-codex/skills.ts
 var PROVIDER_NAME2 = "codex";
 var CODEX_PROJECT_RANK = 140;
 var CODEX_USER_RANK = 160;
+var CODEX_CONTEXT_POLICY = { primary: ["AGENTS.md"] };
 var CodexSkillProvider = class {
   constructor(control) {
     this.control = control;
@@ -3979,60 +4090,65 @@ var CodexSkillProvider = class {
     const candidates = [];
     const cwd = options.cwd;
     if (cwd !== void 0) {
-      const projectRoot = await findProjectRoot(resolve2(cwd));
-      await this.collectAgentsMd(join4(projectRoot, "AGENTS.md"), CODEX_PROJECT_RANK, candidates);
+      const paths = await collectProjectContextFiles(cwd, CODEX_CONTEXT_POLICY);
+      if (await anySourceNonEmpty(paths)) candidates.push(this.agentsCandidate(paths, CODEX_PROJECT_RANK));
     }
-    await this.collectAgentsMd(join4(homedir2(), ".codex", "AGENTS.md"), CODEX_USER_RANK, candidates);
+    const userPath = join6(homedir3(), ".codex", "AGENTS.md");
+    if (await fileNonEmpty(userPath)) candidates.push(this.agentsCandidate([userPath], CODEX_USER_RANK));
     if (this.control.signal.aborted) return [];
     return candidates;
   }
   async get(candidate, _options) {
     const locator = candidate.locator;
-    try {
-      const content = await readFile2(locator.path, { encoding: "utf8" });
-      return {
-        name: candidate.name,
-        description: candidate.description,
-        invocation: candidate.invocation,
-        source: candidate.source,
-        provider: this.name,
-        content,
-        path: locator.path,
-        /* v8 ignore next -- every candidate from collectAgentsMd carries a resourceBase */
-        ...candidate.resourceBase !== void 0 ? { resourceBase: candidate.resourceBase } : {}
-      };
-    } catch {
-      return void 0;
-    }
+    const content = await readSources(locator.paths);
+    if (content === void 0) return void 0;
+    const first = locator.paths[0];
+    return {
+      name: candidate.name,
+      description: candidate.description,
+      invocation: candidate.invocation,
+      source: candidate.source,
+      provider: this.name,
+      content,
+      path: first,
+      resourceBase: { kind: "file", path: first }
+    };
   }
-  /** Read one AGENTS.md file and push a candidate when it exists. */
-  async collectAgentsMd(path, rank, candidates) {
-    try {
-      const content = await readFile2(path, { encoding: "utf8" });
-      if (content.trim().length === 0) return;
-      candidates.push({
-        name: "agents-md",
-        description: "Codex project/user instructions (AGENTS.md)",
-        invocation: { modelInvocable: true, userInvocable: true },
-        source: "custom",
-        provider: this.name,
-        rank,
-        locator: { kind: "agents-md", path },
-        path,
-        resourceBase: { kind: "file", path }
-      });
-    } catch {
-    }
+  /** One merged `agents-md` candidate for a ranked file set. */
+  agentsCandidate(paths, rank) {
+    const first = paths[0];
+    return {
+      name: "agents-md",
+      description: "Codex project/user instructions (AGENTS.md)",
+      invocation: { modelInvocable: true, userInvocable: true },
+      source: "custom",
+      provider: this.name,
+      rank,
+      locator: { kind: "agents-md", paths },
+      path: first,
+      resourceBase: { kind: "file", path: first }
+    };
   }
 };
 
 // src/engine-pi/skills.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { join as join5, resolve as resolve3 } from "node:path";
+import { readdir as readdir2, readFile as readFile3, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join7, resolve as resolve3 } from "node:path";
 var PROVIDER_NAME3 = "pi";
-var PI_PROJECT_RANK = 140;
-var PI_USER_RANK = 160;
+var PI_AGENTS_PROJECT_RANK = 140;
+var PI_SKILL_PROJECT_RANK = 150;
+var PI_AGENTS_USER_RANK = 160;
+var PI_SKILL_USER_RANK = 170;
+var PI_CONTEXT_POLICY = {
+  override: "AGENTS.override.md",
+  primary: ["AGENTS.md", "CLAUDE.md"]
+};
+function piAgentDir() {
+  const override = process.env.PI_CODING_AGENT_DIR;
+  if (override !== void 0 && override.length > 0) return resolve3(override);
+  return join7(homedir4(), ".pi", "agent");
+}
 var PiSkillProvider = class {
   constructor(control) {
     this.control = control;
@@ -4043,49 +4159,113 @@ var PiSkillProvider = class {
     const candidates = [];
     const cwd = options.cwd;
     if (cwd !== void 0) {
-      const projectRoot = await findProjectRoot(resolve3(cwd));
-      await this.collectAgentsMd(join5(projectRoot, "AGENTS.md"), PI_PROJECT_RANK, candidates);
+      const projectDirs = await projectAncestors(cwd);
+      const contextPaths = await collectProjectContextFiles(cwd, PI_CONTEXT_POLICY);
+      if (await anySourceNonEmpty(contextPaths)) candidates.push(this.agentsCandidate(contextPaths, PI_AGENTS_PROJECT_RANK));
+      for (const dir of projectDirs) {
+        await this.collectSkillsDir(join7(dir, ".pi", "skills"), PI_SKILL_PROJECT_RANK, candidates);
+      }
     }
-    await this.collectAgentsMd(join5(homedir3(), ".pi", "AGENTS.md"), PI_USER_RANK, candidates);
+    const userAgentDir = piAgentDir();
+    const userContext = join7(userAgentDir, "AGENTS.md");
+    if (await fileNonEmpty(userContext)) candidates.push(this.agentsCandidate([userContext], PI_AGENTS_USER_RANK));
+    await this.collectSkillsDir(join7(userAgentDir, "skills"), PI_SKILL_USER_RANK, candidates);
     if (this.control.signal.aborted) return [];
     return candidates;
   }
   async get(candidate, _options) {
     const locator = candidate.locator;
-    try {
-      const content = await readFile3(locator.path, { encoding: "utf8" });
+    if (locator.kind === "skill-file") {
+      const parsed = await this.tryParse(locator.path);
+      if (parsed === void 0) return void 0;
       return {
-        name: candidate.name,
-        description: candidate.description,
-        invocation: candidate.invocation,
+        name: parsed.name,
+        description: parsed.description,
+        ...parsed.whenToUse === void 0 ? {} : { whenToUse: parsed.whenToUse },
+        invocation: parsed.invocation,
         source: candidate.source,
         provider: this.name,
-        content,
+        content: parsed.content,
         path: locator.path,
-        /* v8 ignore next -- every candidate from collectAgentsMd carries a resourceBase */
-        ...candidate.resourceBase !== void 0 ? { resourceBase: candidate.resourceBase } : {}
+        resourceBase: { kind: "directory", path: dirname3(locator.path) }
       };
+    }
+    const content = await readSources(locator.paths);
+    if (content === void 0) return void 0;
+    const first = locator.paths[0];
+    return {
+      name: candidate.name,
+      description: candidate.description,
+      invocation: candidate.invocation,
+      source: candidate.source,
+      provider: this.name,
+      content,
+      path: first,
+      resourceBase: { kind: "file", path: first }
+    };
+  }
+  /** One merged `agents-md` candidate for a ranked file set. */
+  agentsCandidate(paths, rank) {
+    const first = paths[0];
+    return {
+      name: "agents-md",
+      description: "Pi project/user instructions (AGENTS.md / CLAUDE.md)",
+      invocation: { modelInvocable: true, userInvocable: true },
+      source: "custom",
+      provider: this.name,
+      rank,
+      locator: { kind: "agents-md", paths },
+      path: first,
+      resourceBase: { kind: "file", path: first }
+    };
+  }
+  /** Collect every skill in one skills directory, both pi layouts. */
+  async collectSkillsDir(skillsDir, rank, candidates) {
+    let entries;
+    try {
+      entries = await readdir2(skillsDir, { withFileTypes: true, encoding: "utf8" });
     } catch {
-      return void 0;
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const entryPath = join7(skillsDir, entry.name);
+      const info = await stat3(entryPath).catch(() => void 0);
+      if (info === void 0) continue;
+      if (info.isDirectory()) {
+        const path = join7(entryPath, "SKILL.md");
+        const parsed2 = await this.tryParse(path);
+        if (parsed2 === void 0) continue;
+        candidates.push(this.skillCandidate(parsed2, path, rank, entryPath));
+        continue;
+      }
+      if (!entry.name.endsWith(".md")) continue;
+      const parsed = await this.tryParse(entryPath);
+      if (parsed === void 0) continue;
+      candidates.push(this.skillCandidate(parsed, entryPath, rank, skillsDir));
     }
   }
-  /** Read one AGENTS.md file and push a candidate when it exists. */
-  async collectAgentsMd(path, rank, candidates) {
+  /** One parsed skill as a ranked candidate. */
+  skillCandidate(skill, path, rank, resourceDir) {
+    return {
+      name: skill.name,
+      description: skill.description,
+      ...skill.whenToUse === void 0 ? {} : { whenToUse: skill.whenToUse },
+      invocation: skill.invocation,
+      source: "custom",
+      provider: this.name,
+      rank,
+      locator: { kind: "skill-file", path },
+      path,
+      resourceBase: { kind: "directory", path: resourceDir }
+    };
+  }
+  /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
+  async tryParse(path) {
     try {
-      const content = await readFile3(path, { encoding: "utf8" });
-      if (content.trim().length === 0) return;
-      candidates.push({
-        name: "agents-md",
-        description: "Pi project/user instructions (AGENTS.md)",
-        invocation: { modelInvocable: true, userInvocable: true },
-        source: "custom",
-        provider: this.name,
-        rank,
-        locator: { kind: "agents-md", path },
-        path,
-        resourceBase: { kind: "file", path }
-      });
+      const raw = await readFile3(path, { encoding: "utf8" });
+      return parseSkillFile(raw);
     } catch {
+      return void 0;
     }
   }
 };
@@ -4111,7 +4291,7 @@ var Config4 = z5.object({
 });
 function resolvePatchPath(config) {
   if (config.patchPath !== void 0 && config.patchPath !== "") return config.patchPath;
-  return join6(
+  return join8(
     resolveDshHome(),
     "profiles",
     config.profile ?? "web",
@@ -4130,13 +4310,13 @@ async function readPatchOrUndefined(path) {
   }
 }
 async function writePatchFile(path, text) {
-  await mkdir(dirname3(path), { recursive: true });
+  await mkdir(dirname4(path), { recursive: true });
   const tmp = `${path}.tmp-${randomUUID()}`;
   await writeFile(tmp, text, "utf8");
   await rename(tmp, path);
 }
 function writePatchFileSync(path, text) {
-  mkdirSync(dirname3(path), { recursive: true });
+  mkdirSync(dirname4(path), { recursive: true });
   const tmp = `${path}.tmp-${randomUUID()}`;
   writeFileSync(tmp, text, "utf8");
   renameSync(tmp, path);
@@ -4150,7 +4330,7 @@ async function syncManagedBlock(path, engine) {
 }
 function readPatchFileSync(path) {
   try {
-    return readFileSync2(path, "utf8");
+    return readFileSync3(path, "utf8");
   } catch (error) {
     if (isMissing(error)) return "";
     throw error;
@@ -4231,8 +4411,12 @@ function apply(ctx, config) {
     const commands = ctx.get("commands");
     if (commands !== void 0) {
       const disposers = [];
-      for (const cmd of CLAUDE_CODE_COMMANDS) {
-        disposers.push(commands.register(cmd));
+      for (const command of [...CLAUDE_CODE_COMMANDS, ...discoverUserSlashCommands()]) {
+        try {
+          disposers.push(commands.register(command));
+        } catch (error) {
+          ctx.logger.warn(`loop-engine: skip claude-code command /${command.name}: ${String(error)}`);
+        }
       }
       commandDisposers = disposers;
     }
@@ -4276,7 +4460,7 @@ function apply(ctx, config) {
   mountEngine(fileEngine);
   ctx.effect(() => () => CLEAR_RETRY(), "loop-engine: mount retry cleanup");
   let source;
-  installSettingsSection(ctx, loopEngineSettingsNamespace(), LOOP_ENGINE_SETTINGS_SCHEMA, { engine: fileEngine }, {
+  installSettingsSection(ctx, loopEngineSettingsNamespace(), LOOP_ENGINE_SETTINGS_SCHEMA, { engine: fileEngine, showInComposer: true }, {
     setSource: (current) => {
       source = current;
     },

package/lib/invariant.js

@@ -3,7 +3,8 @@ import z from "@deepseek-ai/schemastery";
 import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi"];
 var LOOP_ENGINE_SETTINGS_SCHEMA = z.object({
-  engine: z.union([z.const("in-process"), z.const("claude-code"), z.const("codex"), z.const("pi")]).default("in-process")
+  engine: z.union([z.const("in-process"), z.const("claude-code"), z.const("codex"), z.const("pi")]).default("in-process"),
+  showInComposer: z.boolean().default(true)
 });
 
 // src/patch-manager.ts

package/lib/types/client/LoopEngineComposerSelect.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Composer loop-engine picker: a compact dropdown registered at the
+ * `conversation.input.right` seat, so it sits immediately left of the model
+ * select in the composer's tool row. The engine is a deployment-level choice,
+ * so this surface shares the same settings-backed {@link LoopEngineStore} as
+ * the settings section and the header badge — a change in any one is what the
+ * others show next. Switching still asks for confirmation first (it interrupts
+ * sessions still running on the previous engine) and reloads the page once the
+ * commit lands, matching the settings section's semantics.
+ *
+ * Styling is token-driven inline styles like the badge and section (the
+ * client-module bundle is esbuild-built without a CSS loader).
+ * @module dsh-loop-engine/client/composer
+ */
+import { type JSX } from 'react';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
+import type { LoopEngineStore, LoopEngineState } from './store.ts';
+import type { en } from './locales.ts';
+/** Injected dependencies of {@link LoopEngineComposerSelect} (slot `inject`). */
+export interface LoopEngineComposerSelectInjected {
+    /** The selection store (loaded on mount, refreshed by scope pushes). */
+    controller: LoopEngineStore;
+    hooks: {
+        /** Engine snapshot bound by the UI renderer as useSnapshot. */
+        snapshot: SnapshotStore<LoopEngineState>;
+    };
+    /** Composer copy bound to the loop engine dictionaries. */
+    t: (key: keyof typeof en) => string;
+}
+/** Props delivered by the slot outlet (the renderer erases the share boundary). */
+export type LoopEngineComposerSelectProps = Partial<InjectFace<LoopEngineComposerSelectInjected>>;
+/**
+ * Render the composer's loop-engine dropdown. Hides until the settings scope
+ * settles, so the composer never flashes a provisional engine.
+ * @param props - composed slot props.
+ * @returns the picker, or null while the engine is unknown.
+ */
+export declare function LoopEngineComposerSelect(props: LoopEngineComposerSelectProps): JSX.Element | null;
+//# sourceMappingURL=LoopEngineComposerSelect.d.ts.map

package/lib/types/client/index.d.ts

@@ -9,6 +9,7 @@ import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
 import { type LoopEngineKey } from './locales.ts';
 export type { LoopEngineSectionInjected, LoopEngineSectionProps } from './LoopEngineSection.tsx';
 export type { LoopEngineBadgeInjected, LoopEngineBadgeProps } from './LoopEngineBadge.tsx';
+export type { LoopEngineComposerSelectInjected, LoopEngineComposerSelectProps } from './LoopEngineComposerSelect.tsx';
 export type { LoopEngineState } from './store.ts';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {

package/lib/types/client/locales.d.ts

@@ -16,6 +16,8 @@ export interface LoopEngineKey {
     engineCodex: string;
     /** Option label: the Pi CLI driver. */
     enginePi: string;
+    /** Settings toggle: show the engine picker in the chat page composer. */
+    showInComposerLabel: string;
     /** Unavailable-state message. */
     unavailable: string;
     /** Notice shown when the selection would interrupt running agents. */