super-dsh 0.1.9 → 0.1.10-e

package/agent-omp-sdk/dist/discovery.d.ts

@@ -0,0 +1,57 @@
+/**
+ * OMP skills + slash-command discovery, bridged into the host's capability
+ * seams (`ctx.skills` + `ctx.commands`). Both services stay mounted by
+ * dsh-base/dsh-web-app; the bridge only supplies data/registrations — the
+ * UI (SkillRow, the composer `/` menu) already reads them.
+ *
+ * Sidecar-free since the sidecar-decoupling change (plan
+ * 2026-09-16-omp-adapter-sidecar-decoupling): both catalogs are read straight
+ * from disk (omp + claude user/project roots, see omp-disk-discovery). Slash
+ * commands mount once at boot and re-mount on the hourly discovery refresh —
+ * never a sidecar spawn.
+ *
+ * @module agent-omp/discovery
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import { type OmpDiskSlashCommand } from "./omp-disk-discovery.js";
+interface CommandRuntimeSlice {
+    register(definition: {
+        name: string;
+        description: string;
+        input?: {
+            hint?: string;
+            attachments?: boolean;
+        };
+        handler(): {
+            kind: "success";
+            text?: string;
+        } | {
+            kind: "error";
+            text: string;
+        };
+    }): () => void;
+}
+/**
+ * Register one set of disk-scanned OMP slash commands on the host runtime.
+ * The handler echoes the command body as the result text — a first-pass
+ * surface; a deeper integration would route execution through the bridged
+ * Agent. Returns a disposer for the whole set.
+ */
+export declare function mountSlashCommands(commands: CommandRuntimeSlice, found: OmpDiskSlashCommand[]): () => void;
+/**
+ * A refreshable slash-command mount: registers the boot scan immediately,
+ * then `refresh()` swaps the live set for a fresh disk scan (dispose-then-
+ * register, so a removed command file disappears from the `/` menu).
+ */
+export declare function createSlashCommandMount(commands: CommandRuntimeSlice, cwd?: string): {
+    refresh: () => void;
+    disposeAll: () => void;
+};
+/**
+ * Mount OMP discovery on the host seams. Fail-open: a missing `skills` or
+ * `commands` service leaves the feature dormant, never blocks host boot.
+ *
+ * @param ctx - host plugin context.
+ */
+export declare function installOmpDiscovery(ctx: Context): void;
+export {};

package/agent-omp-sdk/dist/discovery.js

@@ -0,0 +1,116 @@
+import { readFile } from "node:fs/promises";
+import { OMP_DISCOVERY_REFRESH_INTERVAL_MS } from "./knobs.js";
+import { readSkills, readSlashCommands, } from "./omp-disk-discovery.js";
+/** Strip a slash-command name to the host's `/^[a-z][a-z0-9_-]*$/` shape. */
+function sanitizeCommandName(name) {
+    const cleaned = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+/, "").slice(0, 64);
+    return cleaned === "" ? "omp-command" : cleaned;
+}
+/**
+ * Register one set of disk-scanned OMP slash commands on the host runtime.
+ * The handler echoes the command body as the result text — a first-pass
+ * surface; a deeper integration would route execution through the bridged
+ * Agent. Returns a disposer for the whole set.
+ */
+export function mountSlashCommands(commands, found) {
+    const disposers = found.map((command) => commands.register({
+        name: sanitizeCommandName(command.name),
+        description: command.description,
+        handler: () => ({ kind: "success", text: command.content }),
+    }));
+    return () => {
+        for (const dispose of disposers) {
+            try {
+                dispose();
+            }
+            catch {
+                // A host-side double-dispose must not break the refresh cycle.
+            }
+        }
+    };
+}
+/**
+ * A refreshable slash-command mount: registers the boot scan immediately,
+ * then `refresh()` swaps the live set for a fresh disk scan (dispose-then-
+ * register, so a removed command file disappears from the `/` menu).
+ */
+export function createSlashCommandMount(commands, cwd) {
+    let dispose = () => { };
+    const refresh = () => {
+        dispose();
+        dispose = mountSlashCommands(commands, readSlashCommands(cwd));
+    };
+    refresh();
+    return {
+        refresh,
+        disposeAll: () => dispose(),
+    };
+}
+/**
+ * Mount OMP discovery on the host seams. Fail-open: a missing `skills` or
+ * `commands` service leaves the feature dormant, never blocks host boot.
+ *
+ * @param ctx - host plugin context.
+ */
+export function installOmpDiscovery(ctx) {
+    // Skills: a discovery provider whose `list(cwd)` scans OMP's disk roots for
+    // the caller's workspace; the body is read lazily from SKILL.md in `get`.
+    ctx.inject(["skills"], (scoped) => {
+        const skills = scoped.get("skills");
+        if (skills === undefined)
+            return;
+        skills.registerProvider(() => ({
+            name: "omp",
+            list: async (options) => {
+                const found = readSkills(options.cwd);
+                return found.map((skill, rank) => ({
+                    name: skill.name,
+                    description: skill.description,
+                    rank,
+                    locator: skill.filePath,
+                    path: skill.filePath,
+                    invocation: { modelInvocable: true, userInvocable: true },
+                    source: "custom",
+                    provider: "omp",
+                }));
+            },
+            get: async (candidate) => {
+                const content = await readFile(String(candidate.locator), "utf8").catch(() => "");
+                return {
+                    name: candidate.name,
+                    description: candidate.description,
+                    content,
+                    invocation: { modelInvocable: true, userInvocable: true },
+                    source: "custom",
+                    provider: "omp",
+                };
+            },
+        }));
+    });
+    // Slash commands: mount the boot scan, then re-scan on the hourly discovery
+    // cadence (pure disk reads; `0` disables). The interval + live registrations
+    // are fiber-owned: torn down with the plugin context.
+    ctx.inject(["commands"], (scoped) => {
+        const commands = scoped.get("commands");
+        if (commands === undefined)
+            return;
+        const mount = createSlashCommandMount(commands);
+        let timer;
+        if (OMP_DISCOVERY_REFRESH_INTERVAL_MS > 0) {
+            timer = setInterval(() => {
+                try {
+                    mount.refresh();
+                }
+                catch {
+                    // A bad refresh must never kill the interval or the host.
+                }
+            }, OMP_DISCOVERY_REFRESH_INTERVAL_MS);
+            timer.unref?.();
+        }
+        ctx.effect(() => () => {
+            if (timer !== undefined)
+                clearInterval(timer);
+            mount.disposeAll();
+        }, "ompDiscovery.slashCommands");
+    });
+}

package/agent-omp-sdk/dist/inbox.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal in-memory inbox for the OMP agent shim.
+ *
+ * The 0.1.5 `dsh-agent` contract exposes the inbox as an interface
+ * (`Inbox` in `runtime-types`); the durable projection-backed implementation
+ * (`ReactLoopInbox`) lives inside the (disabled) `dsh-agent-loop`. OMP owns
+ * its own transcript and the bridge delivers messages directly to the OMP
+ * process (`OmpAgent.#deliver`), so this inbox is never queued into — it
+ * exists to satisfy the `Agent` interface's `inbox` surface with correct
+ * (empty) semantics: `nextTurn`/`nextStep` stay empty and every mutation is
+ * a faithful in-memory splice.
+ *
+ * @module agent-omp/inbox
+ */
+import type { Inbox as InboxContract, InboxTarget } from "@deepseek-ai/dsh-agent";
+import type { UserMessage } from "@deepseek-ai/dsh-session";
+import type { MessageId } from "@deepseek-ai/dsh-llm";
+export declare class Inbox implements InboxContract {
+    #private;
+    get nextTurn(): readonly UserMessage[];
+    get nextStep(): readonly UserMessage[];
+    clear(): void;
+    append(target: InboxTarget, message: UserMessage): void;
+    prepend(target: InboxTarget, message: UserMessage): void;
+    replace(messageId: MessageId, newMessage: UserMessage): boolean;
+    remove(messageId: MessageId): boolean;
+    splice(target: InboxTarget, start: number, deleteCount: number, inserted: UserMessage[]): UserMessage[];
+}

package/agent-omp-sdk/dist/inbox.js

@@ -0,0 +1,53 @@
+export class Inbox {
+    #nextTurn = [];
+    #nextStep = [];
+    get nextTurn() {
+        return this.#nextTurn;
+    }
+    get nextStep() {
+        return this.#nextStep;
+    }
+    clear() {
+        this.#nextTurn = [];
+        this.#nextStep = [];
+    }
+    append(target, message) {
+        this.#list(target).push(message);
+    }
+    prepend(target, message) {
+        this.#list(target).unshift(message);
+    }
+    replace(messageId, newMessage) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1, newMessage);
+        return true;
+    }
+    remove(messageId) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1);
+        return true;
+    }
+    splice(target, start, deleteCount, inserted) {
+        return this.#list(target).splice(start, deleteCount, ...inserted);
+    }
+    #list(target) {
+        return target === "next-turn" ? this.#nextTurn : this.#nextStep;
+    }
+    #find(messageId) {
+        if (this.#nextTurn.some((message) => message.id === messageId))
+            return this.#nextTurn;
+        if (this.#nextStep.some((message) => message.id === messageId))
+            return this.#nextStep;
+        return undefined;
+    }
+}

package/agent-omp-sdk/dist/index.d.ts

@@ -0,0 +1,60 @@
+import { Context, Service } from "@deepseek-ai/cordis";
+import type { AgentFactory, AgentHandle, CreateAgentOptions, ResumeAgentOptions } from "@deepseek-ai/dsh-agent";
+import { type OmpAgentRpc } from "./lazy-rpc.js";
+/**
+ * Whether any live OMP session currently holds the SDK transport's child.
+ *
+ * The reconcile tick's catalog read is a real `omp models --json` subprocess,
+ * so this gate is load-bearing (AGENTS.md §五·五: the periodic tick never
+ * materializes a runtime). For this line the periodic path does NOT touch the
+ * sidecar at all — the data plane is the CLI — but the tick must still pull
+ * zero children, and the SDK wrapper's `spawned` is the honest fact to gate on.
+ * Sessions count only once they actually spawned: a draft session holds a
+ * `LazyOmpRpc` with no child (and no fetched runtime) yet.
+ * Exported beside the plugin (the cordis surface itself is unchanged) so the
+ * no-sidecar guard can pin this gate's truth table behaviourally — a shape
+ * regex alone cannot see an empty input set.
+ */
+export declare function liveOmpSessionExists(sessions: Iterable<OmpAgentRpc>): boolean;
+export declare class OmpProvider extends Service implements AgentFactory {
+    #private;
+    /**
+     * `agentDefaultModel` is load-bearing, not decorative: the harness owns the
+     * "default for new sessions" selection there (`@deepseek-ai/dsh-agent-default-model`,
+     * mounted by dsh-base with a hard-coded `deepseek-official/deepseek-flash`),
+     * and this bridge is the only thing that feeds it OMP's configured default.
+     * Without the inject the context cannot resolve the service, every
+     * `saveSelection` in #syncModelDefaultTick silently no-ops, and a fresh
+     * session inherits the unserved native default → `session/model-unavailable`.
+     */
+    static inject: string[];
+    /** Plain holder — prevents Cordis re-tracing the factory's ctx through a caller shadow. */
+    private readonly runtime;
+    /**
+     * The SDK transport (one sidecar pool per provider = per dsh process). Built
+     * here, but CONSTRUCTION-FREE: the pool is inert until the first session's
+     * first prompt reaches `OmpSdkSidecar#start()`.
+     */
+    private readonly transport;
+    /** Live SDK-backed agents by dash id, for avoidance hand-off. */
+    private readonly heldAgents;
+    /**
+     * Live transport wrappers by dash id — the reconcile tick's liveness gate
+     * (AGENTS.md §五·五): a draft session counts as live only once its
+     * `spawned` flips, which is exactly when the runtime fetch + sidecar start
+     * have happened. Entries are dropped with the handle.
+     */
+    private readonly liveSessions;
+    constructor(ctx: Context);
+    createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
+    /**
+     * Track a published RPC-backed agent, register its transport wrapper with the
+     * tick's liveness gate, and hand the session to the supervisor as held. Arrow
+     * FIELD (not a `#` method): the provider is exposed through a Cordis tracing
+     * proxy, and hard-private methods fail their brand check on the proxy receiver
+     * (the same reason setupAndPublish is module-level).
+     */
+    private readonly registerHeld;
+}
+export default OmpProvider;