@openvulcan/dsh-vulcancode 0.0.0-stage → 0.4.0

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/fences.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Recover a fence's info string from the Markdown source. dsh's code block receives only the first
+ * word of the info string as its language, while `ui-*` components also read the rest (`ui-chart bar
+ * Weekly`), so the browser half looks the fence up in the message text it rendered from.
+ */
+/** One fenced block found in Markdown source. */
+export interface SourceFence {
+    /** First word of the info string, as Markdown parsers report the language. */
+    readonly language: string;
+    /** The rest of the info string, trimmed. */
+    readonly meta: string;
+    /** The fence content without its fences and without the opening line's indentation. */
+    readonly body: string;
+}
+/**
+ * Every fenced block of `markdown`, outer fences before the fences nested in their content. The scan is
+ * deliberately lenient (list and quote containers are only stripped, not modelled): it serves to look
+ * up a fence whose language and content the renderer already reported, never to decide what is a fence.
+ */
+export declare function scanFences(markdown: string): SourceFence[];
+/**
+ * The meta of the fence in `markdown` whose language starts with `language` (as dsh reports it, the
+ * leading `[\w-]+` run) and whose content is `code`. An exact content match wins over one that only
+ * matches line by line after trimming; undefined when no fence matches.
+ */
+export declare function findFenceInfo(markdown: string, language: string, code: string): {
+    language: string;
+    meta: string;
+} | undefined;

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/fences.js

@@ -0,0 +1,70 @@
+/**
+ * Recover a fence's info string from the Markdown source. dsh's code block receives only the first
+ * word of the info string as its language, while `ui-*` components also read the rest (`ui-chart bar
+ * Weekly`), so the browser half looks the fence up in the message text it rendered from.
+ */
+/** Container prefix (`>` quotes) and indentation before a fence marker. */
+const OPENING = /^((?:[ \t]*>)*)([ \t]*)(`{3,}|~{3,})(.*)$/u;
+/**
+ * Every fenced block of `markdown`, outer fences before the fences nested in their content. The scan is
+ * deliberately lenient (list and quote containers are only stripped, not modelled): it serves to look
+ * up a fence whose language and content the renderer already reported, never to decide what is a fence.
+ */
+export function scanFences(markdown) {
+    const lines = markdown.split(/\r?\n/u);
+    const found = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const opening = OPENING.exec(lines[index] ?? '');
+        if (!opening)
+            continue;
+        const quotes = opening[1] ?? '';
+        const indent = (opening[2] ?? '').length;
+        const marker = opening[3] ?? '';
+        const info = (opening[4] ?? '').trim();
+        if (marker.startsWith('`') && info.includes('`'))
+            continue;
+        const char = marker[0] ?? '`';
+        const closing = new RegExp(`^(?:[ \\t]*>)*[ \\t]*${char}{${marker.length},}[ \\t]*$`, 'u');
+        const body = [];
+        let end = index + 1;
+        for (; end < lines.length; end += 1) {
+            const line = lines[end] ?? '';
+            if (closing.test(line))
+                break;
+            body.push(stripPrefix(line, quotes.length > 0, indent));
+        }
+        const [word = ''] = info.split(/\s/u);
+        found.push({ language: word, meta: info.slice(word.length).trim(), body: body.join('\n') });
+        const nested = scanFences(body.join('\n'));
+        found.push(...nested);
+        index = end;
+    }
+    return found;
+}
+/** Remove a quote prefix and up to `indent` columns of indentation from one content line. */
+function stripPrefix(line, quoted, indent) {
+    let text = quoted ? line.replace(/^(?:[ \t]*>[ ]?)+/u, '') : line;
+    let removed = 0;
+    while (removed < indent && (text.startsWith(' ') || text.startsWith('\t'))) {
+        text = text.slice(1);
+        removed += 1;
+    }
+    return text;
+}
+/**
+ * The meta of the fence in `markdown` whose language starts with `language` (as dsh reports it, the
+ * leading `[\w-]+` run) and whose content is `code`. An exact content match wins over one that only
+ * matches line by line after trimming; undefined when no fence matches.
+ */
+export function findFenceInfo(markdown, language, code) {
+    const target = code.replace(/\n$/u, '');
+    const candidates = scanFences(markdown).filter((fence) => /^[\w-]+/u.exec(fence.language)?.[0] === language);
+    const exact = candidates.find((fence) => fence.body === target);
+    const loose = exact ?? candidates.find((fence) => sameTrimmedLines(fence.body, target));
+    return loose === undefined ? undefined : { language: loose.language, meta: loose.meta };
+}
+/** Whether two texts have the same nonblank lines after trimming each. */
+function sameTrimmedLines(a, b) {
+    const lines = (text) => text.split('\n').map((line) => line.trim()).filter(Boolean).join('\n');
+    return lines(a) === lines(b);
+}

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Vulcan Answers for DeepSeek Harness: VulcanCode's interactive answer mode. While a session is
+ * interactive the model receives the `ui-*` component guide as runtime context, and the browser half
+ * renders the settled components in the chat. Each session keeps its own mode (see `session-state.ts`).
+ */
+import type { Context, Volatile } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { type AnswerMode } from './session-state.js';
+export { parseAnswerComponent, SUPPORTED_ANSWER_LANGUAGES, type AnswerComponent } from './answer-model.js';
+export { MODE_COMMAND, MODE_RECORD, PROJECTION_KEY, type AnswerMode, type AnswerSessionView } from './session-state.js';
+export declare const name = "vulcan-answers";
+export declare const inject: string[];
+/** Every field is volatile: dsh's settings forms expose only volatile fields. */
+export interface Config {
+    /** Answer mode a new session starts with; existing sessions keep their own. */
+    defaultMode: Volatile<AnswerMode>;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): Promise<void>;

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/index.js

@@ -0,0 +1,52 @@
+/**
+ * Vulcan Answers for DeepSeek Harness: VulcanCode's interactive answer mode. While a session is
+ * interactive the model receives the `ui-*` component guide as runtime context, and the browser half
+ * renders the settled components in the chat. Each session keeps its own mode (see `session-state.ts`).
+ */
+import Schema from '@deepseek-ai/schemastery';
+import { answerContextText, loadAnswerModeTexts } from './prompt.js';
+import { installSessionState, seedSession } from './session-state.js';
+export { parseAnswerComponent, SUPPORTED_ANSWER_LANGUAGES } from './answer-model.js';
+export { MODE_COMMAND, MODE_RECORD, PROJECTION_KEY } from './session-state.js';
+export const name = 'vulcan-answers';
+export const inject = ['sessionProjections', 'systemPrompt'];
+/** Runtime context name; one per process. */
+const CONTEXT_NAME = 'vulcan-answers:answer-mode';
+/** After dsh's own runtime contexts (100-210), so the guide follows the facts it builds on. */
+const CONTEXT_ORDER = 300;
+export const Config = Schema.object({
+    defaultMode: Schema.union(['interactive', 'standard'])
+        .default('interactive')
+        .description('Answer mode new sessions start with. interactive: answers use ui-* components. standard: plain Markdown. Existing sessions keep their own mode.')
+        .volatile(),
+});
+/** The session an assembly is for; dsh-agent adds `agent` to the assemble context. */
+function assembledSession(context) {
+    return context.agent?.session;
+}
+export async function apply(ctx, config) {
+    const texts = loadAnswerModeTexts();
+    const defaultMode = () => config.defaultMode.get();
+    const read = await installSessionState(ctx, defaultMode);
+    ctx.systemPrompt.context({
+        name: CONTEXT_NAME,
+        order: CONTEXT_ORDER,
+        interpolate: false,
+        // The mode is the user's choice for the session, so a persona that drops optional context keeps it.
+        required: true,
+        text: (context) => {
+            const session = assembledSession(context);
+            if (session === undefined)
+                return '';
+            const view = read(session);
+            const fallback = defaultMode();
+            try {
+                seedSession(session, view, fallback);
+            }
+            catch (error) {
+                ctx.logger.warn('could not record the default answer mode: %s', error);
+            }
+            return answerContextText(view, fallback, texts);
+        },
+    });
+}

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/limits.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bounds of the `ui-*` answer components. The prompt states them to the model and the parser enforces
+ * them, so both read these constants. The values follow VulcanCode's
+ * `crates/vulcan-session-core/src/v1/answer_components.rs`.
+ */
+/** Most data rows one component (or one tabs/columns fence) may hold. */
+export declare const ANSWER_COMPONENT_MAX_ROWS = 128;
+/** Most series one `ui-chart` may draw. */
+export declare const ANSWER_CHART_MAX_SERIES = 8;

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/limits.js

@@ -0,0 +1,9 @@
+/**
+ * Bounds of the `ui-*` answer components. The prompt states them to the model and the parser enforces
+ * them, so both read these constants. The values follow VulcanCode's
+ * `crates/vulcan-session-core/src/v1/answer_components.rs`.
+ */
+/** Most data rows one component (or one tabs/columns fence) may hold. */
+export const ANSWER_COMPONENT_MAX_ROWS = 128;
+/** Most series one `ui-chart` may draw. */
+export const ANSWER_CHART_MAX_SERIES = 8;

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/prompt.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The model-facing answer mode instructions. Both texts are English package assets; the interactive one
+ * names the component limits as `{{max_rows}}` and `{{max_series}}`, which are substituted here from
+ * the parser's own constants, so the context is registered with interpolation off.
+ */
+import { type AnswerMode, type AnswerSessionView } from './session-state.js';
+/** The two instruction texts a session can receive. */
+export interface AnswerModeTexts {
+    /** The component guide, sent while a session is interactive. */
+    readonly interactive: string;
+    /** The stop note, sent once a session that was interactive turns standard. */
+    readonly standard: string;
+}
+/** Replace every `{{name}}` with its value; a placeholder without a value is a packaging error. */
+export declare function substituteLimits(template: string, values: Readonly<Record<string, string>>): string;
+/** Read and fill the packaged instruction texts. */
+export declare function loadAnswerModeTexts(): AnswerModeTexts;
+/**
+ * The context one session receives: the guide while interactive, the stop note once an interactive
+ * session turned standard, and nothing for subagents or sessions that were never interactive.
+ */
+export declare function answerContextText(view: AnswerSessionView, defaultMode: AnswerMode, texts: AnswerModeTexts): string;

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/prompt.js

@@ -0,0 +1,39 @@
+/**
+ * The model-facing answer mode instructions. Both texts are English package assets; the interactive one
+ * names the component limits as `{{max_rows}}` and `{{max_series}}`, which are substituted here from
+ * the parser's own constants, so the context is registered with interpolation off.
+ */
+import { readFileSync } from 'node:fs';
+import { ANSWER_CHART_MAX_SERIES, ANSWER_COMPONENT_MAX_ROWS } from './limits.js';
+import { effectiveMode } from './session-state.js';
+/** Replace every `{{name}}` with its value; a placeholder without a value is a packaging error. */
+export function substituteLimits(template, values) {
+    return template.replace(/\{\{(\w+)\}\}/gu, (_whole, key) => {
+        const value = values[key];
+        if (value === undefined)
+            throw new Error(`answer mode prompt: no value for {{${key}}}`);
+        return value;
+    });
+}
+/** Read and fill the packaged instruction texts. */
+export function loadAnswerModeTexts() {
+    const read = (file) => readFileSync(new URL(`../assets/prompts/${file}`, import.meta.url), 'utf8').trim();
+    return Object.freeze({
+        interactive: substituteLimits(read('answer-mode-interactive.md'), {
+            max_rows: String(ANSWER_COMPONENT_MAX_ROWS),
+            max_series: String(ANSWER_CHART_MAX_SERIES),
+        }),
+        standard: read('answer-mode-standard.md'),
+    });
+}
+/**
+ * The context one session receives: the guide while interactive, the stop note once an interactive
+ * session turned standard, and nothing for subagents or sessions that were never interactive.
+ */
+export function answerContextText(view, defaultMode, texts) {
+    if (view.subagent)
+        return '';
+    if (effectiveMode(view, defaultMode) === 'interactive')
+        return texts.interactive;
+    return view.everInteractive ? texts.standard : '';
+}

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/reply-format.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The summary of the reader's `ui-decision` answers that the view puts into the composer; the
+ * interactive guide describes this shape to the model.
+ */
+/** One answered decision. */
+export interface DecisionReply {
+    readonly question: string;
+    readonly picks: readonly string[];
+    /** Option labels the answer recommended. */
+    readonly recommended: readonly string[];
+    readonly note: string;
+}
+/** Interface-language words the summary uses. */
+export interface ReplyLabels {
+    readonly decisions: string;
+    readonly recommended: string;
+    readonly noChoice: string;
+}
+/** Summarize decisions as Markdown: `question → picks`, a recommended pick labelled, notes quoted. */
+export declare function formatDecisionReply(entries: readonly DecisionReply[], labels: ReplyLabels): string;

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/reply-format.js

@@ -0,0 +1,17 @@
+/**
+ * The summary of the reader's `ui-decision` answers that the view puts into the composer; the
+ * interactive guide describes this shape to the model.
+ */
+/** Summarize decisions as Markdown: `question → picks`, a recommended pick labelled, notes quoted. */
+export function formatDecisionReply(entries, labels) {
+    if (entries.length === 0)
+        return '';
+    const quote = (note) => note.trim() ? note.trim().split(/\r?\n/u).map((line) => `  > ${line}`.trimEnd()) : [];
+    const lines = entries.flatMap((entry) => [
+        `- ${entry.question} → ${entry.picks.length > 0
+            ? entry.picks.map((pick) => entry.recommended.includes(pick) ? `${pick} (${labels.recommended})` : pick).join(', ')
+            : labels.noChoice}`,
+        ...quote(entry.note),
+    ]);
+    return [`**${labels.decisions}**`, ...lines].join('\n');
+}

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/session-state.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Per-session answer mode. The mode lives in the session's own log as plugin records, so it follows
+ * the session through restarts, forks and resumes; a session projection folds it and serves it to the
+ * composer pill, and one slash command is the only user write path. The plugin's configured default
+ * only seeds a session that has no record yet, at its first prompt assembly; subagent sessions are
+ * always standard and never get a record.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type Session, type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session';
+/** How the model answers in one session. */
+export type AnswerMode = 'standard' | 'interactive';
+/** Package name, the command definition id. */
+export declare const PACKAGE_NAME = "@openvulcan/dsh-vulcan-answers";
+/** Record type of one mode switch. */
+export declare const MODE_RECORD = "plugin:vulcan-answers/mode";
+/** Projection key the client reads; also restated in `client/shared.ts`. */
+export declare const PROJECTION_KEY = "vulcanAnswers";
+/** Slash command that switches the mode; also restated in `client/shared.ts`. */
+export declare const MODE_COMMAND = "vulcan-answer-mode";
+/** One mode switch, as logged. */
+export interface ModeRecord {
+    readonly mode: AnswerMode;
+}
+/** What the session projection holds and serves. */
+export interface AnswerSessionView {
+    /** The recorded mode; null until the session is seeded or switched. */
+    readonly mode: AnswerMode | null;
+    /** Whether any record ever set interactive, so a later standard mode needs the stop note. */
+    readonly everInteractive: boolean;
+    /** A subagent session, which always answers in standard mode. */
+    readonly subagent: boolean;
+}
+declare module '@deepseek-ai/dsh-session/types' {
+    interface PluginRecordMap {
+        /** The session's answer mode; the latest record wins. */
+        'plugin:vulcan-answers/mode': ModeRecord;
+    }
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionMap {
+        /** Vulcan Answers' per-session mode for the composer pill. */
+        vulcanAnswers: AnswerSessionView;
+    }
+}
+/** Whether a value is an answer mode. */
+export declare function isAnswerMode(value: unknown): value is AnswerMode;
+/** Whether a session header describes a subagent child. */
+export declare function isSubagentHeader(header: Pick<SessionHeader, 'origin' | 'delegationDepth'>): boolean;
+/** The state a session starts from. */
+export declare function initialView(header: Pick<SessionHeader, 'origin' | 'delegationDepth'>): AnswerSessionView;
+/** The mode a session answers in now: subagents are standard, an unseeded session follows the default. */
+export declare function effectiveMode(view: AnswerSessionView, defaultMode: AnswerMode): AnswerMode;
+/**
+ * Fold one event into the state. Records are validated because a restored record carries whatever an
+ * earlier build wrote; one that does not parse leaves the state unchanged.
+ */
+export declare function applySessionRecord(state: AnswerSessionView, event: SessionEvent): AnswerSessionView;
+/** Reader of a session's mode state. */
+export type ReadAnswerState = (session: Session) => AnswerSessionView;
+/** Register the projection and the command; resolves to the state reader. */
+export declare function installSessionState(ctx: Context, defaultMode: () => AnswerMode): Promise<ReadAnswerState>;
+/**
+ * Give an unseeded top-level session the configured default as its own record, so a later change of
+ * the default does not move it. Called while its prompt is assembled.
+ */
+export declare function seedSession(session: Session, view: AnswerSessionView, defaultMode: AnswerMode): void;

package/node_modules/@openvulcan/dsh-vulcan-answers/lib/session-state.js

@@ -0,0 +1,118 @@
+/**
+ * Per-session answer mode. The mode lives in the session's own log as plugin records, so it follows
+ * the session through restarts, forks and resumes; a session projection folds it and serves it to the
+ * composer pill, and one slash command is the only user write path. The plugin's configured default
+ * only seeds a session that has no record yet, at its first prompt assembly; subagent sessions are
+ * always standard and never get a record.
+ */
+import { CommandDefinitionId } from '@deepseek-ai/dsh-commands/brand';
+import { appendPluginRecord, pluginRecordOf } from '@deepseek-ai/dsh-session';
+/** Package name, the command definition id. */
+export const PACKAGE_NAME = '@openvulcan/dsh-vulcan-answers';
+/** Record type of one mode switch. */
+export const MODE_RECORD = 'plugin:vulcan-answers/mode';
+/** Projection key the client reads; also restated in `client/shared.ts`. */
+export const PROJECTION_KEY = 'vulcanAnswers';
+/** Slash command that switches the mode; also restated in `client/shared.ts`. */
+export const MODE_COMMAND = 'vulcan-answer-mode';
+/** Whether a value is an answer mode. */
+export function isAnswerMode(value) {
+    return value === 'standard' || value === 'interactive';
+}
+/** Whether a session header describes a subagent child. */
+export function isSubagentHeader(header) {
+    return header.origin === 'subagent' || (header.delegationDepth ?? 0) > 0;
+}
+/** The state a session starts from. */
+export function initialView(header) {
+    return Object.freeze({ mode: null, everInteractive: false, subagent: isSubagentHeader(header) });
+}
+/** The mode a session answers in now: subagents are standard, an unseeded session follows the default. */
+export function effectiveMode(view, defaultMode) {
+    return view.subagent ? 'standard' : view.mode ?? defaultMode;
+}
+/**
+ * Validator of the state and the wire view. dsh only calls `parse`; a hand-written one keeps this
+ * package off dsh's zod version, whose schema type the definition names.
+ */
+const viewSchema = {
+    parse(value) {
+        const view = value;
+        if (typeof view === 'object' && view !== null && (view.mode === null || isAnswerMode(view.mode))
+            && typeof view.everInteractive === 'boolean' && typeof view.subagent === 'boolean') {
+            return Object.freeze({ mode: view.mode, everInteractive: view.everInteractive, subagent: view.subagent });
+        }
+        throw new TypeError('vulcanAnswers projection: expected { mode: "standard" | "interactive" | null, everInteractive: boolean, subagent: boolean }');
+    },
+};
+/**
+ * Fold one event into the state. Records are validated because a restored record carries whatever an
+ * earlier build wrote; one that does not parse leaves the state unchanged.
+ */
+export function applySessionRecord(state, event) {
+    const record = pluginRecordOf(event);
+    if (record === undefined || record.type !== MODE_RECORD)
+        return state;
+    const data = record.data;
+    if (typeof data !== 'object' || data === null)
+        return state;
+    const mode = data['mode'];
+    if (!isAnswerMode(mode))
+        return state;
+    const everInteractive = state.everInteractive || mode === 'interactive';
+    return mode === state.mode && everInteractive === state.everInteractive ? state : Object.freeze({ ...state, mode, everInteractive });
+}
+/**
+ * Whether an awaited registration is a dsh 0.2.2 handle. dsh 0.2.1 registers synchronously and
+ * awaiting its disposer yields a function; both are inside `engines.dsh`.
+ */
+function isHandle(value) {
+    return typeof value === 'object' && value !== null && typeof value.stateOf === 'function';
+}
+/** Register the projection and the command; resolves to the state reader. */
+export async function installSessionState(ctx, defaultMode) {
+    const projections = ctx.sessionProjections;
+    const registered = await projections.register({
+        key: PROJECTION_KEY,
+        stateVersion: 1,
+        stateSchema: viewSchema,
+        init: header => initialView(header),
+        apply: applySessionRecord,
+        wire: { viewSchema, view: state => state },
+    });
+    const read = isHandle(registered)
+        ? session => registered.stateOf(session)
+        // dsh 0.2.1 serves states by key only.
+        : session => projections.stateOf(session, PROJECTION_KEY) ?? initialView(session.header);
+    ctx.inject(['commands'], (child) => {
+        child.commands.register({
+            definitionId: CommandDefinitionId(PACKAGE_NAME),
+            name: MODE_COMMAND,
+            description: 'Switch this session\'s answer mode between interactive ui-* components and standard Markdown, from the next request',
+            input: { hint: 'interactive | standard' },
+            handler: ({ agent, rawInput }) => {
+                const word = rawInput.trim().toLowerCase();
+                const view = read(agent.session);
+                if (word === '')
+                    return { kind: 'success', text: `answer mode ${effectiveMode(view, defaultMode())}` };
+                if (!isAnswerMode(word))
+                    return { kind: 'error', text: `expected "interactive" or "standard", got "${word}"` };
+                if (view.subagent)
+                    return { kind: 'error', text: 'subagent sessions always answer in standard mode' };
+                if (view.mode !== word)
+                    appendPluginRecord(agent.session, MODE_RECORD, { mode: word });
+                return { kind: 'success', text: `answer mode ${word} from the next request` };
+            },
+        });
+    });
+    return read;
+}
+/**
+ * Give an unseeded top-level session the configured default as its own record, so a later change of
+ * the default does not move it. Called while its prompt is assembled.
+ */
+export function seedSession(session, view, defaultMode) {
+    if (view.subagent || view.mode !== null)
+        return;
+    appendPluginRecord(session, MODE_RECORD, { mode: defaultMode });
+}

package/node_modules/@openvulcan/dsh-vulcan-answers/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@openvulcan/dsh-vulcan-answers",
+  "version": "0.4.0",
+  "description": "Interactive answers for DeepSeek Harness: the model answers with VulcanCode ui-* components, rendered in the chat.",
+  "license": "MIT",
+  "icon": "./assets/answers-icon.png",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OpenVulcan/dsh-vulcancode.git",
+    "directory": "packages/dsh-vulcan-answers"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "!lib/**/*.test.*",
+    "assets"
+  ],
+  "engines": {
+    "dsh": ">=0.2.1-rc.2 <0.3.0"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-plugin-manager",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-settings-general"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.5",
+    "@deepseek-ai/dsh-commands": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-settings": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.1-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/@openvulcan/dsh-vulcan-luaskills/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenVulcan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@openvulcan/dsh-vulcan-luaskills/assets/luaskills-icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128.00000000 128.00000000" role="img" aria-label="LuaSkills"><title>LuaSkills — S1 contour R1 review candidate</title><desc>Review only. S1 body paths cleaned from v1.3. Dot path, position, color, transform and viewBox preserved. No changes to approved R2 wordmark. Not a new symbol design.</desc><rect id="container" x="0" y="0" width="128" height="128" rx="25.6" fill="#171C19" /><g transform="translate(19.35319915 15.36000000) scale(0.97280000)"><path id="symbol-body" d="M0.55 15.15827411L16.06973315 15.15827411C16.37348976 15.15827411 16.61973315 15.4045175 16.61973315 15.70827411L16.61973315 71.42867C16.61973315 78.8210647 22.08745984 83.32897 29.25 83.32897L75.24 83.32897C76.32047899 83.32897 77.38716 82.19985495 77.38716 81.1C77.38716 79.41897344 75.35246626 78.40112849 73.94 78.024C64.91344556 75.61390996 54.25899415 73.39323287 45.62 70.24C37.73317733 67.36130973 33.79 63.35695518 33.79 54.65C33.79 43.42129198 41.73989153 37.40335277 52.48 37.40335277L88.01407376 37.40335277C88.31783038 37.40335277 88.56407376 37.64959615 88.56407376 37.95335277L88.56407376 50.75C88.56407376 51.05375661 88.31783038 51.3 88.01407376 51.3L53 51.3C51.93161066 51.3 50.1 53.38543719 50.1 54.75C50.1 56.91 52.96532212 57.68052101 54.66 58.133C62.73280917 60.28844005 71.10844405 62.24534877 79.09 64.56C89.55856733 67.59588453 91.79029781 72.79443208 91.79029781 83.5C91.79029781 91.86377052 86.82564748 100 77.68 100L28.55 100C12.18383487 100 0 89.51226091 0 72.7L0 15.70827411C0 15.4045175 0.24624339 15.15827411 0.55 15.15827411Z" fill="#D0D0CA" fill-rule="evenodd" /><path id="symbol-dot" d="M91.70974964838106 9.341838685937416C91.70974964838106 14.501193727559992 87.68762759278803 18.683677371874833 82.72608859579702 18.683677371874833C77.76454959880601 18.683677371874833 73.74242754321298 14.501193727559992 73.74242754321298 9.341838685937416C73.74242754321298 4.182483644314841 77.76454959880601 0.0 82.72608859579702 0.0C87.68762759278803 0.0 91.70974964838106 4.182483644314841 91.70974964838106 9.341838685937416Z" fill="#7358D6" fill-rule="evenodd" /></g></svg>