@try-works/dsh-recursive-mode 0.1.0

package/lib/router.d.ts

@@ -0,0 +1,77 @@
+export interface RouterDefaults {
+    when_role_unconfigured: string;
+    when_cli_unavailable: string;
+    when_model_unknown: string;
+    allow_auto_assign_if_single_cli: boolean;
+    probe_timeout_ms: number;
+    invoke_timeout_ms: number;
+}
+export interface RoleRoute {
+    enabled: boolean;
+    mode: string;
+    cli: string | null;
+    model: string | null;
+    fallback: string;
+}
+export interface RouterPolicy {
+    version: number;
+    defaults: RouterDefaults;
+    role_routes: Record<string, RoleRoute>;
+    cli_overrides: Record<string, unknown>;
+    custom_clis: unknown[];
+}
+export type RouteTier = 'native' | 'external-cli' | 'self-audit' | 'local-controller';
+export interface RouteDecision {
+    tier: RouteTier;
+    provider?: string;
+    reason: string;
+}
+export interface SubagentProviderLike {
+    name: string;
+    capabilities?: {
+        outputSchema?: boolean;
+        depthLimit?: boolean;
+        toolFilter?: boolean;
+        persona?: boolean;
+    };
+}
+export interface CapabilityProbe {
+    available: boolean;
+    provider?: string;
+    capabilities?: {
+        outputSchema: boolean;
+        depthLimit: boolean;
+        toolFilter: boolean;
+        persona: boolean;
+    };
+    reason: string;
+}
+/** Parse recursive-router.json. A missing/invalid file yields a default self-audit policy (never throws). */
+export declare function loadRouterPolicy(path?: string): RouterPolicy;
+/** Default router policy path inside a workspace root. */
+export declare function routerPolicyPath(root: string): string;
+/**
+ * Resolve a role to a tier, preferring a native provider whose name maps to
+ * the role (e.g. role 'code-reviewer' -> provider 'code-reviewer' or the
+ * generic spawn/fork provider). External CLIs ride their provider rows; else
+ * the policy fallback.
+ */
+export declare function resolveRole(role: string, policy: RouterPolicy, providers: Record<string, SubagentProviderLike>): RouteDecision;
+/** Probe a single provider and return its advertised capabilities. */
+export declare function probeCapabilities(provider: SubagentProviderLike | undefined): CapabilityProbe;
+/**
+ * Probe the router-relevant capability for a role. No provider -> available
+ * false with a concrete reason (the self-audit fallback trigger).
+ */
+export declare function capabilityProbe(input: {
+    providers: Record<string, SubagentProviderLike>;
+    role: string;
+    policy?: RouterPolicy;
+}): CapabilityProbe;
+/** Render the Delegation Decision Basis prose the phase doc records. */
+export declare function delegationDecisionBasis(input: {
+    role: string;
+    available: boolean;
+    provider?: string;
+    fallback: string;
+}): string;

package/lib/run.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Run discovery for recursive-mode runs.
+ *
+ * Ports the discovery subset of recursive-status.py:
+ * - discoverRuns: list run directories under <repoRoot>/.recursive/run/
+ * - resolveRunDir: explicit run id, or the latest run by mtime (stable sort)
+ *
+ * R1 (run 02): dedicated module so tools and status share one discovery path.
+ */
+export interface RunDiscoveryResult {
+    runDir: string;
+    runId: string;
+}
+/**
+ * List run ids under <repoRoot>/.recursive/run/, excluding non-directories.
+ * Mirrors: runs = [p for p in run_root.iterdir() if p.is_dir()]
+ */
+export declare function discoverRuns(repoRoot: string): string[];
+/**
+ * Resolve the run directory for an explicit run id, or the latest run by mtime.
+ * Mirrors get_latest_run_directory: sort by st_mtime descending, stable sort
+ * (ties preserve discovery order — no name-based tie-break).
+ */
+export declare function resolveRunDir(repoRoot: string, runId?: string): RunDiscoveryResult | null;
+/**
+ * Latest run directory by mtime (descending), stable sort preserving
+ * discovery order for exact ties. Returns null when no runs exist.
+ */
+export declare function getLatestRunDirectory(runRoot: string): string | null;

package/lib/runtime.d.ts

@@ -0,0 +1,241 @@
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { RecursiveStatusResult } from './types.ts';
+import { type WorkspaceRegistryLike } from './workspace.ts';
+import { type ScratchTarget } from './scratch.ts';
+import { type ReviewBundleInput } from './review.ts';
+import { type SubagentProviderLike, type RouteDecision, type CapabilityProbe } from './router.ts';
+import { type SubagentsRuntimeLike, type SubagentStartRequestLike, type SubagentResultLike, type Reference } from './delegation.ts';
+import { type PhaseTransitionIntent, type SessionEventLike, type RecursivePhaseState, type GateCheckResult } from './lifecycle.ts';
+import { type EnforcementConfig, type PreStepGateDecision, type ToolGuardDecision, type ToolExecLike } from './enforcement.ts';
+import { type RecursiveEventLike, type RecursiveFoldState } from './projection.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        recursive: RecursiveRuntime;
+    }
+}
+export interface LockArtifactResult {
+    artifact: string;
+    runId: string;
+    status: string;
+    lockedAt: string | null;
+    lockHash: string | null;
+    receipt?: unknown;
+    blockers: string[];
+}
+export interface LintArtifactResult {
+    artifact: string;
+    runId: string;
+    errors: string[];
+    warnings: string[];
+    passed: boolean;
+}
+export declare class RecursiveRuntime extends Service {
+    /** Recursive-mode runtime service. Owns run-state reads + lock/init/lint operations. */
+    constructor(ctx: Context, config?: {
+        repoRoot?: string;
+        workspaceRegistry?: WorkspaceRegistryLike;
+    });
+    private readonly repoRoot;
+    private readonly workspaceRegistry;
+    private _enforcementConfig;
+    /**
+     * Workspace-scoped control-plane root (R1 binding invariant).
+     * Resolves the session agent's canonical cwd -> workspace path via the
+     * registry; NEVER scans list(). Returns null when unavailable (defer).
+     */
+    resolveWorkspaceRoot(agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null): Promise<string | null>;
+    /**
+     * Run-scoped closeout receipt scaffold (R2), rooted under the given
+     * workspace root. Refuses runIds outside the root (never crosses workspaces).
+     */
+    closeoutRun(root: string, runId: string, phase: string): {
+        error: string;
+    } | {
+        phase: string;
+        file: string;
+        created: string[];
+        existing: string[];
+        closeoutPhase: string;
+        runId: string;
+        error?: undefined;
+    };
+    /**
+     * Run-scoped scratchpad access (R5), rooted under the given workspace root.
+     */
+    scratchRun(root: string, runId: string, action: string, target: ScratchTarget, content?: string): {
+        error: string;
+        runId?: undefined;
+        target?: undefined;
+        action?: undefined;
+        content?: undefined;
+        path?: undefined;
+    } | {
+        runId: string;
+        target: ScratchTarget;
+        action: string;
+        content: string;
+        path: string;
+        error?: undefined;
+    } | {
+        runId: string;
+        target: ScratchTarget;
+        action: string;
+        path: string;
+        error?: undefined;
+        content?: undefined;
+    };
+    /**
+     * Phase B (native delegation): build a review bundle (R1) + file-backed
+     * handoff docs (R2), resolve the role via the router policy (R3), and call
+     * ctx.subagents.start() with the full request (R4). Workspace-scoped: every
+     * path resolves under the session's control-plane root.
+     */
+    delegateReview(input: {
+        root: string;
+        runId: string;
+        phase: string;
+        role: string;
+        delegationId: string;
+        childId: string;
+        artifactPath: string;
+        upstreamArtifacts: string[];
+        auditQuestions: string[];
+        requiredOutput: string;
+        codeRefs?: string[];
+        changedFiles?: string[];
+        diffBasis?: ReviewBundleInput['diffBasis'];
+        policyPath?: string;
+        providers?: Record<string, SubagentProviderLike>;
+        subagents?: SubagentsRuntimeLike;
+        maxDepth?: number;
+        toolFilter?: unknown;
+    }): Promise<{
+        decision: RouteDecision;
+        probe: CapabilityProbe;
+        bundle: import("./review.ts").ReviewBundleResult;
+        handoffPath: string;
+        briefPath: string;
+        replyPath: string;
+        childScratchPath: string;
+        prompt: string;
+        request: SubagentStartRequestLike;
+        result: SubagentResultLike | null;
+        evaluation: {
+            accepted: boolean;
+            reason: string;
+        };
+        actionRecordPath: string;
+        error: string | null;
+    }>;
+    /** R6: validate a child's claimed references against actual files. */
+    validateReferences(root: string, references: Reference[]): import("./delegation.ts").ReferenceCheck;
+    /** R7: probe availability for a role and render the decision basis prose. */
+    probeDelegation(root: string, role: string, providers?: Record<string, SubagentProviderLike>): {
+        decision: RouteDecision;
+        probe: CapabilityProbe;
+        basis: string;
+    };
+    /**
+     * B3: per-call workspace root resolution. The control-plane root is the
+     * session's cwd (or registry-canonicalized), NEVER process.cwd() — the host
+     * checkout is not the run's workspace. Reads resolve under that root only.
+     */
+    resolveRootFor(agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null): Promise<string | null>;
+    /**
+     * Emit a recursive/* event into the session whose control-plane root matches
+     * `root` (additive log-only; the projection drives from these). Falls back to
+     * the agent's session when passed, else the session store list.
+     */
+    private emitToSession;
+    status(runId?: string, agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null): Promise<RecursiveStatusResult | null>;
+    /**
+     * Scaffold a run directory with stub artifact headers (no-op if exists).
+     * Returns the run dir + created artifacts.
+     */
+    initRun(runId: string, agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null): Promise<{
+        runDir: string;
+        runId: string;
+        created: string[];
+        existing: string[];
+    }>;
+    /**
+     * Lock a DRAFT artifact (or reopen a LOCKED one). Validates prerequisites;
+     * writes Status/LockedAt/LockHash + receipt. Returns the lock result.
+     */
+    lockArtifact(runId: string, artifact: string, reopen?: boolean, agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null): Promise<LockArtifactResult>;
+    /** Reopen a LOCKED artifact to DRAFT (delete LockedAt/LockHash, invalidate downstream receipts). */
+    private reopenArtifact;
+    /**
+     * Lint an artifact for phase-specific issues. Minimal structural checks:
+     * gates present, TODO section, Status field, LockHash consistency.
+     */
+    lintArtifact(runId: string, artifact?: string, agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null): Promise<LintArtifactResult>;
+    /** Phase C R1/R2: fold the log into phase state; validate a transition intent. */
+    foldPhase(events: readonly SessionEventLike[]): RecursivePhaseState | null;
+    validateTransition(intent: PhaseTransitionIntent): GateCheckResult;
+    detectTransitionIntent(events: readonly SessionEventLike[]): PhaseTransitionIntent | null;
+    /** Phase C R3: Layer 1 pre-step gate decision (caller of the transition set). */
+    gatePreStep(events: readonly SessionEventLike[], config?: EnforcementConfig): PreStepGateDecision;
+    /** Phase C R4: Layer 2 tool guard decision (caller of the transition set). */
+    guardTool(exec: ToolExecLike, root: string, runId: string, config?: EnforcementConfig): ToolGuardDecision;
+    /** Phase C R8: fs/observed tamper detection. */
+    detectTamper(targetPath: string, root: string, runId: string): {
+        runId: string;
+        path: string;
+        reason: string;
+    } | null;
+    /** Phase C R5: render the current-phase policy contract. */
+    renderPolicy(root: string, runId: string, folded: RecursivePhaseState | null): string;
+    /** Phase C R6: couple a gate-block to the goal service (graceful no-op). */
+    coupleGateBlockToGoal(goalService: unknown, agent: unknown, ref: unknown, reason: {
+        code: string;
+        message: string;
+    }): boolean;
+    /** Phase D R1: append a recursive/* event through the host session adapter (worktree-keyed). */
+    emitRecursiveEvent(session: unknown, type: string, data: Record<string, unknown>): void;
+    /** Phase D R2/R9: fold a session log into the worktree-grouped projection. */
+    foldRecursiveProjection(events: readonly RecursiveEventLike[], workspaceRoot?: string): RecursiveFoldState;
+    /** Phase D R2: the registered projection unit (key 'recursive'). */
+    get projectionUnit(): import("@deepseek-ai/dsh-session-projection").ProjectionDefinition<"recursive", RecursiveFoldState>;
+    /** Phase D R9: whether a worktreeRoot is inside the workspace control-plane root. */
+    isInsideWorkspace(worktreeRoot: string, workspaceRoot: string): boolean;
+    /** Phase C R7: resolve the enforcement config (strict|advisory, default advisory). */
+    get enforcementConfig(): EnforcementConfig;
+    setEnforcementConfig(config: unknown): EnforcementConfig;
+}

package/lib/scratch.d.ts

@@ -0,0 +1,18 @@
+export type ScratchTarget = 'md' | 'ts';
+export declare function scratchPathFor(runDir: string, target: ScratchTarget): string;
+export declare function readScratch(runDir: string, target: ScratchTarget): string;
+export declare function writeScratch(runDir: string, target: ScratchTarget, content: string): string;
+export declare function appendScratch(runDir: string, target: ScratchTarget, content: string): string;
+/**
+ * Child-scoped scratch path (Phase B R5): <run-dir>/scratch/<child-id>.md.
+ * Resolved under the run dir; a child id escaping the scratch dir is rejected.
+ */
+export declare function childScratchPath(runDir: string, childId: string): string;
+/** Read-only access to the PARENT's scratch (the main agent's working memory). */
+export declare function readParentScratch(runDir: string, target?: ScratchTarget): string;
+/**
+ * Write ONLY the child's own scratch file. Refuses any target outside
+ * <run-dir>/scratch/<child-id>.md (a child cannot overwrite the parent's
+ * scratch.md through this writer).
+ */
+export declare function writeChildScratch(runDir: string, childId: string, content: string): string;

package/lib/status.d.ts

@@ -0,0 +1,19 @@
+import type { ArtifactState, PhaseDef, RecursiveStatusResult } from './types.ts';
+export declare const RUN_ARTIFACT_SEQUENCE: string[];
+export declare const PHASES: PhaseDef[];
+export declare function escapeRegExp(value: string): string;
+export declare function trimMdValue(value: string): string;
+export declare function getMdFieldValue(content: string, fieldName: string): string | null;
+export declare function getGateStatus(content: string, gateName: string): string;
+export declare function getTodoStats(content: string): {
+    hasTodo: boolean;
+    total: number;
+    checked: number;
+    unchecked: number;
+};
+export declare function lockHashFromContent(content: string): string;
+export declare function getWorkflowProfile(runDir: string): string;
+export { getLatestRunDirectory, discoverRuns, resolveRunDir } from './run.ts';
+export type { RunDiscoveryResult } from './run.ts';
+export declare function getArtifactState(artifactPath: string, workflowProfile: string): ArtifactState;
+export declare function foldRun(runDir: string, runId: string): RecursiveStatusResult;

package/lib/types.d.ts

@@ -0,0 +1,104 @@
+export interface PhaseDef {
+    key: string;
+    label: string;
+    file: string;
+    optional: boolean;
+    phaseName: string;
+}
+export interface ArtifactState {
+    exists: boolean;
+    status: string;
+    lockValid: boolean;
+    lockProblems: string[];
+    blockers: string[];
+    lockedAt: string | null;
+    storedHash: string | null;
+    actualHash: string | null;
+    coverage: string;
+    approval: string;
+    audit: string;
+    todoHasSection: boolean;
+    todoUnchecked: number;
+}
+export interface PhaseState {
+    key: string;
+    label: string;
+    file: string;
+    optional: boolean;
+    exists: boolean;
+    status: string;
+    lockValid: boolean;
+    lockProblems: string[];
+    blockers: string[];
+}
+export interface RecursiveStatusResult {
+    runId: string;
+    currentPhase: {
+        key: string;
+        label: string;
+        phaseName: string;
+        status: string;
+    } | null;
+    phases: PhaseState[];
+    workflowProfile: string;
+}
+/** Run-level durable state (mirrors lifecycle.ts RUN_STATES; single pure-type home for the wire). */
+export type RecursiveRunState = 'new' | 'active' | 'paused' | 'blocked' | 'complete';
+/** One locked-phase fact carried by a recursive/phase-locked event. */
+export interface RecursivePhaseLock {
+    lockedAt: string;
+    lockHash: string;
+}
+/** One gate failure fact carried by a recursive/gate-blocked event. */
+export interface RecursiveGateBlock {
+    failures: string[];
+    kind: string;
+}
+/** One tamper fact carried by a recursive/tamper event. */
+export interface RecursiveTamper {
+    path: string;
+    reason: string;
+}
+/** One subagent activity fact (start or end). */
+export interface RecursiveSubagent {
+    childId: string;
+    role: string;
+    provider: string;
+    status?: 'running' | 'done' | 'failed';
+}
+/** One phase row in a run card's folded phase chain. */
+export interface RecursivePhaseRow {
+    phase: string;
+    status: string;
+    lockedAt?: string;
+    lockHash?: string;
+}
+/**
+ * The per-run wire card the recursive projection folds: the board, inspector,
+ * node, and strip all render from this whole value — never from the file tree.
+ */
+export interface RecursiveRunCard {
+    runId: string;
+    worktreeRoot: string;
+    repo?: string;
+    template?: string;
+    /** Folded phase chain: last-wins per phase key. */
+    phases: Record<string, RecursivePhaseRow>;
+    /** Folded run-level state: last recursive/run-state wins (default 'active'). */
+    state: RecursiveRunState;
+    stateReason?: string;
+    /** Latest gate block (last-wins); absent when no block is in force. */
+    gateBlocked?: RecursiveGateBlock;
+    /** Tamper facts (accumulated, latest wins per path). */
+    tampers: Record<string, RecursiveTamper>;
+    /** Subagent activity (latest status wins per childId). */
+    subagents: Record<string, RecursiveSubagent>;
+    /** Set on recursive/run-merged; the run re-keys to this root. */
+    mergedToRepoRoot?: string;
+}
+/**
+ * The recursive projection whole value: runs grouped by worktree root first,
+ * then by runId. The board renders one lane per run; the client enumerates by
+ * worktree root so it never crosses the workspace boundary.
+ */
+export type RecursiveProjection = Record<string, Record<string, RecursiveRunCard>>;

package/lib/workspace.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Workspace-scoped control-plane root resolution (R1, binding invariant).
+ *
+ * The plugin NEVER scans `workspaceRegistry.list()` to find "the" workspace and
+ * NEVER reads another open workspace's `.recursive/` tree. The ONLY root-resolution
+ * path is: session canonical cwd (`agent.session.header.cwd`) ->
+ * `workspaceRegistry.resolveByPath(cwd)` -> the owning workspace's canonical `path`,
+ * which IS the control-plane root.
+ */
+export interface WorkspaceLike {
+    readonly path: string;
+    readonly id: string;
+}
+export interface WorkspaceRegistryLike {
+    /** Resolve by canonical directory path without creating or mutating. */
+    resolveByPath(path: string): Promise<WorkspaceLike | undefined> | WorkspaceLike | undefined;
+    /** MUST NOT be used by this plugin (workspace-scoping invariant). */
+    list?(): unknown;
+}
+export interface WorkspaceResolver {
+    (cwd: string): Promise<string | null>;
+}
+/**
+ * Build a resolver bound to a workspace registry. Returns the canonical workspace
+ * path for the given cwd, or `null` when the cwd is not a registered workspace
+ * (no repo -> defer, never fail hard).
+ */
+export declare function makeWorkspaceResolver(registry: WorkspaceRegistryLike): WorkspaceResolver;
+/**
+ * Resolve the control-plane root for an agent-like object with a session header
+ * carrying a canonical `cwd`. Degrades to `null` when the registry or cwd is
+ * unavailable (callers defer, never fail hard).
+ */
+export declare function resolveControlPlaneRoot(agent: {
+    session?: {
+        header?: {
+            cwd?: string;
+        };
+    };
+} | null | undefined, registry?: WorkspaceRegistryLike | null, cwdFallback?: string): Promise<string | null>;
+/**
+ * Extract the canonical session cwd (for callers that pass it explicitly).
+ */
+export declare function sessionCwd(agent: {
+    session?: {
+        header?: {
+            cwd?: string;
+        };
+    };
+} | null | undefined): string | null;

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@try-works/dsh-recursive-mode",
+  "description": "recursive-mode workflow as a DeepSeek Harness bundle: RecursiveRuntime service + recursive_status tool",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./client": {
+      "types": "./lib/client.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "src",
+    "preset",
+    "scripts"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-api-remotes"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.5",
+    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.5",
+    "@deepseek-ai/dsh-session-projection": "0.1.0-rc.5",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.5",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "file:D:/deepseek-harness/vendor/cordis",
+    "@deepseek-ai/cosmokit": "file:D:/deepseek-harness/vendor/cosmokit",
+    "@deepseek-ai/dsh-agent": "file:D:/deepseek-harness/packages/core/agent",
+    "@deepseek-ai/dsh-attachment": "file:D:/deepseek-harness/packages/attachment/attachment",
+    "@deepseek-ai/dsh-brand": "file:D:/deepseek-harness/packages/util/brand",
+    "@deepseek-ai/dsh-code-runtime": "file:D:/deepseek-harness/packages/code-runtime/code-runtime",
+    "@deepseek-ai/dsh-invariants": "file:D:/deepseek-harness/packages/runtime-diagnostics/invariants",
+    "@deepseek-ai/dsh-llm": "file:D:/deepseek-harness/packages/llm/llm",
+    "@deepseek-ai/dsh-scope": "file:D:/deepseek-harness/packages/core/scope",
+    "@deepseek-ai/dsh-session": "file:D:/deepseek-harness/packages/core/session",
+    "@deepseek-ai/dsh-session-projection": "file:D:/deepseek-harness/packages/session/session-projection",
+    "@deepseek-ai/dsh-system-prompt": "file:D:/deepseek-harness/packages/core/system-prompt",
+    "@deepseek-ai/dsh-timeout": "file:D:/deepseek-harness/packages/util/timeout",
+    "@deepseek-ai/dsh-tools": "file:D:/deepseek-harness/packages/core/tools",
+    "@deepseek-ai/dsh-user-approval": "file:D:/deepseek-harness/packages/interaction/user-approval",
+    "@deepseek-ai/schemastery": "file:D:/deepseek-harness/vendor/schemastery",
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "react": "^18.2.0",
+    "tsdown": "^0.22.2",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0",
+    "zod": "^4.4.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsdown",
+    "bundle": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-session-projection": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-runtime": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-slots": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-conversation": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-sidebar": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-settings": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-api-remotes": {
+      "optional": true
+    }
+  }
+}