@antst/roller 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Starikov
+
+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/README.md

@@ -0,0 +1,16 @@
+# @antst/roller
+
+roller is file rewind for DeepSeek Harness (DSH). It records the original
+contents of files changed by DSH's `write`, `edit`, and mutating
+`str_replace_editor` operations, then restores those files to a completed
+turn boundary.
+
+Install as a DSH plugin bundle, not as a standalone dependency:
+
+```sh
+npm install --global @deepseek-ai/dsh
+dsh plugin --profile <profile> add @antst/roller
+```
+
+Full documentation, source, and issue tracker:
+https://forgejo.antst.net/ai/roller

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# File rewind for profiles built on dsh-base.
+- insert:
+    - id: roller
+      name: '@antst/roller'

package/lib/capture.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { FsTarget } from '@deepseek-ai/dsh-fs';
+import type { KvTable } from '@deepseek-ai/dsh-storage-domain';
+import { type CheckpointKey, type CheckpointRecord } from './spec.js';
+export declare class CaptureJournal {
+    private readonly ctx;
+    private readonly checkpoints;
+    private readonly evictedAtTurn;
+    constructor(ctx: Context, checkpoints: KvTable<CheckpointKey, CheckpointRecord>);
+    capture(target: FsTarget, value: object | undefined): Promise<void>;
+    private evict;
+}

package/lib/capture.js

@@ -0,0 +1,156 @@
+import { createHash } from 'node:crypto';
+import { relative, sep } from 'node:path';
+import { FsError } from '@deepseek-ai/dsh-fs';
+import { hasMultipleHardLinks } from './restore-files.js';
+import { MAX_CHECKPOINT_BYTES, RETAINED_TURNS, } from './spec.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function mutationActor(value) {
+    if (!isRecord(value) || !isRecord(value.arguments) || !isRecord(value.agent))
+        return undefined;
+    const session = value.agent.session;
+    if (!isRecord(session) || !isRecord(session.header) || typeof session.snapshotEvents !== 'function')
+        return undefined;
+    if (typeof session.header.id !== 'string')
+        return undefined;
+    if (value.name !== 'write' && value.name !== 'edit' && value.name !== 'str_replace_editor')
+        return undefined;
+    return value;
+}
+function requestedPath(actor) {
+    if (actor.name === 'write' || actor.name === 'edit') {
+        return typeof actor.arguments.file_path === 'string' ? actor.arguments.file_path : undefined;
+    }
+    const command = actor.arguments.command;
+    if (command !== 'create' && command !== 'str_replace' && command !== 'insert')
+        return undefined;
+    return typeof actor.arguments.path === 'string' ? actor.arguments.path : undefined;
+}
+function openTurn(session) {
+    let boundary;
+    const events = session.snapshotEvents();
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === 'turn/start' || event.type === 'turn/end') {
+            boundary = event;
+            break;
+        }
+    }
+    if (boundary?.type !== 'turn/start' || !isRecord(boundary.data))
+        return undefined;
+    return Number.isSafeInteger(boundary.data.turn) && boundary.data.turn >= 0
+        ? boundary.data.turn
+        : undefined;
+}
+function keyOf(sessionId, turn, targetKey) {
+    return createHash('sha256')
+        .update(sessionId).update('\0').update(String(turn)).update('\0').update(targetKey)
+        .digest('hex');
+}
+function normalizedRelative(cwdPath, targetPath) {
+    return relative(cwdPath, targetPath).split(sep).join('/');
+}
+function losslessUtf8(bytes) {
+    let decoded;
+    try {
+        decoded = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return false;
+    }
+    return Buffer.from(decoded, 'utf8').equals(Buffer.from(bytes));
+}
+export class CaptureJournal {
+    ctx;
+    checkpoints;
+    evictedAtTurn = new Map();
+    constructor(ctx, checkpoints) {
+        this.ctx = ctx;
+        this.checkpoints = checkpoints;
+    }
+    async capture(target, value) {
+        const actor = mutationActor(value);
+        if (actor === undefined)
+            return;
+        const path = requestedPath(actor);
+        const cwd = actor.agent.session.header.cwd;
+        const turn = openTurn(actor.agent.session);
+        if (path === undefined || cwd === undefined || turn === undefined)
+            return;
+        const sessionId = actor.agent.session.header.id;
+        const targetKey = String(target.targetKey);
+        const key = keyOf(sessionId, turn, targetKey);
+        const existing = this.checkpoints.get(key);
+        if (existing !== undefined) {
+            if (existing.sessionId !== sessionId || existing.turn !== turn || existing.targetKey !== targetKey) {
+                throw new Error(`roller: checkpoint key collision for ${target.displayPath}`);
+            }
+            return;
+        }
+        const cwdTarget = actor.signal === undefined
+            ? await this.ctx.fs.resolve(cwd)
+            : await this.ctx.fs.resolve(cwd, { signal: actor.signal });
+        if (!this.ctx.fs.contains(cwdTarget, target))
+            return;
+        const pathInfo = await this.ctx.fs.lstat(path, { cwd }, actor.signal);
+        if (pathInfo?.type === 'symlink')
+            return;
+        let before;
+        if (pathInfo === undefined) {
+            before = { kind: 'absent' };
+        }
+        else {
+            if (pathInfo.type !== 'file')
+                return;
+            if (await hasMultipleHardLinks(this.ctx.fs.processPath(target)))
+                return;
+            let bytes;
+            try {
+                bytes = await this.ctx.fs.readBytes(target, actor.signal, MAX_CHECKPOINT_BYTES);
+            }
+            catch (error) {
+                if (error instanceof FsError && error.code === 'FS_TOO_LARGE')
+                    return;
+                throw error;
+            }
+            if (!losslessUtf8(bytes))
+                return;
+            before = {
+                kind: 'text',
+                contentBase64: Buffer.from(bytes).toString('base64'),
+                byteLength: bytes.byteLength,
+            };
+        }
+        await this.evict(sessionId, turn);
+        const cwdPath = this.ctx.fs.processPath(cwdTarget);
+        const targetPath = this.ctx.fs.processPath(target);
+        try {
+            await this.checkpoints.put(key, {
+                sessionId,
+                turn,
+                targetKey,
+                relativePath: normalizedRelative(cwdPath, targetPath),
+                displayPath: target.displayPath,
+                before,
+            });
+        }
+        catch (error) {
+            const cause = error instanceof Error ? error.message : String(error);
+            throw new Error(`roller: checkpoint write failed for ${target.displayPath}: ${cause}`, { cause: error });
+        }
+    }
+    async evict(sessionId, turn) {
+        if (this.evictedAtTurn.get(sessionId) === turn)
+            return;
+        const cutoff = turn - (RETAINED_TURNS - 1);
+        for (const [key, record] of this.checkpoints.entries()) {
+            if (record.sessionId === sessionId && record.turn < cutoff) {
+                await this.checkpoints.delete(key);
+            }
+        }
+        // This is only a scan watermark. Journal correctness never depends on
+        // retaining or reconstructing it, so a restart merely repeats one scan.
+        this.evictedAtTurn.set(sessionId, turn);
+    }
+}

package/lib/format.d.ts

@@ -0,0 +1,14 @@
+export interface RestoreFailure {
+    path: string;
+    operation: 'write' | 'delete';
+    message: string;
+}
+export interface RestoreReport {
+    seq: number;
+    turn: number;
+    written: readonly string[];
+    deleted: readonly string[];
+    failed: readonly RestoreFailure[];
+}
+/** Stable command/done text rendered by every DSH command surface. */
+export declare function formatRestoreReport(report: RestoreReport): string;

package/lib/format.js

@@ -0,0 +1,17 @@
+function paths(heading, values) {
+    return [heading, ...(values.length === 0 ? ['- none'] : values.map(value => `- ${value}`))];
+}
+/** Stable command/done text rendered by every DSH command surface. */
+export function formatRestoreReport(report) {
+    return [
+        report.seq === 0
+            ? 'Restored files to session start.'
+            : `Restored files to turn/end ${report.seq} (turn ${report.turn}).`,
+        ...paths(`Written (${report.written.length}):`, report.written),
+        ...paths(`Deleted (${report.deleted.length}):`, report.deleted),
+        `Failed (${report.failed.length}):`,
+        ...(report.failed.length === 0
+            ? ['- none']
+            : report.failed.map(failure => `- ${failure.path}: ${failure.operation}: ${failure.message}`)),
+    ].join('\n');
+}

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@deepseek-ai/cordis';
+export { MAX_CHECKPOINT_BYTES, RETAINED_TURNS, checkpointRecordSchema, rollerDomainSpec, } from './spec.js';
+export type { CheckpointKey, CheckpointRecord } from './spec.js';
+export { formatRestoreReport } from './format.js';
+export type { RestoreFailure, RestoreReport } from './format.js';
+export declare const name = "roller";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;

package/lib/index.js

@@ -0,0 +1,26 @@
+import { CaptureJournal } from './capture.js';
+import { registerRestoreCommand } from './restore.js';
+import { rollerDomainSpec } from './spec.js';
+import { warnIfUnsupportedDsh } from './version.js';
+export { MAX_CHECKPOINT_BYTES, RETAINED_TURNS, checkpointRecordSchema, rollerDomainSpec, } from './spec.js';
+export { formatRestoreReport } from './format.js';
+export const name = 'roller';
+export const inject = ['commands', 'fs', 'sandboxPolicy', 'sessions', 'storageDomain'];
+export async function apply(ctx) {
+    // A real profile boot installs Loader before mounting config entries
+    // (DSH packages/boot/app-boot/src/index.ts:779-789); direct test hosts do not.
+    if (ctx.get('loader') !== undefined)
+        warnIfUnsupportedDsh();
+    const domain = await ctx.storageDomain.open(rollerDomainSpec);
+    ctx.effect(() => () => domain.close());
+    const journal = new CaptureJournal(ctx, domain.table('checkpoints'));
+    ctx.effect(() => registerRestoreCommand(ctx, domain.table('checkpoints')));
+    ctx.on('fs/write-intent', async (target, actor, next) => {
+        await journal.capture(target, actor);
+        return next();
+    }, { prepend: true });
+    ctx.on('fs/edit-intent', async (target, actor, next) => {
+        await journal.capture(target, actor);
+        return next();
+    }, { prepend: true });
+}

package/lib/restore-files.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { FsTarget } from '@deepseek-ai/dsh-fs';
+import type { SandboxExecutionPolicy } from '@deepseek-ai/dsh-sandbox';
+/** Host-only hard-link check for capture eligibility. */
+export declare function hasMultipleHardLinks(path: string): Promise<boolean>;
+/** The one host-local seam used until DSH exposes a filesystem delete primitive. */
+export declare function deleteRestoredFile(ctx: Context, target: FsTarget, policy: SandboxExecutionPolicy, exists: boolean, signal: AbortSignal): Promise<void>;

package/lib/restore-files.js

@@ -0,0 +1,31 @@
+import { lstat, unlink } from 'node:fs/promises';
+/** Host-only hard-link check for capture eligibility. */
+export async function hasMultipleHardLinks(path) {
+    return (await lstat(path)).nlink > 1;
+}
+/** The one host-local seam used until DSH exposes a filesystem delete primitive. */
+export async function deleteRestoredFile(ctx, target, policy, exists, signal) {
+    if (!exists)
+        return;
+    if (policy.mode === 'read-only') {
+        throw new Error(`cannot delete ${target.displayPath}: file access denied under read-only mode`);
+    }
+    if (policy.mode === 'workspace-write') {
+        const root = await ctx.fs.resolve(policy.workspaceRoot, { signal });
+        if (!ctx.fs.contains(root, target)) {
+            throw new Error(`cannot delete ${target.displayPath}: outside workspace-write root`);
+        }
+    }
+    const hostPath = ctx.fs.processPath(target);
+    if (ctx.fs.processPathFromHostPath(hostPath) !== hostPath) {
+        throw new Error(`cannot delete ${target.displayPath}: filesystem is not host-local`);
+    }
+    signal.throwIfAborted();
+    const info = await lstat(hostPath);
+    if (!info.isFile())
+        throw new Error(`cannot delete ${target.displayPath}: not a regular file`);
+    if (info.nlink > 1)
+        throw new Error(`cannot delete ${target.displayPath}: hard-linked file`);
+    signal.throwIfAborted();
+    await unlink(hostPath);
+}

package/lib/restore.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { CommandInvocation, CommandResult } from '@deepseek-ai/dsh-commands';
+import type { KvTable } from '@deepseek-ai/dsh-storage-domain';
+import type { CheckpointKey, CheckpointRecord } from './spec.js';
+export declare function restoreCommand(ctx: Context, checkpoints: KvTable<CheckpointKey, CheckpointRecord>, invocation: CommandInvocation): Promise<CommandResult>;
+export declare function registerRestoreCommand(ctx: Context, checkpoints: KvTable<CheckpointKey, CheckpointRecord>): () => void;

package/lib/restore.js

@@ -0,0 +1,119 @@
+import { SessionSeq } from '@deepseek-ai/dsh-session';
+import { deleteRestoredFile } from './restore-files.js';
+import { formatRestoreReport } from './format.js';
+function parseSeq(rawInput) {
+    const value = rawInput.trim();
+    if (!/^\d+$/u.test(value))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+function latestCompletedTurn(session) {
+    const events = session.snapshotEvents();
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === 'turn/end')
+            return event.data.turn;
+    }
+    return 0;
+}
+function selectedRecords(checkpoints, sessionId, targetTurn) {
+    const newestFirst = [...checkpoints.entries()]
+        .map(([, record]) => record)
+        .filter(record => record.sessionId === sessionId && record.turn > targetTurn)
+        .sort((left, right) => right.turn - left.turn);
+    const selected = new Map();
+    for (const record of newestFirst)
+        selected.set(record.targetKey, record);
+    return [...selected.values()].sort((left, right) => left.relativePath < right.relativePath ? -1 : left.relativePath > right.relativePath ? 1 : 0);
+}
+function decodedContent(record) {
+    if (record.before.kind !== 'text')
+        throw new Error('checkpoint does not contain text');
+    const bytes = Buffer.from(record.before.contentBase64, 'base64');
+    if (bytes.toString('base64') !== record.before.contentBase64
+        || bytes.byteLength !== record.before.byteLength) {
+        throw new Error('checkpoint content is malformed');
+    }
+    const content = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    if (!Buffer.from(content, 'utf8').equals(bytes))
+        throw new Error('checkpoint content is not lossless UTF-8');
+    return content;
+}
+function failureMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replaceAll(/\s+/gu, ' ').trim() || 'unknown failure';
+}
+function error(text) {
+    return { kind: 'error', text };
+}
+export async function restoreCommand(ctx, checkpoints, invocation) {
+    const value = invocation.rawInput.trim();
+    const start = value === 'start' || value === '0';
+    const seq = start ? 0 : parseSeq(value);
+    if (seq === undefined)
+        return error('Usage: /roller-restore <turn-end-seq|start|0>');
+    const current = invocation.agent.session;
+    const sourceId = current.header.parentSession ?? current.id;
+    const source = ctx.sessions.get(sourceId);
+    if (source === undefined)
+        return error(`Source session ${sourceId} is not live.`);
+    const boundary = start
+        ? { type: 'turn/end', data: { turn: -1 } }
+        : source.eventAt(SessionSeq(seq));
+    if (boundary?.type !== 'turn/end')
+        return error(`No turn/end event exists at sequence ${seq}.`);
+    const latestTurn = latestCompletedTurn(source);
+    if (!start && latestTurn - boundary.data.turn > 100) {
+        return error(`Turn ${boundary.data.turn} is outside roller's 100-turn retention window.`);
+    }
+    const cwd = current.header.cwd;
+    if (cwd === undefined)
+        return error('The current session has no workspace cwd.');
+    const records = selectedRecords(checkpoints, String(sourceId), boundary.data.turn);
+    const policy = ctx.sandboxPolicy.resolve({ session: current });
+    const written = [];
+    const deleted = [];
+    const failed = [];
+    const cwdTarget = await ctx.fs.resolve(cwd, { signal: invocation.signal });
+    for (const record of records) {
+        const operation = record.before.kind === 'text' ? 'write' : 'delete';
+        try {
+            const target = await ctx.fs.resolve(record.relativePath, { cwd, signal: invocation.signal });
+            if (!ctx.fs.contains(cwdTarget, target))
+                throw new Error('path is outside the session cwd');
+            const pathInfo = await ctx.fs.lstat(record.relativePath, { cwd }, invocation.signal);
+            if (pathInfo?.type === 'symlink')
+                throw new Error('refusing to restore a symbolic link');
+            if (pathInfo !== undefined && pathInfo.type !== 'file')
+                throw new Error('path is not a regular file');
+            if (record.before.kind === 'text') {
+                await ctx.fs.writeText(target, decodedContent(record), undefined, invocation.signal, policy);
+                written.push(record.relativePath);
+            }
+            else {
+                await deleteRestoredFile(ctx, target, policy, pathInfo !== undefined, invocation.signal);
+                deleted.push(record.relativePath);
+            }
+        }
+        catch (pathError) {
+            failed.push({
+                path: record.relativePath,
+                operation,
+                message: failureMessage(pathError),
+            });
+        }
+    }
+    return {
+        kind: 'success',
+        text: formatRestoreReport({ seq, turn: start ? 0 : boundary.data.turn, written, deleted, failed }),
+    };
+}
+export function registerRestoreCommand(ctx, checkpoints) {
+    return ctx.commands.register({
+        name: 'roller-restore',
+        description: 'Restore files to a completed turn boundary or session start',
+        input: { hint: '<turn-end-seq|start|0>' },
+        handler: invocation => restoreCommand(ctx, checkpoints, invocation),
+    });
+}

package/lib/spec.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const MAX_CHECKPOINT_BYTES = 1048576;
+export declare const RETAINED_TURNS = 100;
+export type CheckpointKey = string & {
+    readonly __checkpointKey: unique symbol;
+};
+export declare const checkpointRecordSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    turn: z.ZodNumber;
+    targetKey: z.ZodString;
+    relativePath: z.ZodString;
+    displayPath: z.ZodString;
+    before: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        contentBase64: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type CheckpointRecord = z.infer<typeof checkpointRecordSchema>;
+export declare const rollerDomainSpec: {
+    name: string;
+    version: number;
+    layout: "per-record";
+    tables: {
+        checkpoints: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<CheckpointKey, {
+            sessionId: string;
+            turn: number;
+            targetKey: string;
+            relativePath: string;
+            displayPath: string;
+            before: {
+                kind: "absent";
+            } | {
+                kind: "text";
+                contentBase64: string;
+                byteLength: number;
+            };
+        }>;
+    };
+};

package/lib/spec.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+export const MAX_CHECKPOINT_BYTES = 1_048_576;
+export const RETAINED_TURNS = 100;
+export const checkpointRecordSchema = z.object({
+    sessionId: z.string(),
+    turn: z.number().int().nonnegative(),
+    targetKey: z.string(),
+    relativePath: z.string(),
+    displayPath: z.string(),
+    before: z.discriminatedUnion('kind', [
+        z.object({ kind: z.literal('absent') }),
+        z.object({
+            kind: z.literal('text'),
+            contentBase64: z.string(),
+            byteLength: z.number().int().nonnegative().max(MAX_CHECKPOINT_BYTES),
+        }),
+    ]),
+});
+export const rollerDomainSpec = defineDomain({
+    name: 'roller',
+    version: 1,
+    layout: 'per-record',
+    tables: {
+        checkpoints: domainTable(checkpointRecordSchema),
+    },
+});

package/lib/version.d.ts

@@ -0,0 +1 @@
+export declare function warnIfUnsupportedDsh(): void;

package/lib/version.js

@@ -0,0 +1,19 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+const validatedVersions = JSON.parse(readFileSync(new URL('../validated-dsh-versions.json', import.meta.url), 'utf8'));
+function runningDshVersion() {
+    try {
+        const entry = realpathSync(process.argv[1] ?? '');
+        const manifest = JSON.parse(readFileSync(resolve(dirname(entry), '../package.json'), 'utf8'));
+        return typeof manifest.version === 'string' ? manifest.version : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+export function warnIfUnsupportedDsh() {
+    const version = runningDshVersion();
+    if (!validatedVersions.includes(version)) {
+        process.stderr.write(`roller: warning: DSH ${version} is not validated; validated: ${validatedVersions.join(', ')}\n`);
+    }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@antst/roller",
+  "version": "0.1.2",
+  "description": "File rewind for DeepSeek Harness",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/antst/roller",
+    "directory": "packages/roller"
+  },
+  "homepage": "https://github.com/antst/roller#readme",
+  "bugs": {
+    "url": "https://github.com/antst/roller/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "cordis.patch.yml",
+    "validated-dsh-versions.json"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "dependencies": {
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-commands": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-fs": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-sandbox": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-sandbox-policy": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-session": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-storage-domain": "0.1.2-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/dsh-agent": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-agent-loop": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-agent-loop-testkit": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-commands": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-fs": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-fs-local": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-fs-observation-policy": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-fs-sandbox": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-sandbox": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-sandbox-policy": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-session": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-session-projection": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-storage": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-storage-domain": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-storage-json": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-system-prompt": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-tool-fs": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-tool-str-replace-editor": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-tools": "0.1.2-rc.1"
+  }
+}

package/validated-dsh-versions.json

@@ -0,0 +1,3 @@
+[
+  "0.1.2-rc.1"
+]