@try-works/dsh-recursive-mode 0.1.0

package/lib/enforcement.d.ts

@@ -0,0 +1,53 @@
+import { type SessionEventLike } from './lifecycle.ts';
+export type EnforcementMode = 'strict' | 'advisory';
+export interface EnforcementConfig {
+    preStep: EnforcementMode;
+    toolGuards: EnforcementMode;
+    tamper: EnforcementMode;
+}
+/** Validate the enforcement config shape (unknown keys fail at plugin load). */
+export declare function resolveEnforcementConfig(config: unknown): EnforcementConfig;
+export declare const DEFAULT_ENFORCEMENT: EnforcementConfig;
+/**
+ * Layer 1 - agent/pre-step phase-transition gate decision.
+ * Reads on TRANSITION INTENT ONLY (13.5): no transition intent means the step
+ * passes through untouched. On a transition intent whose gates fail:
+ *  - strict  -> reject (turn ends blocked, no model call spent)
+ *  - advisory -> enter (warn only; a recursive/gate-blocked event is emitted)
+ */
+export interface PreStepGateDecision {
+    kind: 'reject' | 'enter';
+    gateBlocked: boolean;
+    failures: string[];
+}
+export declare function evaluatePreStepGate(events: readonly SessionEventLike[], mode?: EnforcementMode): PreStepGateDecision;
+/**
+ * Layer 2 - tools/pre-execute guard decision.
+ * Pure predicate: inspects the pending tool execution (name + args) against
+ * the run tree under the given worktree root.
+ */
+export type ToolGuardDecision = {
+    kind: 'allow';
+} | {
+    kind: 'deny';
+    reason: string;
+} | {
+    kind: 'ask';
+    reason?: string;
+};
+export interface ToolExecLike {
+    name: string;
+    arguments?: unknown;
+    agent?: unknown;
+}
+export declare function evaluateToolGuard(exec: ToolExecLike, worktreeRoot: string, activeRunId: string, mode?: EnforcementMode): ToolGuardDecision;
+/**
+ * Layer 8 - fs/observed lock-tamper detection.
+ * A locked *.md whose observed version differs from the stored LockHash is
+ * a tamper. Returns a tamper reason (or null when clean/not-applicable).
+ */
+export declare function detectTamper(targetPath: string, worktreeRoot: string, activeRunId: string): {
+    runId: string;
+    path: string;
+    reason: string;
+} | null;

package/lib/events.d.ts

@@ -0,0 +1,173 @@
+/**
+ * recursive/* session events (Phase D R1, PROPOSAL 11.2/11.6): the complete
+ * durable event vocabulary the projection folds, the board renders, and the
+ * conversation node correlates. Every payload carries a non-empty
+ * { runId, worktreeRoot } so the whole plane is worktree-aware and the
+ * projection can group runs by their control-plane root (binding
+ * workspace-scoping invariant, run 03 R1).
+ *
+ * Events are LOG-ONLY (no live mirror): the projection unit (projection.ts)
+ * is the only derived view. Payloads are plain JSON and declared on the
+ * SessionEventMap merge via @deepseek-ai/dsh-session/types.
+ *
+ * The pure constructor helpers below enforce the runId + non-empty
+ * worktreeRoot invariant at emit time, so a malformed event fails loud at
+ * the emit site instead of silently landing cross-workspace.
+ */
+import type { RecursiveRunState } from './types.ts';
+/** Declare the recursive/* event family on the session event map (merge-extensible). */
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * A transition the lifecycle driver is ABOUT to validate/commit (logged
+         * before any file write). The pre-step gate reads this as the caller of the
+         * transition set — never a projection event (log-only internal signal).
+         */
+        'recursive/phase-intent': {
+            runId: string;
+            worktreeRoot: string;
+            targetArtifact: string;
+            kind: 'lock' | 'reopen' | 'advance';
+            evidence?: Record<string, unknown>;
+        };
+        /** A run was created/bootstrapped in this workspace. */
+        'recursive/run-created': {
+            runId: string;
+            worktreeRoot: string;
+            template?: string;
+            repo?: string;
+        };
+        /** A phase transition committed (validate -> commit -> flush -> emit). */
+        'recursive/phase': {
+            runId: string;
+            worktreeRoot: string;
+            phase: string;
+            status: string;
+        };
+        /** A phase artifact was locked (lock hash + timestamp recorded). */
+        'recursive/phase-locked': {
+            runId: string;
+            worktreeRoot: string;
+            phase: string;
+            lockedAt: string;
+            lockHash: string;
+        };
+        /** A transition's gate predicate failed (rejected in strict, warned in advisory). */
+        'recursive/gate-blocked': {
+            runId: string;
+            worktreeRoot: string;
+            phase: string;
+            failures: string[];
+            kind: string;
+        };
+        /** fs/observed detected a change to a locked artifact outside a tool call. */
+        'recursive/tamper': {
+            runId: string;
+            worktreeRoot: string;
+            path: string;
+            reason: string;
+        };
+        /** A run was merged back to the repo root (conversation history re-keys). */
+        'recursive/run-merged': {
+            runId: string;
+            worktreeRoot: string;
+            repoRoot: string;
+        };
+        /** Run-level lifecycle flag (active/paused/blocked/complete + reason). */
+        'recursive/run-state': {
+            runId: string;
+            worktreeRoot: string;
+            state: RecursiveRunState;
+            reason?: string;
+        };
+        /** A subagent started for this run. */
+        'recursive/subagent-start': {
+            runId: string;
+            worktreeRoot: string;
+            childId: string;
+            role: string;
+            provider: string;
+        };
+        /** A subagent finished for this run. */
+        'recursive/subagent-end': {
+            runId: string;
+            worktreeRoot: string;
+            childId: string;
+            role: string;
+            provider: string;
+            status: 'running' | 'done' | 'failed';
+        };
+    }
+}
+/** Enforce the runId + non-empty worktreeRoot invariant at emit time. */
+export declare function requireRunKey(runId: string, worktreeRoot: string): void;
+export interface PhaseIntentInput {
+    runId: string;
+    worktreeRoot: string;
+    targetArtifact: string;
+    kind: 'lock' | 'reopen' | 'advance';
+    evidence?: Record<string, unknown>;
+}
+export interface RunCreatedInput {
+    runId: string;
+    worktreeRoot: string;
+    template?: string;
+    repo?: string;
+}
+export interface PhaseInput {
+    runId: string;
+    worktreeRoot: string;
+    phase: string;
+    status: string;
+}
+export interface PhaseLockedInput {
+    runId: string;
+    worktreeRoot: string;
+    phase: string;
+    lockedAt: string;
+    lockHash: string;
+}
+export interface GateBlockedInput {
+    runId: string;
+    worktreeRoot: string;
+    phase: string;
+    failures: string[];
+    kind: string;
+}
+export interface TamperInput {
+    runId: string;
+    worktreeRoot: string;
+    path: string;
+    reason: string;
+}
+export interface RunMergedInput {
+    runId: string;
+    worktreeRoot: string;
+    repoRoot: string;
+}
+export interface RunStateInput {
+    runId: string;
+    worktreeRoot: string;
+    state: RecursiveRunState;
+    reason?: string;
+}
+export interface SubagentInput {
+    runId: string;
+    worktreeRoot: string;
+    childId: string;
+    role: string;
+    provider: string;
+}
+export interface SubagentEndInput extends SubagentInput {
+    status: 'running' | 'done' | 'failed';
+}
+export declare function phaseIntent(data: PhaseIntentInput): PhaseIntentInput;
+export declare function runCreated(data: RunCreatedInput): RunCreatedInput;
+export declare function phase(data: PhaseInput): PhaseInput;
+export declare function phaseLocked(data: PhaseLockedInput): PhaseLockedInput;
+export declare function gateBlocked(data: GateBlockedInput): GateBlockedInput;
+export declare function tamper(data: TamperInput): TamperInput;
+export declare function runMerged(data: RunMergedInput): RunMergedInput;
+export declare function runState(data: RunStateInput): RunStateInput;
+export declare function subagentStart(data: SubagentInput): SubagentInput;
+export declare function subagentEnd(data: SubagentEndInput): SubagentEndInput;

package/lib/handoff.d.ts

@@ -0,0 +1,51 @@
+export interface HandoffInput {
+    root: string;
+    runId: string;
+    delegationId: string;
+    role: string;
+    objective: string;
+    runDocRefs: string[];
+    codeRefs: string[];
+    auditQuestions: string[];
+    requiredOutput: string;
+    decisionBasis: string;
+    constraints?: string[];
+}
+export interface ChildBriefInput {
+    root: string;
+    runId: string;
+    delegationId: string;
+    childId: string;
+    slice: string;
+    replyContract?: string;
+}
+/** Main-agent handoff doc: the full delegation info for one delegation. */
+export declare function createHandoff(input: HandoffInput): string;
+/** Per-child brief: the receiving slice for one child. */
+export declare function createChildBrief(input: ChildBriefInput): string;
+/** Reply path the child must write its submission to. */
+export declare function replyPath(input: {
+    root: string;
+    runId: string;
+    delegationId: string;
+    childId: string;
+}): string;
+/** Child-scoped disposable scratch (Phase B R5, PROPOSAL 10.7). */
+export declare function childScratchPath(input: {
+    root: string;
+    runId: string;
+    childId: string;
+}): string;
+/**
+ * Build the reference-based delegation prompt (PROPOSAL 10.6): a pointer to
+ * handoff.md + brief.md, instructions to write reply.md and call report citing
+ * it. Short, not a monolithic paste.
+ */
+export declare function buildDelegationPrompt(input: {
+    root: string;
+    runId: string;
+    delegationId: string;
+    childId: string;
+    handoffPath: string;
+    briefPath: string;
+}): string;

package/lib/index.d.ts

@@ -0,0 +1,40 @@
+import { type Context } from '@deepseek-ai/cordis';
+export declare const name = "@try-works/dsh-recursive-mode";
+export { RecursiveRuntime } from './runtime.ts';
+export { createRecursiveStatusTool } from './recursive_status.tool.ts';
+export { createRecursiveInitTool } from './recursive_init.tool.ts';
+export { createRecursiveLockTool } from './recursive_lock.tool.ts';
+export { createRecursiveLintTool } from './recursive_lint.tool.ts';
+export { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts';
+export { createRecursiveScratchTool } from './recursive_scratch.tool.ts';
+export * from './status.ts';
+export { PHASE_SEQUENCE, OPTIONAL_PHASES, normalizeForLockHash, lockHashFromContent, phaseIndex, isCoreArtifact, getPrerequisites, getLockStatus, getPrerequisiteBlockers, receiptPath, readReceipt, writeReceipt, invalidateReceipt, getStaleDownstreamPhases, getNextLegalPhase, getAllStaleReceipts, validateChain, } from './lock.ts';
+export type { LockReceipt, LockStatus, PrerequisiteBlocker, StaleDownstream, ChainPhaseResult, LockChainResult, } from './lock.ts';
+export * from './run.ts';
+export * from './review.ts';
+export * from './handoff.ts';
+export * from './router.ts';
+export * from './delegation.ts';
+export * from './lifecycle.ts';
+export * from './enforcement.ts';
+export * from './policy.ts';
+export * from './events.ts';
+export * from './projection.ts';
+/**
+ * Bundle plugin entry. The Loader activates this row once `tools` is available
+ * (`inject` below); the RecursiveRuntime service is constructed directly so it
+ * is provided on `ctx.recursive` for the lifetime of this fiber, and the
+ * read-path tools (status/init/lock/lint) are registered through it (R2/R4).
+ */
+export declare const inject: string[];
+/**
+ * Two-stage init (PROPOSAL §5.10):
+ *  - Stage A (mount-time, this apply): register the isolated ctx.recursive
+ *    service + the recursive_* tools + the /recursive command + the
+ *    recursive:policy prompt section. No repo/run work here.
+ *  - Stage B (agent/session-start): resolve the session's workspace root (R1),
+ *    bootstrap the scaffold if missing, enumerate runs as dir names only, and
+ *    inject a workspace-scoped notice. See stageBWorkflowInit + the
+ *    agent/session-start listener below.
+ */
+export declare function apply(ctx: Context): void;

package/lib/lifecycle.d.ts

@@ -0,0 +1,107 @@
+/** Run-level durable states (PROPOSAL 8.8). */
+export declare const RUN_STATES: readonly ["new", "active", "paused", "blocked", "complete"];
+export type RunState = (typeof RUN_STATES)[number];
+/** A proposed phase transition the gates validate before any file write. */
+export interface PhaseTransitionIntent {
+    runId: string;
+    worktreeRoot: string;
+    targetArtifact: string;
+    kind: 'lock' | 'reopen' | 'advance';
+    evidence?: {
+        tddMode?: string;
+        redEvidencePath?: string;
+        greenEvidencePath?: string;
+        qaMode?: string;
+        qaSignOff?: boolean;
+    };
+}
+/** Folded phase state (last-wins over recursive/phase + recursive/run-state). */
+export interface RecursivePhaseState {
+    runId: string;
+    phase: string;
+    status: string;
+    runState: RunState;
+}
+/** A session-event-like carrier (the pure fold reads events by shape). */
+export interface SessionEventLike {
+    type: string;
+    data?: Record<string, unknown>;
+}
+/** Gate check result - the transition set's single output. */
+export interface GateCheckResult {
+    passed: boolean;
+    failures: string[];
+}
+/**
+ * Payload shapes for the recursive/* events. These are LEGACY structural
+ * views kept for internal consumers; the single source of truth for the
+ * emitted payloads is events.ts (every event carries { runId, worktreeRoot }).
+ * Aligned here so no local interface drifts out of the worktree-keyed
+ * invariant (B7).
+ */
+export interface RecursivePhaseEvent {
+    runId: string;
+    worktreeRoot: string;
+    phase: string;
+    status: string;
+}
+export interface RecursiveRunStateEvent {
+    runId: string;
+    worktreeRoot: string;
+    state: RunState;
+    reason?: string;
+}
+export interface RecursiveGateBlockedEvent {
+    runId: string;
+    worktreeRoot: string;
+    phase: string;
+    failures: string[];
+    kind: string;
+}
+export interface RecursiveTamperEvent {
+    runId: string;
+    worktreeRoot: string;
+    path: string;
+    reason: string;
+}
+export interface RecursiveTransitionFailedEvent {
+    runId: string;
+    worktreeRoot: string;
+    phase: string;
+    error: string;
+}
+/**
+ * Pure last-wins fold over the recursive/* events (the foldPlanMode pattern).
+ * A log with no recursive/phase folds to null; the last recursive/run-state
+ * wins for the run-level flag.
+ */
+export declare function foldRecursivePhase(events: readonly SessionEventLike[], end?: number): RecursivePhaseState | null;
+/** Whether the session log holds an opened turn without its closing turn/end. */
+export declare function hasOpenTurn(events: readonly SessionEventLike[]): boolean;
+/** Detect a pending transition intent from the session log (the lock tool logs it). */
+export declare function detectTransitionIntent(events: readonly SessionEventLike[]): PhaseTransitionIntent | null;
+/**
+ * Validate a proposed transition against the target phase's gates (PROPOSAL 8.4).
+ * Pure: reads the current file tree + lock.ts chain; writes nothing.
+ */
+export declare function validateTransition(intent: PhaseTransitionIntent): GateCheckResult;
+/**
+ * A serialized per-run transition driver (coalesced - the single-reservation
+ * pattern). Two concurrent 'lock Phase 3' intents queue; the second observes
+ * the first's committed state instead of racing the write.
+ */
+export declare class LifecycleDriver {
+    private readonly drivers;
+    /** Run one transition serially per runId. */
+    serialize(runId: string, run: () => Promise<void>): Promise<void>;
+}
+/**
+ * Couple a gate-block to the goal service (PROPOSAL 8.4 goal integration).
+ * Graceful no-op when the goal service or agent is unavailable.
+ */
+export declare function coupleGateBlockToGoal(goalService: {
+    block?: (agent: unknown, ref: unknown, reason: unknown) => unknown;
+} | null | undefined, agent: unknown, ref: unknown, reason: {
+    code: string;
+    message: string;
+}): boolean;

package/lib/lock.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Lock-hash + lock-chain validation for recursive-mode runs.
+ *
+ * Ports recursive-lock.py / verify-locks.py / recursive_phase_rules.py
+ * semantics (byte-for-byte where observable):
+ * - lockHashFromContent: LF-normalize, strip LockHash lines, SHA-256 hex
+ * - getLockStatus: MISSING / DRAFT / STALE_LOCK / LOCKED
+ * - getPrerequisites / getPrerequisiteBlockers: sequence ordering
+ * - validateChain: per-phase validity + break + next legal phase
+ * - receipts: read/write/invalidate with Python-identical JSON
+ *
+ * R3 (run 02).
+ */
+export declare const PHASE_SEQUENCE: readonly ["00-requirements.md", "00-worktree.md", "01-as-is.md", "01.5-root-cause.md", "02-to-be-plan.md", "03-implementation-summary.md", "03.5-code-review.md", "04-test-summary.md", "05-manual-qa.md", "06-decisions-update.md", "07-state-update.md", "08-memory-impact.md"];
+export declare const OPTIONAL_PHASES: Set<string>;
+export interface LockReceipt {
+    artifact: string;
+    artifact_path: string;
+    artifact_hash: string;
+    locked_at: string;
+    prerequisite_hashes: Record<string, string>;
+    previous_receipt_hash: string | null;
+    receipt_hash: string;
+}
+export type LockStatus = 'MISSING' | 'DRAFT' | 'STALE_LOCK' | 'LOCKED';
+export interface PrerequisiteBlocker {
+    artifact: string;
+    status: string;
+    path: string;
+}
+export interface StaleDownstream {
+    artifact: string;
+    reason: string;
+}
+export interface ChainPhaseResult {
+    file: string;
+    status: LockStatus;
+    lockValid: boolean;
+    lockProblems: string[];
+}
+export interface LockChainResult {
+    runId: string;
+    phases: ChainPhaseResult[];
+    breakPhase: string | null;
+    nextLegalPhase: string | null;
+    complete: boolean;
+    staleReceipts: StaleDownstream[];
+}
+/** LF-normalize, strip every LockHash: line, return the normalized content. */
+export declare function normalizeForLockHash(content: string): string;
+/** SHA-256 hex over the UTF-8 bytes of the normalized content. */
+export declare function lockHashFromContent(content: string): string;
+export declare function phaseIndex(artifactFile: string): number;
+export declare function isCoreArtifact(artifactFile: string): boolean;
+/**
+ * Every earlier phase in PHASE_SEQUENCE that exists on disk.
+ * Mirrors: [phase for phase in PHASE_SEQUENCE[:idx] if (run_dir / phase).exists()]
+ */
+export declare function getPrerequisites(runDir: string, artifactFile: string): string[];
+/**
+ * Canonical lock-validity classifier:
+ * MISSING (no file) / DRAFT (not LOCKED) / STALE_LOCK (missing or mismatched hash fields) / LOCKED.
+ */
+export declare function getLockStatus(artifactPath: string): LockStatus;
+/** Every prerequisite whose status is not LOCKED, in PHASE_SEQUENCE order. */
+export declare function getPrerequisiteBlockers(runDir: string, artifactFile: string): PrerequisiteBlocker[];
+export declare function receiptPath(runDir: string, artifactFile: string): string;
+export declare function readReceipt(runDir: string, artifactFile: string): LockReceipt | null;
+/**
+ * Write a lock receipt with Python-identical JSON semantics.
+ */
+export declare function writeReceipt(runDir: string, artifactFile: string, artifactPath: string): LockReceipt;
+export declare function invalidateReceipt(runDir: string, artifactFile: string): boolean;
+/**
+ * Downstream phases (strictly after artifactFile in PHASE_SEQUENCE) whose
+ * receipt's prerequisite_hashes[artifactFile] differs from the current hash
+ * (or the artifact no longer exists).
+ */
+export declare function getStaleDownstreamPhases(runDir: string, artifactFile: string): StaleDownstream[];
+export declare function getNextLegalPhase(runDir: string): string | null;
+/** All receipts whose prerequisite_hashes reference a missing or changed artifact. */
+export declare function getAllStaleReceipts(runDir: string): StaleDownstream[];
+/**
+ * Validate the full lock chain of a run: per-phase lock status, break phase,
+ * next legal phase, completion, and stale receipts.
+ */
+export declare function validateChain(runDir: string, runId: string): LockChainResult;
+/**
+ * Python json.dumps(obj, sort_keys=True, separators=(', ', ': '), ensure_ascii=True)
+ * compact serialization. Exported for parity testing against the Python oracle.
+ */
+export declare function serializeForReceiptHash(obj: object): string;

package/lib/policy.d.ts

@@ -0,0 +1,12 @@
+import type { RecursivePhaseState } from './lifecycle.ts';
+import type { EnforcementConfig } from './enforcement.ts';
+export interface PolicyContext {
+    worktreeRoot: string;
+    runId: string;
+    folded: RecursivePhaseState | null;
+    config?: EnforcementConfig;
+}
+/**
+ * Render the current-phase contract. Empty string when no run is active.
+ */
+export declare function renderRecursivePolicy(context: PolicyContext | null): string;

package/lib/projection.d.ts

@@ -0,0 +1,29 @@
+import type { ZodType } from 'zod';
+import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection';
+import type { RecursiveProjection } from './types.ts';
+/** Declare the 'recursive' projection key on the shared type table. */
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionMap {
+        /** Runs grouped by worktree root, then runId. */
+        recursive: RecursiveProjection;
+    }
+}
+/** Structural event shape the pure fold reads (unit-testable without a session). */
+export interface RecursiveEventLike {
+    type: string;
+    data?: Record<string, unknown>;
+}
+/** Mutable fold accumulator (private to the pure fold; never leaks). */
+export interface RecursiveFoldState {
+    /** The workspace control-plane root this unit is scoped to ('' = accept all). */
+    workspaceRoot: string;
+    /** Runs grouped by worktree root then runId. */
+    byWorktree: RecursiveProjection;
+}
+export declare function emptyRecursiveFoldState(workspaceRoot?: string): RecursiveFoldState;
+/** Whether a worktreeRoot is inside (or equal to) the workspace root. */
+export declare function isInsideWorkspace(worktreeRoot: string, workspaceRoot: string): boolean;
+export declare function foldRecursiveProjection(state: RecursiveFoldState, event: RecursiveEventLike): RecursiveFoldState;
+export declare const recursiveProjectionSchema: ZodType<RecursiveProjection>;
+/** The registered projection unit (key 'recursive'). */
+export declare const recursiveProjectionUnit: ProjectionDefinition<'recursive', RecursiveFoldState>;

package/lib/recursive_closeout.tool.d.ts

@@ -0,0 +1,8 @@
+import type { RecursiveRuntime } from './runtime.ts';
+/**
+ * `recursive_closeout` — scaffold a Phase 4/5/6/7/8 closeout receipt under the
+ * SESSION's workspace only (R1 workspace-scoping invariant). The run is resolved
+ * via the session agent's cwd -> workspace registry; a runId outside the current
+ * workspace is rejected.
+ */
+export declare function createRecursiveCloseoutTool(recursive: RecursiveRuntime): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/recursive_init.tool.d.ts

@@ -0,0 +1,2 @@
+import type { RecursiveRuntime } from './runtime.ts';
+export declare function createRecursiveInitTool(recursive: RecursiveRuntime): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/recursive_lint.tool.d.ts

@@ -0,0 +1,2 @@
+import type { RecursiveRuntime } from './runtime.ts';
+export declare function createRecursiveLintTool(recursive: RecursiveRuntime): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/recursive_lock.tool.d.ts

@@ -0,0 +1,2 @@
+import type { RecursiveRuntime } from './runtime.ts';
+export declare function createRecursiveLockTool(recursive: RecursiveRuntime): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/recursive_scratch.tool.d.ts

@@ -0,0 +1,7 @@
+import type { RecursiveRuntime } from './runtime.ts';
+/**
+ * `recursive_scratch` — read/write/append the run-scoped disposable scratchpad
+ * (R5) under the CURRENT session workspace only (R1). Scratch is git-ignored
+ * and never citable as an Input.
+ */
+export declare function createRecursiveScratchTool(recursive: RecursiveRuntime): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/recursive_status.tool.d.ts

@@ -0,0 +1,2 @@
+import type { RecursiveRuntime } from './runtime.ts';
+export declare function createRecursiveStatusTool(recursive: RecursiveRuntime): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/review.d.ts

@@ -0,0 +1,39 @@
+export interface ReviewBundleInput {
+    root: string;
+    runId: string;
+    phase: string;
+    role: string;
+    artifactPath: string;
+    upstreamArtifacts: string[];
+    auditQuestions: string[];
+    requiredOutput: string;
+    diffBasis?: {
+        baselineType: string;
+        baselineReference: string;
+        comparisonReference: string;
+        normalizedBaseline: string;
+        normalizedComparison: string;
+        normalizedDiffCommand: string;
+    };
+    codeRefs?: string[];
+    addenda?: string[];
+    priorEvidence?: string[];
+    memoryRefs?: string[];
+    changedFiles?: string[];
+}
+export interface ReviewBundleResult {
+    bundlePath: string;
+    repoRelativePath: string;
+    artifactContentHash: string;
+    markdown: string;
+}
+/** LF-normalized sha256 (matches recursive-lock.py content_sha256). */
+export declare function contentSha256(content: string): string;
+/**
+ * Build a canonical review bundle. Throws when the artifact path is missing or
+ * when a path would escape the workspace root (fail loud, never a silent
+ * bundle).
+ */
+export declare function buildReviewBundle(input: ReviewBundleInput): ReviewBundleResult;
+/** Canonical bundle dir for a run: .recursive/run/<id>/evidence/review-bundles/. */
+export declare function reviewBundleDir(root: string, runId: string): string;