@khorsheed/dsh-local-agent-kimi 0.1.0-rc.6

package/lib/types/session-view.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Kimi session viewer: read a scoped-home session's `wire.jsonl` event log
+ * and render a readable transcript (user prompts, assistant thinking and
+ * replies, tool calls with arguments and results). The kimi ACP mode writes
+ * responses to the session file rather than pushing them over the protocol,
+ * and the dsh subagent record for a one-shot run carries only the final
+ * output — this is the way to see what the kimi subagent actually did.
+ *
+ * The transcript is harness-comparison grade: every line is tagged with its
+ * wire turn number (1-based, matching the dsh child session's `turn/start`
+ * numbering), kimi's auto-permission `<system-reminder>` user messages are
+ * filtered out, tool calls carry their rendered arguments, tool results are
+ * matched to their owning call by `parentUuid`, and every `usage.record`
+ * (kimi reports accounting per LLM request, not cumulative) is surfaced with
+ * its transcript position so a delta mirror can sum a round's total.
+ * @module @khorsheed/dsh-local-agent-kimi/session-view
+ */
+import type { TokenUsage } from '@deepseek-ai/dsh-llm';
+/** One rendered transcript line. */
+export type KimiTranscriptLine = ({
+    kind: 'user';
+    text: string;
+    turn: number;
+} | {
+    kind: 'assistant';
+    text: string;
+    turn: number;
+} | {
+    kind: 'think';
+    text: string;
+    turn: number;
+}
+/**
+ * Tool activity: one call with its (possibly still pending) result. `id`
+ * is the wire's toolCallId/uuid when present, else a synthesized
+ * position-based id — stable across mirror passes either way, so the
+ * child session's `tool/call`/`tool/result` events pair by it.
+ */
+ | {
+    kind: 'tool';
+    id: string;
+    name: string;
+    args?: string;
+    result?: string;
+    turn: number;
+}) & {
+    model?: string;
+};
+/** A parsed transcript of one kimi session. */
+export interface KimiSessionTranscript {
+    /** Session id. */
+    sessionId: string;
+    /** Transcript lines in event order, each tagged with its wire turn number. */
+    lines: readonly KimiTranscriptLine[];
+    /**
+     * Every `usage.record` the wire reported, tagged with the transcript-line
+     * position it occurred at. Each record is ONE LLM request's accounting
+     * (kimi does not accumulate within a turn), so a mirror sums the records
+     * whose position falls inside the delta it appends.
+     */
+    usageRecords: readonly {
+        readonly line: number;
+        readonly usage: TokenUsage;
+    }[];
+    /**
+     * The model identifier the wire named: the `model` field of a `usage.record`
+     * or `llm.request` event, LAST one seen (a resumed session's later rounds
+     * append later records, so the last record is the latest round's). Absent
+     * when the wire named none — older kimi releases omit it.
+     */
+    model?: string;
+    /** Turn containing the latest native model observation. */
+    modelTurn?: number;
+}
+/**
+ * Find a session directory under `<homeDir>/sessions/wd_*` whose id matches.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @param sessionId - the kimi session id.
+ * @returns the session directory, or undefined when absent.
+ */
+export declare function findKimiSessionDir(homeDir: string, sessionId: string): Promise<string | undefined>;
+/**
+ * Parse a session's wire log into transcript lines plus every usage record.
+ * @param sessionDir - the session directory.
+ * @returns the transcript.
+ */
+export declare function readKimiTranscript(sessionDir: string): Promise<KimiSessionTranscript>;
+/**
+ * Map a wire `usage.record` payload onto the shared usage contract. kimi
+ * reports input (uncached), cache read, cache creation, and output; the
+ * creation counter is its cache-write analog. Non-numeric or missing
+ * counters are dropped so the record stays usable when kimi omits a field.
+ * @param raw - the event's `usage` value.
+ * @returns the shared usage record, or undefined when nothing was reported.
+ */
+export declare function usageFromWire(raw: unknown): TokenUsage | undefined;
+/**
+ * Sum per-request usage records into one round total. Each `usage.record` is
+ * a single LLM request's accounting, so a round's totals are the sum of the
+ * records inside it.
+ * @param records - the usage records to add.
+ * @returns the summed usage, or undefined when the list is empty.
+ */
+export declare function sumUsageRecords(records: readonly {
+    readonly line: number;
+    readonly usage: TokenUsage;
+}[]): TokenUsage | undefined;
+/**
+ * Merge two usage windows into one running total — the delegation run's
+ * per-round accumulator: each mirror pass (live poll, settle) returns its
+ * own window's accounting, and the disjoint windows sum to the round's
+ * total. `undefined` operands pass through, so callers accumulate without
+ * absence checks.
+ * @param left - the running total, or undefined before the first window.
+ * @param right - the next window's usage, or undefined when it had none.
+ * @returns the merged total, or undefined when both operands are absent.
+ */
+export declare function addTokenUsage(left: TokenUsage | undefined, right: TokenUsage | undefined): TokenUsage | undefined;
+/** Render a transcript as command-reply text. */
+export declare function renderTranscript(transcript: KimiSessionTranscript): string;
+//# sourceMappingURL=session-view.d.ts.map

package/lib/types/session-view.js

@@ -0,0 +1,423 @@
+/**
+ * Kimi session viewer: read a scoped-home session's `wire.jsonl` event log
+ * and render a readable transcript (user prompts, assistant thinking and
+ * replies, tool calls with arguments and results). The kimi ACP mode writes
+ * responses to the session file rather than pushing them over the protocol,
+ * and the dsh subagent record for a one-shot run carries only the final
+ * output — this is the way to see what the kimi subagent actually did.
+ *
+ * The transcript is harness-comparison grade: every line is tagged with its
+ * wire turn number (1-based, matching the dsh child session's `turn/start`
+ * numbering), kimi's auto-permission `<system-reminder>` user messages are
+ * filtered out, tool calls carry their rendered arguments, tool results are
+ * matched to their owning call by `parentUuid`, and every `usage.record`
+ * (kimi reports accounting per LLM request, not cumulative) is surfaced with
+ * its transcript position so a delta mirror can sum a round's total.
+ * @module @khorsheed/dsh-local-agent-kimi/session-view
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/** The wire event log path for a session directory. */
+function wirePath(sessionDir) {
+    return join(sessionDir, 'agents', 'main', 'wire.jsonl');
+}
+/**
+ * Find a session directory under `<homeDir>/sessions/wd_*` whose id matches.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @param sessionId - the kimi session id.
+ * @returns the session directory, or undefined when absent.
+ */
+export async function findKimiSessionDir(homeDir, sessionId) {
+    const sessionsRoot = join(homeDir, 'sessions');
+    let workspaces;
+    try {
+        workspaces = await readdir(sessionsRoot);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    for (const workspace of workspaces) {
+        const sessionDir = join(sessionsRoot, workspace, `session_${sessionId}`);
+        try {
+            await readFile(wirePath(sessionDir));
+            return sessionDir;
+        }
+        catch {
+            // Not this workspace's session; keep looking.
+        }
+    }
+    return undefined;
+}
+/** Whether a user message is kimi's auto-permission reminder, never real task text. */
+function isSystemReminder(text) {
+    return text.startsWith('<system-reminder>');
+}
+/** Flatten the text blocks of a message content array. */
+function textOf(content) {
+    return (content ?? [])
+        .filter((block) => typeof block === 'object' && block !== null && block.type === 'text')
+        .map(block => block.text ?? '')
+        .join('');
+}
+/**
+ * Render a file-editing tool call's arguments apply-patch style: the path
+ * plus the old/new content. Without this a delegation's edits collapsed to
+ * the bare path (or nothing) and the transcript hid what the member actually
+ * changed — the kimi twin of codex's fileChange → ApplyPatch fold.
+ * @param name - the tool name the wire recorded.
+ * @param record - the call's argument object.
+ * @returns the patch-style summary, or undefined when the tool is not a
+ *   known file-editing shape.
+ */
+function editArgsOf(name, record) {
+    const path = typeof record['path'] === 'string' ? record['path'] : undefined;
+    if (name === 'Edit' || name === 'MultiEdit') {
+        if (path === undefined || path.trim() === '')
+            return undefined;
+        const edits = Array.isArray(record['edits']) ? record['edits'] : [record];
+        const hunks = [];
+        for (const edit of edits) {
+            const oldText = typeof edit['old_string'] === 'string' ? edit['old_string'] : '';
+            const newText = typeof edit['new_string'] === 'string' ? edit['new_string'] : '';
+            if (oldText === '' && newText === '')
+                continue;
+            hunks.push('@@', ...oldText.split('\n').map(line => `-${line}`), ...newText.split('\n').map(line => `+${line}`));
+        }
+        // An edit call whose content the wire did not carry keeps the scalar path.
+        if (hunks.length === 0)
+            return undefined;
+        return [`update: ${path}`, ...hunks].join('\n');
+    }
+    if (name === 'Write') {
+        if (path === undefined || path.trim() === '')
+            return undefined;
+        const content = typeof record['content'] === 'string' ? record['content'] : '';
+        // A Write whose content the wire did not carry keeps the scalar path.
+        if (content === '')
+            return undefined;
+        return [`add: ${path}`, ...content.split('\n').map(line => `+${line}`)].join('\n');
+    }
+    // Patch-style tools (ApplyPatch and friends): the patch text IS the argument.
+    const patch = record['patch'] ?? record['diff'];
+    if (typeof patch === 'string' && patch.trim() !== '')
+        return patch;
+    return undefined;
+}
+/** Render a tool call's arguments into a compact summary. */
+function argsOf(name, args) {
+    if (args === undefined)
+        return undefined;
+    if (typeof args === 'string')
+        return args.trim() === '' ? undefined : args;
+    if (typeof args !== 'object' || args === null || Array.isArray(args))
+        return undefined;
+    const record = args;
+    // File-editing tools first: their edit content outranks the bare path the
+    // scalar preference below would otherwise reduce them to.
+    const edit = editArgsOf(name, record);
+    if (edit !== undefined)
+        return edit;
+    // WebSearch/FetchURL expose a query/url; prefer the most meaningful scalar.
+    for (const key of ['query', 'url', 'path', 'command']) {
+        const value = record[key];
+        if (typeof value === 'string' && value.trim() !== '')
+            return value.trim();
+    }
+    // A tool whose meaningful arg is none of the four (Agent's prompt, Grep's
+    // pattern, …): a short key=value summary beats dropping the call entirely.
+    const pairs = [];
+    for (const [key, value] of Object.entries(record)) {
+        if (typeof value === 'string' && value.trim() !== '')
+            pairs.push(`${key}=${value.trim()}`);
+        else if (typeof value === 'number' || typeof value === 'boolean')
+            pairs.push(`${key}=${String(value)}`);
+    }
+    if (pairs.length === 0)
+        return undefined;
+    const summary = pairs.join(' ');
+    return summary.length > 200 ? `${summary.slice(0, 200)}…` : summary;
+}
+/**
+ * Parse a session's wire log into transcript lines plus every usage record.
+ * @param sessionDir - the session directory.
+ * @returns the transcript.
+ */
+export async function readKimiTranscript(sessionDir) {
+    const sessionId = sessionDir.split('session_').pop() ?? sessionDir;
+    const lines = [];
+    const usageRecords = [];
+    let model;
+    let modelTurn;
+    let lineModel;
+    const push = (line) => {
+        lines.push({ ...line, ...lineModel === undefined ? {} : { model: lineModel } });
+    };
+    // Wire turns are 0-based on loop events; a `turn.prompt` also opens a new
+    // round. The transcript uses 1-based turns matching the dsh child session's
+    // turn/start numbering.
+    let turn = 0;
+    let turnSeen = false;
+    // Tool calls by uuid and toolCallId, so a result attaches to its own call
+    // even when several calls run in parallel within one step.
+    const callsByUuid = new Map();
+    const callsByToolCallId = new Map();
+    let text;
+    try {
+        text = await readFile(wirePath(sessionDir), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { sessionId, lines, usageRecords };
+        }
+        throw error;
+    }
+    for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        if (line === '')
+            continue;
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (event.type === 'usage.record') {
+            // The record's own `model` field is the observed model identifier
+            // (verified against kimi 0.39.x wires); the `llm.request` fallback
+            // below covers wires whose usage records omit it. Last one seen wins:
+            // a resumed session's later rounds append later records.
+            if (typeof event.model === 'string' && event.model !== '') {
+                model = lineModel = event.model;
+                modelTurn = turn || 1;
+            }
+            const usage = usageFromWire(event.usage);
+            if (usage !== undefined)
+                usageRecords.push({ line: lines.length, usage });
+            continue;
+        }
+        if (event.type === 'llm.request') {
+            lineModel = typeof event.model === 'string' && event.model !== '' ? event.model : undefined;
+            if (typeof event.model === 'string' && event.model !== '') {
+                model = event.model;
+                modelTurn = turn || 1;
+            }
+            continue;
+        }
+        if (event.type === 'turn.prompt') {
+            lineModel = undefined;
+            // Each round's user prompt opens the next turn; the matching
+            // context.append_message below is deduped against this text.
+            turnSeen = true;
+            turn += 1;
+            const prompt = textOf(event.input ?? []);
+            if (prompt.trim() !== '' && !isSystemReminder(prompt)) {
+                push({ kind: 'user', text: prompt, turn: turn === 0 ? 1 : turn });
+            }
+            continue;
+        }
+        if (event.type === 'context.append_message') {
+            const message = event.message;
+            const role = message?.role;
+            const textContent = textOf(message?.content ?? []);
+            if (role === 'user' && textContent.trim() !== '' && !isSystemReminder(textContent)) {
+                // A user append_message that duplicates the current turn.prompt (the
+                // ACP server replays the prompt into the context) must not open a new
+                // turn; when no turn.prompt preceded it, treat it as the round start.
+                // The dedupe compares TEXT, not just kind: a second DISTINCT user
+                // message in a row (a mid-round injection) is real content.
+                const last = lines[lines.length - 1];
+                if (turnSeen && last?.kind === 'user' && last.text === textContent) {
+                    // Duplicate of the prompt; skip.
+                    continue;
+                }
+                turnSeen = true;
+                turn += 1;
+                lineModel = undefined;
+                push({ kind: 'user', text: textContent, turn: turn === 0 ? 1 : turn });
+            }
+            else if (role === 'assistant' && textContent.trim() !== '') {
+                push({ kind: 'assistant', text: textContent, turn: turn === 0 ? 1 : turn });
+            }
+            continue;
+        }
+        if (event.type === 'context.append_loop_event') {
+            const loop = event.event;
+            if (loop === undefined)
+                continue;
+            const loopTurn = typeof loop.turnId === 'number' ? loop.turnId + 1 : undefined;
+            if (loopTurn !== undefined) {
+                turn = Math.max(turn, loopTurn);
+                turnSeen = true;
+            }
+            const part = loop.part;
+            const lineTurn = turn === 0 ? 1 : turn;
+            if (part?.type === 'text' && part.text !== undefined && part.text.trim() !== '') {
+                push({ kind: 'assistant', text: part.text, turn: lineTurn });
+            }
+            else if (part?.type === 'think' && part.think !== undefined && part.think.trim() !== '') {
+                push({ kind: 'think', text: part.think, turn: lineTurn });
+            }
+            else if (loop.type === 'tool.call') {
+                const call = loop;
+                const name = call.toolCall?.name ?? call.name ?? 'tool';
+                const args = argsOf(name, call.toolCall?.args ?? call.args);
+                const lineIndex = lines.length;
+                push({
+                    kind: 'tool',
+                    id: typeof call.toolCallId === 'string'
+                        ? call.toolCallId
+                        : typeof call.uuid === 'string' ? call.uuid : `kimi-tool-${lineIndex}`,
+                    name,
+                    ...args === undefined ? {} : { args },
+                    turn: lineTurn,
+                });
+                if (typeof call.uuid === 'string')
+                    callsByUuid.set(call.uuid, lineIndex);
+                if (typeof call.toolCallId === 'string')
+                    callsByToolCallId.set(call.toolCallId, lineIndex);
+            }
+            else if (loop.type === 'tool.result') {
+                const result = loop;
+                const output = result.result?.output;
+                let target = typeof result.parentUuid === 'string'
+                    ? callsByUuid.get(result.parentUuid)
+                    : undefined;
+                if (target === undefined && typeof result.toolCallId === 'string') {
+                    target = callsByToolCallId.get(result.toolCallId);
+                }
+                if (target === undefined) {
+                    // No id to pair with: fall back to the most recent tool line so a
+                    // wire without ids still renders the result on its call.
+                    for (let index = lines.length - 1; index >= 0; index -= 1) {
+                        if (lines[index]?.kind === 'tool') {
+                            target = index;
+                            break;
+                        }
+                    }
+                }
+                if (output !== undefined && output.trim() !== '' && target !== undefined) {
+                    const current = lines[target];
+                    if (current !== undefined && current.kind === 'tool') {
+                        lines[target] = { ...current, result: output };
+                    }
+                }
+            }
+            else if (loop.type === 'content.part'
+                && part?.type !== undefined
+                && part.type !== 'text'
+                && part.type !== 'think') {
+                // A content part type this fold does not know (image, audio, a future
+                // plan part, …): keep a visible marker instead of the content
+                // vanishing from the transcript.
+                push({ kind: 'assistant', text: `[未支持的内容类型 ${part.type}]`, turn: lineTurn });
+            }
+        }
+    }
+    return { sessionId, lines, usageRecords, ...model === undefined ? {} : { model }, ...modelTurn === undefined ? {} : { modelTurn } };
+}
+/**
+ * Map a wire `usage.record` payload onto the shared usage contract. kimi
+ * reports input (uncached), cache read, cache creation, and output; the
+ * creation counter is its cache-write analog. Non-numeric or missing
+ * counters are dropped so the record stays usable when kimi omits a field.
+ * @param raw - the event's `usage` value.
+ * @returns the shared usage record, or undefined when nothing was reported.
+ */
+export function usageFromWire(raw) {
+    const counters = raw;
+    if (counters === undefined || typeof counters !== 'object')
+        return undefined;
+    const num = (value) => {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : undefined;
+    };
+    const input = num(counters.inputOther);
+    const output = num(counters.output);
+    const cacheRead = num(counters.inputCacheRead);
+    const cacheWrite = num(counters.inputCacheCreation);
+    if (input === undefined && output === undefined && cacheRead === undefined && cacheWrite === undefined) {
+        return undefined;
+    }
+    const usage = {
+        inputTokens: input ?? 0,
+        outputTokens: output ?? 0,
+    };
+    if (cacheRead !== undefined && cacheRead > 0)
+        usage.cacheReadTokens = cacheRead;
+    if (cacheWrite !== undefined && cacheWrite > 0)
+        usage.cacheWriteTokens = cacheWrite;
+    return usage;
+}
+/**
+ * Sum per-request usage records into one round total. Each `usage.record` is
+ * a single LLM request's accounting, so a round's totals are the sum of the
+ * records inside it.
+ * @param records - the usage records to add.
+ * @returns the summed usage, or undefined when the list is empty.
+ */
+export function sumUsageRecords(records) {
+    let input = 0;
+    let output = 0;
+    let cacheRead = 0;
+    let cacheWrite = 0;
+    for (const record of records) {
+        input += record.usage.inputTokens ?? 0;
+        output += record.usage.outputTokens ?? 0;
+        cacheRead += record.usage.cacheReadTokens ?? 0;
+        cacheWrite += record.usage.cacheWriteTokens ?? 0;
+    }
+    if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0)
+        return undefined;
+    const usage = { inputTokens: input, outputTokens: output };
+    if (cacheRead > 0)
+        usage.cacheReadTokens = cacheRead;
+    if (cacheWrite > 0)
+        usage.cacheWriteTokens = cacheWrite;
+    return usage;
+}
+/**
+ * Merge two usage windows into one running total — the delegation run's
+ * per-round accumulator: each mirror pass (live poll, settle) returns its
+ * own window's accounting, and the disjoint windows sum to the round's
+ * total. `undefined` operands pass through, so callers accumulate without
+ * absence checks.
+ * @param left - the running total, or undefined before the first window.
+ * @param right - the next window's usage, or undefined when it had none.
+ * @returns the merged total, or undefined when both operands are absent.
+ */
+export function addTokenUsage(left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    return sumUsageRecords([
+        { line: 0, usage: left },
+        { line: 0, usage: right },
+    ]);
+}
+/** Render a transcript as command-reply text. */
+export function renderTranscript(transcript) {
+    if (transcript.lines.length === 0)
+        return `kimi session ${transcript.sessionId}: no readable transcript yet.`;
+    const parts = [`kimi session ${transcript.sessionId}:`];
+    for (const line of transcript.lines) {
+        if (line.kind === 'user') {
+            parts.push(`\n用户: ${line.text}`);
+        }
+        else if (line.kind === 'assistant') {
+            parts.push(`\nkimi: ${line.text}`);
+        }
+        else if (line.kind === 'think') {
+            parts.push(`\n[思考] ${line.text}`);
+        }
+        else {
+            // The other kinds are exhausted above; this is the tool line.
+            const call = `[工具 ${line.name}]${line.args !== undefined ? ` ${line.args}` : ''}`;
+            parts.push(`\n  ↳ ${call}${line.result !== undefined ? ` → ${line.result}` : ''}`);
+        }
+    }
+    return parts.join('\n');
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Kimi Delegation",
+    "description": "Delegate tasks to the Kimi Code CLI from any session."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Kimi 委派",
+    "description": "从任意会话委派任务给 Kimi Code CLI。"
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@khorsheed/dsh-local-agent-kimi",
+  "description": "Kimi Code harness for dsh-local-agent: scoped KIMI_CODE_HOME, one-shot kimi -p delegation visible in the 子代理 surface, session records and preset wiring",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "local-agent",
+    "kimi"
+  ],
+  "version": "0.1.0-rc.6",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./records": {
+      "types": "./lib/types/records.d.ts",
+      "default": "./lib/records.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "dsh": {
+    "references": [
+      "@khorsheed/dsh-bundle-local-agent"
+    ],
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ],
+      "platform": "web"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "compat": {
+      "minHost": "0.1.5-rc.1",
+      "notes": "liveMirrorGranularity token: host 0.1.5 retired the per-chunk session event, so token-mode deltas no longer land in the child session log — they ride the run-progress channel and the round settles as one combined assistant/message (identical final text); a late-arriving usage whose carrier message already mirrored is dropped with a warn (no usage-backfill event exists). The thinkingEffort config item (default high, provision-time only) and the effectiveSettings eval snapshot are plugin-level — scoped-file provisioning and reads with no host-API dependency on either host line",
+      "verifiedHost": "0.1.5-rc.1"
+    }
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "locale/*.json"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@khorsheed/dsh-local-agent": "^0.1.0-rc.6",
+    "@khorsheed/dsh-local-agent-tool-subagent": "^0.1.0-rc.6"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent-preset-registry": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-commands": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-subagent": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-subprocess": "^0.1.0-rc.6",
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-api-remotes": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-locale": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-primitives": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-settings": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-slots": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  }
+}