@stackstackstack/dsh-agent-instructions 0.1.5

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@stackstackstack/dsh-agent-instructions`.
+* @module @stackstackstack/dsh-agent-instructions/invariant
+*/
+const PACKAGE_NAME = "@stackstackstack/dsh-agent-instructions";
+/** Cordis companion plugin name. */
+const name = "workspace-context-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: replay intentionally tolerates unknown or malformed workspace sources,
+* while focused pipeline tests own its private pending/cache state transitions.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/config.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Configuration normalization for workspace instruction discovery and rendering.
+ *
+ * @module @stackstackstack/dsh-agent-instructions/config
+ */
+import z from '@deepseek-ai/schemastery';
+/** User-facing workspace instruction loader configuration. */
+export interface Config {
+    /** Harness home containing the fixed user-global `AGENTS.md`; defaults to `$DSH_HOME` or `~/.dsh`. */
+    dshHome?: string;
+    /** Directory entries that identify the project root while walking upward from the session cwd. */
+    projectRootMarkers?: string[];
+    /** UTF-8 byte cap for one rendered baseline or dynamic batch; non-positive or non-finite disables loading. */
+    maxBytes: number;
+    /** Maximum UTF-8 bytes read from one instruction file; larger files are ignored. */
+    maxSourceBytes?: number;
+    /** Maximum UTF-8 bytes read across one baseline or dynamic reconciliation batch. */
+    maxTotalSourceBytes?: number;
+    /**
+     * Ordered same-directory project candidates; every existing file loads, with
+     * per-directory trimmed-content duplicates collapsed to the earliest candidate.
+     */
+    instructionFileCandidates?: string[];
+    /**
+     * Ordered same-directory local-overlay candidates loaded after the base files
+     * under the same per-directory trimmed-content dedup; empty disables the overlay.
+     */
+    localInstructionFileCandidates?: string[];
+}
+export declare const Config: z<Config>;
+/** Normalized instruction discovery configuration. */
+export interface ResolvedDiscoveryConfig {
+    dshHome: string;
+    projectRootMarkers: string[];
+    instructionFileCandidates: string[];
+    localInstructionFileCandidates: string[];
+}
+/** Normalized configuration used by discovery and reconciliation. */
+export interface ResolvedConfig extends ResolvedDiscoveryConfig {
+    maxBytes: number;
+    maxSourceBytes: number;
+    maxTotalSourceBytes: number;
+}
+/**
+ * Identify the discovery, precedence, and budget semantics of one baseline.
+ * @param config - normalized plugin configuration.
+ * @param cwd - absolute session working directory.
+ * @param projectRoot - project root selected for the current baseline.
+ * @returns stable serialized identity for compatibility checks on resume.
+ */
+export declare function workspaceBaselineIdentity(config: ResolvedConfig, cwd: string, projectRoot: string): string;
+/**
+ * Resolve defaults, the harness home, and valid same-directory candidates.
+ * @param config - user-facing plugin configuration.
+ * @returns normalized runtime configuration.
+ */
+export declare function resolveConfig(config: Config): ResolvedConfig;
+/**
+ * Resolve the subset of configuration used before instruction content is rendered.
+ * @param config - optional discovery controls.
+ * @returns normalized home, root markers, and instruction candidates.
+ */
+export declare function resolveDiscoveryConfig(config: Pick<Config, 'dshHome' | 'projectRootMarkers' | 'instructionFileCandidates' | 'localInstructionFileCandidates'>): ResolvedDiscoveryConfig;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/digest.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Content identity for workspace instruction duplicate suppression.
+ *
+ * @module @stackstackstack/dsh-agent-instructions/digest
+ */
+/**
+ * Compute the content identity used across instruction loading and session state.
+ * @param content - exact UTF-8 instruction text.
+ * @returns lowercase SHA-1 digest in hexadecimal form.
+ */
+export declare function instructionContentSha1(content: string): string;
+/**
+ * Compute the whitespace-insensitive identity used for per-directory duplicate
+ * suppression. Leading and trailing whitespace is trimmed before hashing so a
+ * symlinked or byte-copied sibling that differs only by surrounding whitespace
+ * still collapses to a single rendered file.
+ * @param content - exact UTF-8 instruction text.
+ * @returns SHA-1 digest of the trimmed content.
+ */
+export declare function trimmedInstructionDigest(content: string): string;
+//# sourceMappingURL=digest.d.ts.map

package/lib/types/files.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Instruction-file discovery and bounded, abort-aware provider reads.
+ *
+ * @module @stackstackstack/dsh-agent-instructions/files
+ */
+import type { FileSystem, FsTarget, FsVersion } from '@stackstackstack/dsh-fs';
+import { type ResolvedConfig } from './config.ts';
+import { type RenderedWorkspaceContext } from './render.ts';
+/** An instruction candidate identified by absolute and model-facing paths. */
+export interface InstructionFile {
+    absolutePath: string;
+    displayPath: string;
+}
+/** An instruction file whose UTF-8 content was read successfully. */
+export interface LoadedInstructionFile extends InstructionFile {
+    content: string;
+    /** Provider freshness token when the file was loaded through `ctx.fs`. */
+    version?: FsVersion;
+}
+/** Provider metadata for a probed scope candidate before its content is read. */
+export interface ProbedInstructionFile extends InstructionFile {
+    target: FsTarget;
+    version: FsVersion;
+    size?: number;
+}
+interface DiscoverOptions {
+    cwd: string;
+    dshHome?: string;
+    projectRootMarkers?: string[];
+    instructionFileCandidates?: string[];
+    localInstructionFileCandidates?: string[];
+    projectRoot?: string;
+    signal?: AbortSignal;
+}
+interface LoadOptions extends DiscoverOptions {
+    maxBytes: number;
+    maxSourceBytes?: number;
+    maxTotalSourceBytes?: number;
+    replacePreviousBaseline?: boolean;
+}
+/** Aggregate UTF-8 source budget shared by one complete load batch. */
+export interface SourceByteBudget {
+    readonly maxBytes: number;
+    usedBytes: number;
+}
+/** Rendered baseline plus the successfully read and byte-budget-retained files. */
+export interface RenderedInstructionSet {
+    rendered: RenderedWorkspaceContext;
+    /** Successfully read candidates before content deduplication and byte budgeting. */
+    observed: LoadedInstructionFile[];
+    /** Candidates retained by content deduplication and byte budgeting. */
+    included: LoadedInstructionFile[];
+}
+/** Tri-state scope probe that distinguishes confirmed absence from provider failure. */
+export type ScopeInstructionProbe = {
+    kind: 'present';
+    file: ProbedInstructionFile;
+} | {
+    kind: 'absent';
+} | {
+    kind: 'unavailable';
+};
+/**
+ * Walk upward to the first directory containing a configured root marker.
+ * @param cwd - absolute session working directory where the walk begins.
+ * @param markers - child names that identify a project root.
+ * @param fileSystem - optional provider used instead of host filesystem probes.
+ * @param signal - cancellation for provider and host probes.
+ * @returns the discovered project root, or `cwd` when no marker exists.
+ */
+export declare function findProjectRoot(cwd: string, markers: readonly string[], fileSystem?: FileSystem, signal?: AbortSignal): Promise<string>;
+/**
+ * Build the inclusive root-to-cwd directory chain.
+ * @param root - root directory expected to contain or equal `cwd`.
+ * @param cwd - most-specific directory in the chain.
+ * @returns directories ordered from broadest to most specific.
+ */
+export declare function ancestorChain(root: string, cwd: string): string[];
+/**
+ * Find descendant directories crossed between a cwd and a touched file.
+ * @param root - session cwd that bounds nested discovery.
+ * @param touchedPath - absolute path or path relative to `root`.
+ * @returns descendant directories from shallowest through the touched file's parent.
+ */
+export declare function descendantDirsBetween(root: string, touchedPath: string): string[];
+/**
+ * Convert an absolute instruction path to its project-root-relative display form.
+ * @param root - project root used as the display base.
+ * @param path - absolute path to display.
+ * @returns the root-relative path.
+ */
+export declare function relativeDisplay(root: string, path: string): string;
+/**
+ * Discover host-visible user-global and root-to-cwd instruction candidates.
+ * All present candidates in each directory are returned; trimmed-content
+ * duplicates are collapsed later, once content is read.
+ * @param options - cwd, home, root marker, and candidate configuration.
+ * @returns path-deduplicated instruction candidates in model precedence order.
+ */
+export declare function discoverBaselineInstructionFiles(options: DiscoverOptions): Promise<InstructionFile[]>;
+/**
+ * Drop later candidates whose trimmed content duplicates an earlier sibling in
+ * the same directory. Different directories never collapse even when identical;
+ * within one directory the earliest candidate in discovery order is kept and its
+ * original bytes are rendered. A candidate that symlinks a sibling resolves to
+ * the same content and collapses here like any byte-identical real file.
+ * @param files - loaded files in discovery order.
+ * @returns the retained files in the same order.
+ */
+export declare function dedupInstructionFilesByDirectory(files: LoadedInstructionFile[]): LoadedInstructionFile[];
+/**
+ * Discover, read, and render the baseline instruction chain.
+ * @param options - discovery, source-size, byte-budget, and cancellation configuration.
+ * @param fileSystem - optional provider used instead of host filesystem reads.
+ * @returns rendered baseline context, or undefined when nothing can be loaded.
+ */
+export declare function loadBaselineInstructions(options: LoadOptions, fileSystem?: FileSystem): Promise<RenderedWorkspaceContext | undefined>;
+/**
+ * Load a baseline together with the files retained after rendering.
+ * @param options - discovery, source-size, byte-budget, and cancellation configuration.
+ * @param fileSystem - optional provider used instead of host filesystem reads.
+ * @returns rendered context and retained files, an explicit empty replacement set, or undefined when empty or disabled.
+ */
+export declare function loadBaselineInstructionSet(options: LoadOptions, fileSystem?: FileSystem): Promise<RenderedInstructionSet | undefined>;
+/**
+ * Probe the current provider metadata for one per-candidate instruction scope.
+ * @param scope - a {@link candidateScopeKey} identifying a directory and candidate file.
+ * @param projectRoot - project root used to resolve and display project scopes.
+ * @param resolved - normalized plugin configuration.
+ * @param fileSystem - provider used to resolve and stat scope candidates.
+ * @param signal - cancellation for provider probes.
+ * @returns present metadata, confirmed absence, or temporary unavailability.
+ */
+export declare function probeScopeInstruction(scope: string, projectRoot: string, resolved: ResolvedConfig, fileSystem: FileSystem, signal?: AbortSignal): Promise<ScopeInstructionProbe>;
+/**
+ * Read one already-probed scope candidate under the configured source cap.
+ * @param file - winning provider candidate and its metadata snapshot.
+ * @param maxSourceBytes - maximum UTF-8 bytes accepted from the source.
+ * @param sourceBudget - aggregate UTF-8 byte budget for the current batch.
+ * @param fileSystem - provider used for the streaming read.
+ * @param signal - cancellation for provider streaming.
+ * @returns loaded content with the probed version, or undefined when unavailable.
+ */
+export declare function readScopeInstruction(file: ProbedInstructionFile, maxSourceBytes: number, sourceBudget: SourceByteBudget, fileSystem: FileSystem, signal?: AbortSignal): Promise<LoadedInstructionFile | undefined>;
+export {};
+//# sourceMappingURL=files.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Workspace instruction loader for AGENTS.md-compatible files.
+ *
+ * Baseline instructions enter durable context before the first request; successful fs
+ * tool touches project nested, changed, and removed instructions into the inbox.
+ * Plugin lifecycle reads use the optional `ctx.fs` provider, so providerless products
+ * mount it as a no-op.
+ *
+ * @module @stackstackstack/dsh-agent-instructions
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { Config } from './config.ts';
+import { name } from './state.ts';
+export { Config, name };
+export { discoverBaselineInstructionFiles, loadBaselineInstructions, } from './files.ts';
+export type { InstructionFile, LoadedInstructionFile, } from './files.ts';
+export { renderWorkspaceContext } from './render.ts';
+export type { RenderedWorkspaceContext, TruncatedInstruction } from './render.ts';
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@stackstackstack/dsh-agent-instructions`.
+ * @module @stackstackstack/dsh-agent-instructions/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "workspace-context-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/render.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Model-facing workspace instruction rendering within an explicit byte budget.
+ *
+ * @module @stackstackstack/dsh-agent-instructions/render
+ */
+import type { InstructionFile, LoadedInstructionFile } from './files.ts';
+/** Byte-accounting record for one truncated instruction file. */
+export interface TruncatedInstruction {
+    displayPath: string;
+    originalBytes: number;
+    includedBytes: number;
+}
+/** Model-facing text plus omitted and truncated source records. */
+export interface RenderedWorkspaceContext {
+    text: string;
+    omitted: InstructionFile[];
+    truncated: TruncatedInstruction[];
+}
+/** Structured dynamic state persisted outside model-visible prompt prose. */
+export interface AgentInstructionChange {
+    action: 'set' | 'replace' | 'remove';
+    scope: string;
+    path: string;
+    digest?: string;
+}
+/** One state transition paired with the content used to render it. */
+export interface ChangeRenderItem {
+    change: AgentInstructionChange;
+    file: LoadedInstructionFile;
+}
+/** Directory component that identifies the single user-global instruction scope. */
+export declare const USER_GLOBAL_DIRECTORY = "user-global";
+/**
+ * File name of the single user-global instruction file under `$DSH_HOME`.
+ * Discovery (`$DSH_HOME/<name>`) and reconciliation (the user-global scope key's
+ * candidate component) both key on this name, so it lives in one place: were the
+ * two to disagree, the user-global instruction would load but never reconcile.
+ */
+export declare const USER_GLOBAL_FILE = "AGENTS.md";
+/**
+ * Derive the logical instruction scope from a model-facing path.
+ * @param displayPath - project-relative or user-global instruction path.
+ * @returns `user-global`, `.`, or the containing project-relative directory.
+ */
+export declare function scopeForDisplayPath(displayPath: string): string;
+/**
+ * Compose the reconciliation key for one instruction candidate file.
+ * Each loaded candidate is tracked independently, so the key pairs the logical
+ * directory with the exact candidate file name behind a NUL separator that no
+ * directory path or file name can contain. Distinct candidates in one directory
+ * (`AGENTS.md` vs `CLAUDE.md`, a base file vs its `.local` overlay) therefore
+ * never collide in the scope-keyed state maps.
+ * @param directory - `user-global`, `.`, or a project-relative directory.
+ * @param candidateName - instruction file name within that directory.
+ * @returns the per-candidate logical scope key.
+ */
+export declare function candidateScopeKey(directory: string, candidateName: string): string;
+/**
+ * Derive the per-candidate scope key for a loaded instruction file.
+ * @param displayPath - project-relative or user-global instruction path.
+ * @returns the scope key pairing the file's directory with its name.
+ */
+export declare function instructionScopeKey(displayPath: string): string;
+/**
+ * Recover the directory and candidate name that {@link candidateScopeKey} encoded.
+ * @param scope - a per-candidate scope key.
+ * @returns the directory scope and the candidate file name within it.
+ */
+export declare function decodeScopeKey(scope: string): {
+    directory: string;
+    candidateName: string;
+};
+/**
+ * Render one reconciliation batch and retain only transitions that fit.
+ * @param items - ordered state transitions and current file contents.
+ * @param maxBytes - maximum UTF-8 bytes allowed in the rendered batch.
+ * @returns bounded prompt text and the transitions actually represented by it.
+ */
+export declare function renderInstructionChanges(items: ChangeRenderItem[], maxBytes: number): {
+    text: string;
+    changes: AgentInstructionChange[];
+};
+/**
+ * Render a baseline together with the exact source files semantically represented in it.
+ * @param files - loaded files ordered from broadest to most specific.
+ * @param options - rendering byte budget and whether this baseline supersedes a visible predecessor.
+ * @returns bounded public rendering plus files with surviving content, including genuinely empty files.
+ * @internal
+ */
+export declare function renderWorkspaceInstructionSet(files: LoadedInstructionFile[], options: {
+    maxBytes: number;
+    replacePreviousBaseline?: boolean;
+}): {
+    rendered: RenderedWorkspaceContext;
+    included: LoadedInstructionFile[];
+};
+/**
+ * Render the baseline instruction chain with deterministic precedence budgeting.
+ * @param files - loaded files ordered from broadest to most specific.
+ * @param options - rendering byte budget and whether this baseline supersedes a visible predecessor.
+ * @returns bounded baseline prompt text and budget diagnostics.
+ */
+export declare function renderWorkspaceContext(files: LoadedInstructionFile[], options: {
+    maxBytes: number;
+    replacePreviousBaseline?: boolean;
+}): RenderedWorkspaceContext;
+//# sourceMappingURL=render.d.ts.map

package/lib/types/state.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Session-visible workspace instruction state and dynamic reconciliation.
+ *
+ * @module @stackstackstack/dsh-agent-instructions/state
+ */
+import type { Agent } from '@stackstackstack/dsh-agent';
+import type { Message } from '@stackstackstack/dsh-llm';
+import type { Session, UserMessage } from '@stackstackstack/dsh-session';
+import type { FileSystem, FsVersion } from '@stackstackstack/dsh-fs';
+import type { ResolvedConfig } from './config.ts';
+import { type LoadedInstructionFile } from './files.ts';
+import { type AgentInstructionChange } from './render.ts';
+export declare const name = "agent-instructions";
+/** Durable producer, file, and reconciliation facts for one workspace context. */
+export interface AgentInstructionSource {
+    kind: 'agent-instructions';
+    /** Every workspace context carries instructions read out of a file (the `instructions` context form). */
+    form: 'instructions';
+    /** Marks the complete startup/resume baseline rather than a later delta. */
+    baseline?: true;
+    /** Discovery, precedence, and budget identity used to validate a resumed baseline. */
+    baselineIdentity?: string;
+    changes: AgentInstructionChange[];
+}
+declare module '@stackstackstack/dsh-llm' {
+    interface MessageSourceMap {
+        'agent-instructions': AgentInstructionSource;
+    }
+}
+/** Per-scope metadata cache; instruction prose is deliberately not retained. */
+export interface InstructionVersionState {
+    path: string;
+    version: FsVersion;
+    digest: string;
+    /**
+     * Trimmed-content identity ({@link trimmedInstructionDigest}) used to suppress
+     * per-directory duplicates on the metadata fast path without re-reading a sibling.
+     */
+    trimmedDigest: string;
+}
+/** Session-isolated fast-path state keyed by logical instruction scope. */
+export type InstructionVersionCache = WeakMap<Session, Map<string, InstructionVersionState>>;
+/** A metadata-cache transition associated with one rendered instruction change. */
+export interface InstructionVersionUpdate {
+    change: AgentInstructionChange;
+    state?: InstructionVersionState;
+}
+/** Rendered reconciliation plus its metadata-cache transitions. */
+export interface ReconciledInstructionContext {
+    context: UserMessage;
+    versionUpdates: InstructionVersionUpdate[];
+}
+/**
+ * Build the user-role message for a rendered baseline.
+ * @param text - complete plugin-owned system-reminder text.
+ * @returns a user-role prefix message.
+ */
+export declare function workspaceContextMessage(text: string): Message;
+/**
+ * Convert retained baseline files into comparison and metadata-cache state.
+ * @param files - baseline files that survived rendering.
+ * @returns latest baseline changes and provider versions keyed by logical scope.
+ */
+export declare function baselineInstructionState(files: LoadedInstructionFile[]): {
+    changes: Map<string, AgentInstructionChange>;
+    versions: Map<string, InstructionVersionState>;
+};
+/**
+ * Keep only cache updates represented by rendered changes.
+ * @param updates - proposed updates from one or more reconciliations.
+ * @param renderedChanges - transitions retained by the renderer.
+ * @returns updates represented by an exact retained transition.
+ */
+export declare function retainedInstructionVersionUpdates(updates: readonly InstructionVersionUpdate[], renderedChanges: readonly AgentInstructionChange[]): InstructionVersionUpdate[];
+/**
+ * Apply metadata-cache transitions without retaining instruction prose.
+ * @param session - owning session.
+ * @param updates - ordered set/delete transitions.
+ * @param cache - session-isolated metadata cache.
+ */
+export declare function applyInstructionVersionUpdates(session: Session, updates: readonly InstructionVersionUpdate[], cache: InstructionVersionCache): void;
+/**
+ * Compare visible state with provider-visible files and render transitions.
+ * @param agent - session owner whose visible surface supplies durable state.
+ * @param resolved - normalized plugin configuration.
+ * @param versionCache - per-session scope metadata used to skip unchanged reads.
+ * @param fileSystem - provider used for current file probes.
+ * @param options - authoritative claimed context, pending scope hints, touched paths, and baseline participation.
+ * @returns rendered context plus deferred cache updates, or undefined when unchanged/unavailable.
+ */
+export declare function reconcileInstructionContext(agent: Agent, resolved: ResolvedConfig, versionCache: InstructionVersionCache, fileSystem: FileSystem, options: {
+    authorityMessages: readonly UserMessage[];
+    scopeMessages: readonly UserMessage[];
+    touchedPaths: readonly string[];
+    includeBaselineScopes: boolean;
+    excludedBaselineScopes?: ReadonlySet<string>;
+    projectRoot?: string;
+    signal?: AbortSignal;
+}): Promise<ReconciledInstructionContext | undefined>;
+//# sourceMappingURL=state.d.ts.map

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@stackstackstack/dsh-agent-instructions",
+  "description": "Workspace context loader for AGENTS.md/CLAUDE.md instruction files",
+  "version": "0.1.5",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/context/agent-instructions"
+  },
+  "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"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@stackstackstack/dsh-agent": "^0.1.5",
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-home-paths": "^0.1.5",
+    "@stackstackstack/dsh-llm": "^0.1.5",
+    "@stackstackstack/dsh-tools": "^0.1.5",
+    "@stackstackstack/dsh-fs": "^0.1.5",
+    "@stackstackstack/dsh-session": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.2",
+    "@stackstackstack/dsh-agent": "^0.1.5",
+    "@stackstackstack/dsh-agent-loop": "^0.1.5",
+    "@stackstackstack/dsh-fs": "^0.1.5",
+    "@stackstackstack/dsh-fs-local": "^0.1.5",
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-llm": "^0.1.5",
+    "@stackstackstack/dsh-llm-deepseek": "^0.1.5",
+    "@stackstackstack/dsh-home-paths": "^0.1.5",
+    "@stackstackstack/dsh-session": "^0.1.5",
+    "@stackstackstack/dsh-tools": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@stackstackstack/dsh-system-prompt": "^0.1.5",
+    "@stackstackstack/dsh-tool-fs": "^0.1.5"
+  }
+}