dsh-loop-engine 1.0.0-rc3 → 1.0.0-rc4

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

@@ -9,12 +9,14 @@ import type { LoopEngineId } from '../settings.ts';
 export interface LoopEngineState {
     status: 'loading' | 'ready' | 'unavailable' | 'saving';
     engine: LoopEngineId;
+    showInComposer: boolean;
     writable: boolean;
     error: string | null;
 }
-/** Narrow a wire section to the stored engine id; an invalid one reads default. */
+/** Narrow a wire section to the stored engine id and display toggle; an invalid one reads default. */
 export declare function decodeLoopEngine(section: unknown): {
     engine: LoopEngineId;
+    showInComposer: boolean;
 } | undefined;
 /** Coordinates the settings-backed loop engine selection. */
 export declare class LoopEngineStore {
@@ -28,6 +30,7 @@ export declare class LoopEngineStore {
      */
     constructor(scope: SettingsScope<{
         engine: LoopEngineId;
+        showInComposer: boolean;
     }>);
     /** Begin following the bound scope and publish its current answer. */
     load(): void;
@@ -38,6 +41,15 @@ export declare class LoopEngineStore {
      * @returns whether the write landed.
      */
     setEngine(engine: LoopEngineId): Promise<boolean>;
+    /**
+     * Persist whether the composer shows the engine picker. Success is judged
+     * against the snapshot the write left behind, so a refused write reports
+     * error after its recovery. Unlike {@link setEngine}, landing does not reload
+     * the page — the toggle only changes composer visibility.
+     * @param show - whether the chat page composer reveals the engine picker.
+     * @returns whether the write landed.
+     */
+    setShowInComposer(show: boolean): Promise<boolean>;
     /** Stop following the scope. */
     dispose(): void;
     private derive;

package/lib/types/commands.d.ts

@@ -1,13 +1,25 @@
 /**
- * Claude Code built-in slash command definitions.
+ * Claude Code slash-command bridge.
  *
- * These commands are registered into the DSH CommandRuntime when the
- * claude-code engine is active.  The handlers are stubs — the real command
- * processing happens inside the Claude Agent SDK — so the UI shows the
- * commands in the slash menu and the handler returns success immediately.
+ * The dsh `commands` runtime executes a registered command locally — the line
+ * is consumed and never reaches the model — so a command whose real processing
+ * lives inside the Claude Code CLI must forward the raw line back to the
+ * engine. The definitions here do exactly that: the handler delivers
+ * `/<name> [args]` to the receiving agent as a plain user message, and the CLI
+ * then expands it natively (built-ins and custom `.claude/commands/*.md`).
+ * Registering the built-ins keeps them visible in the dsh web slash menu;
+ * unregistered `/lines` pass through as user text, but the menu would hide the
+ * engine's command surface.
+ *
+ * User-level custom slash commands (`~/.claude/commands/*.md`) are discovered
+ * and registered the same way, so they appear in the menu AND reach the CLI.
+ * Project-level `.claude/commands/` files are left to the CLI entirely: they
+ * are cwd-dependent, and a global dsh registration would collide across
+ * projects.
  *
  * @module dsh-loop-engine/commands
  */
+import type { UserMessage } from '@deepseek-ai/dsh-session';
 /** Minimal shape of a DSH command definition (avoiding a direct peer dep on @deepseek-ai/dsh-commands). */
 export interface CommandDefinition {
     readonly name: string;
@@ -18,15 +30,40 @@ export interface CommandDefinition {
     };
     readonly handler: (invocation: CommandInvocation) => CommandResult | Promise<CommandResult>;
 }
+/** Invocation delivered to one registered command handler. */
 export interface CommandInvocation {
     readonly commandId: string;
+    /** The receiving agent; forwarding handlers deliver the raw line back to it. */
+    readonly agent: {
+        readonly followup: (input: UserMessage) => void;
+    };
+    /** Exact text following the command name, including separator whitespace. */
     readonly rawInput: string;
     readonly signal: AbortSignal;
 }
+/** Settled result of one command handler. */
 export interface CommandResult {
     readonly kind: 'success' | 'error';
     readonly text?: string;
 }
+/**
+ * Build the forwarding handler for one Claude Code slash command: it
+ * re-delivers the full `/<name> [args]` line to the receiving agent as a
+ * plain user message, where the CLI expands it. `rawInput` already carries the
+ * separator whitespace and any arguments.
+ * @param name - the command name without the leading slash.
+ * @returns the command handler.
+ */
+export declare function forwardClaudeCodeCommand(name: string): (invocation: CommandInvocation) => CommandResult;
 /** Claude Code's built-in slash commands. */
-export declare const CLAUDE_CODE_COMMANDS: CommandDefinition[];
+export declare const CLAUDE_CODE_COMMANDS: readonly CommandDefinition[];
+/**
+ * Discover the user-level custom slash commands from `~/.claude/commands/*.md`
+ * and build forwarding definitions for them. The scan is synchronous so the
+ * mount path can register the commands before the engine-selection commit
+ * returns; files without a usable name or description, and names already taken
+ * by the built-ins, are skipped.
+ * @returns forwarding definitions, sorted by file name.
+ */
+export declare function discoverUserSlashCommands(): CommandDefinition[];
 //# sourceMappingURL=commands.d.ts.map

package/lib/types/driver-core/context-files.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Context-file collection and body loading shared by the hosted engine
+ * drivers.
+ *
+ * Codex and Pi read per-directory instruction files (`AGENTS.md`; pi also
+ * accepts `CLAUDE.md` and prefers `AGENTS.override.md` inside any directory
+ * that has one) while walking from the session cwd up to the git root. The
+ * skill providers surface each collected set as one merged skill candidate so
+ * the dsh skill-injection seam (`/name` gestures) can carry it into the
+ * prompt; the body-loading helpers below feed both providers' list/get paths.
+ *
+ * @module dsh-loop-engine/driver-core/context-files
+ */
+/** Per-directory context-file resolution policy for one engine. */
+export interface ContextFilePolicy {
+    /** Per-directory override file that replaces the primary files when present. */
+    readonly override?: string;
+    /** Per-directory primary files, tried in order until one exists. */
+    readonly primary: readonly string[];
+}
+/**
+ * The directory chain from `cwd` up to the git root, nearest first. Without a
+ * repository the chain is just the resolved `cwd` itself, matching
+ * {@link findProjectRoot}'s fallback so the walk stays bounded.
+ * @param cwd - the session working directory.
+ * @returns the chain of directories to inspect.
+ */
+export declare function projectAncestors(cwd: string): Promise<string[]>;
+/**
+ * Collect every directory's context file per the policy, from the session cwd
+ * up to the git root.
+ * @param cwd - the session working directory.
+ * @param policy - per-directory resolution policy.
+ * @returns existing context files, nearest directory first.
+ */
+export declare function collectProjectContextFiles(cwd: string, policy: ContextFilePolicy): Promise<string[]>;
+/**
+ * Read one file, or `undefined` when it is unreadable.
+ * @param path - the file to read.
+ * @returns the file body, or `undefined` on any failure.
+ */
+export declare function readOptionalFile(path: string): Promise<string | undefined>;
+/**
+ * Whether any of the given sources carries non-whitespace content.
+ * @param paths - candidate file paths.
+ * @returns whether at least one readable source is non-empty.
+ */
+export declare function anySourceNonEmpty(paths: readonly string[]): Promise<boolean>;
+/**
+ * Whether one file exists and carries non-whitespace content.
+ * @param path - the file to inspect.
+ * @returns whether the file is readable and non-empty.
+ */
+export declare function fileNonEmpty(path: string): Promise<boolean>;
+/**
+ * Concatenate every non-empty readable source body in order, or `undefined`
+ * when none are readable.
+ * @param paths - candidate file paths, nearest directory first.
+ * @returns the joined bodies, or `undefined` when nothing could be read.
+ */
+export declare function readSources(paths: readonly string[]): Promise<string | undefined>;
+//# sourceMappingURL=context-files.d.ts.map

package/lib/types/engine-codex/skills.d.ts

@@ -1,17 +1,20 @@
 /**
  * Codex skill provider: exposes the codex CLI's instruction files as DSH
- * skills. Codex has no per-skill catalog like Claude Code's `.claude/skills/`;
- * it reads project and user instruction files named `AGENTS.md`. Each found
- * `AGENTS.md` is surfaced as a single user-invocable skill whose content is
- * the file body, so the dsh skill-injection seam (`/name` gestures) can carry
- * it into the prompt.
+ * skills.
+ *
+ * Codex has no per-skill catalog like the agents-skill standard; its
+ * instructions are `AGENTS.md` files read from the session cwd up to the git
+ * root, plus the global `~/.codex/AGENTS.md`. Each file set is surfaced as one
+ * user-invocable `agents-md` skill whose body is the concatenated file
+ * contents, so the dsh skill-injection seam (`/name` gestures) can carry it
+ * into the prompt.
  *
  * @module dsh-loop-engine/engine-codex/skills
  */
-import { type SkillCandidate, type SkillDefinition, type SkillLookupOptions, type SkillProvider, type SkillProviderControl } from '../skills.ts';
+import type { SkillCandidate, SkillDefinition, SkillLookupOptions, SkillProvider, SkillProviderControl } from '../skills.ts';
 /**
- * Skill provider that discovers `AGENTS.md` from the project root (git root
- * when one exists) and the user home `~/.codex/AGENTS.md`.
+ * Skill provider that discovers `AGENTS.md` from every directory between the
+ * project cwd and the git root, plus the user home `~/.codex/AGENTS.md`.
  */
 export declare class CodexSkillProvider implements SkillProvider {
     private readonly control;
@@ -19,8 +22,8 @@ export declare class CodexSkillProvider implements SkillProvider {
     constructor(control: SkillProviderControl);
     list(options: SkillLookupOptions): Promise<readonly SkillCandidate[]>;
     get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
-    /** Read one AGENTS.md file and push a candidate when it exists. */
-    private collectAgentsMd;
+    /** One merged `agents-md` candidate for a ranked file set. */
+    private agentsCandidate;
 }
 export default CodexSkillProvider;
 //# sourceMappingURL=skills.d.ts.map

package/lib/types/engine-pi/skills.d.ts

@@ -1,17 +1,40 @@
 /**
- * Pi skill provider: exposes the Pi CLI's instruction files as DSH skills.
- * Pi reads project and user instruction files named `AGENTS.md` (like codex),
- * and its own tool rules live under `.pi/`. Each found `AGENTS.md` is surfaced
- * as a single user-invocable skill whose content is the file body, so the dsh
- * skill-injection seam (`/name` gestures) can carry it into the prompt — the
- * same bridge the codex driver exposes.
+ * Pi skill provider: exposes the Pi CLI's instruction files and skills as DSH
+ * skills.
+ *
+ * Pi reads per-directory context files (`AGENTS.md`, or `CLAUDE.md`,
+ * preferring `AGENTS.override.md` where one exists) from the session cwd up to
+ * the git root, plus a global `AGENTS.md` under the pi config directory
+ * (`PI_CODING_AGENT_DIR` or `~/.pi/agent`), and installs skills from
+ * `skills/` directories (`~/.pi/agent/skills/` and project `.pi/skills/`
+ * walking up). Each context-file set is surfaced as one user-invocable
+ * `agents-md` skill whose body is the concatenated file contents; every found
+ * `SKILL.md` catalog entry is surfaced under its own name, so the dsh
+ * skill-injection seam (`/name` gestures) can carry them into the prompt.
+ *
+ * `.agents/skills` roots are deliberately not scanned here: dsh's own
+ * `skill-filesystem` provider already exposes them through the same registry
+ * in the web profile. Pi settings/CLI/package skills are only discoverable
+ * through a running `pi --mode rpc` probe, which the engine does not perform
+ * at composition time — the filesystem subset above is authoritative for the
+ * web menu.
  *
  * @module dsh-loop-engine/engine-pi/skills
  */
-import { type SkillCandidate, type SkillDefinition, type SkillLookupOptions, type SkillProvider, type SkillProviderControl } from '../skills.ts';
+import type { SkillCandidate, SkillDefinition, SkillLookupOptions, SkillProvider, SkillProviderControl } from '../skills.ts';
+/**
+ * Resolve the pi config directory, honoring the `PI_CODING_AGENT_DIR`
+ * environment override and falling back to `~/.pi/agent`.
+ * @returns the absolute pi config directory.
+ */
+export declare function piAgentDir(): string;
 /**
- * Skill provider that discovers `AGENTS.md` from the project root (git root
- * when one exists) and the user home `~/.pi/AGENTS.md`.
+ * Skill provider that discovers context files and skills from pi's standard
+ * locations:
+ *   - project context files between the cwd and the git root (plus
+ *     `~/.pi/agent/AGENTS.md`) — surfaced as one `agents-md` skill;
+ *   - project `.pi/skills/` and user `~/.pi/agent/skills/` — each `SKILL.md`
+ *     entry surfaced under its own name.
  */
 export declare class PiSkillProvider implements SkillProvider {
     private readonly control;
@@ -19,8 +42,14 @@ export declare class PiSkillProvider implements SkillProvider {
     constructor(control: SkillProviderControl);
     list(options: SkillLookupOptions): Promise<readonly SkillCandidate[]>;
     get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
-    /** Read one AGENTS.md file and push a candidate when it exists. */
-    private collectAgentsMd;
+    /** One merged `agents-md` candidate for a ranked file set. */
+    private agentsCandidate;
+    /** Collect every skill in one skills directory, both pi layouts. */
+    private collectSkillsDir;
+    /** One parsed skill as a ranked candidate. */
+    private skillCandidate;
+    /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
+    private tryParse;
 }
 export default PiSkillProvider;
 //# sourceMappingURL=skills.d.ts.map

package/lib/types/settings.d.ts

@@ -21,6 +21,8 @@ export type LoopEngineId = (typeof LOOP_ENGINE_IDS)[number];
 export interface LoopEngineSettings {
     /** The engine future Agents are created on. */
     engine: LoopEngineId;
+    /** Whether the composer's loop engine picker is shown on the chat page. */
+    showInComposer: boolean;
 }
 /** Schema of the loop engine settings section. */
 export declare const LOOP_ENGINE_SETTINGS_SCHEMA: z<LoopEngineSettings>;

package/lib/types/skills.d.ts

@@ -56,6 +56,22 @@ export interface SkillProviderControl {
     readonly signal: AbortSignal;
     invalidate(): void;
 }
+/** One parsed agents-skill standard skill: frontmatter metadata plus the body. */
+export interface ParsedSkill {
+    name: string;
+    description: string;
+    whenToUse?: string;
+    invocation: SkillInvocationPolicy;
+    content: string;
+}
+/**
+ * Parse one agents-skill standard file: YAML frontmatter (`name`,
+ * `description`, optional `whenToUse`/`disable-model-invocation`/
+ * `user-invocable`) plus the markdown body.
+ * @param raw - the raw file content.
+ * @returns the parsed skill, or `undefined` when the file is not a skill.
+ */
+export declare function parseSkillFile(raw: string): ParsedSkill | undefined;
 /**
  * Skill provider that discovers skills from Claude Code's standard locations:
  *   - `<project>/.claude/skills/` — project skills

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-loop-engine",
   "description": "Web-switchable agent loop engine selection for the DeepSeek Harness - out-of-tree plugin (Claude Code / Codex drivers) maintained by @kuun993, zero main-repo changes",
-  "version": "1.0.0-rc3",
+  "version": "1.0.0-rc4",
   "publishConfig": {
     "access": "public"
   },