@anionex/dsh-turn-rewind 0.1.2 → 0.2.1

package/lib/store.js

@@ -117,6 +117,11 @@ export class LedgerStore {
             throw error;
         }
     }
+    /** Acquire only the durable directory lock when the recorded worktree is no longer available. */
+    async acquireWorkspaceDir(workspaceDir, workspace, signal) {
+        const lease = await this.acquireOne(join(workspaceDir, 'lock.json'), workspace, false, true, signal);
+        return () => lease.release();
+    }
     async acquireOne(initialLockPath, workspace, shared, reclaim = true, signal) {
         throwIfAborted(signal);
         const ownerHostId = hostIdentity();
@@ -254,28 +259,39 @@ export class LedgerStore {
     }
     /** List all validated restore points for one workspace, newest first. */
     async listManifests(workspace, signal) {
+        const manifests = await this.listManifestsInDir(this.workspaceDir(workspace), signal);
+        for (const manifest of manifests) {
+            if (manifest.workspace !== workspace) {
+                throw new ChangeLedgerError('STATE_CORRUPT', `manifest ${manifest.id} belongs to a different workspace`);
+            }
+        }
+        return manifests;
+    }
+    /** List validated manifests directly from one storage directory, newest first. */
+    async listManifestsInDir(workspaceDir, signal) {
         const manifests = [];
-        for (const filename of await safeJsonNames(join(this.workspaceDir(workspace), 'manifests'))) {
+        for (const filename of await safeJsonNames(join(workspaceDir, 'manifests'))) {
             throwIfAborted(signal);
-            const manifest = parseManifest(await readJson(join(this.workspaceDir(workspace), 'manifests', filename)));
+            const manifest = parseManifest(await readJson(join(workspaceDir, 'manifests', filename)));
             this.assertManifestOwned(manifest);
-            await this.assertManifestWorkspaceIdentity(manifest, this.workspaceDir(workspace));
+            await this.assertManifestWorkspaceIdentity(manifest, workspaceDir);
             if (filename !== `${manifest.id}.json`) {
                 throw new ChangeLedgerError('STATE_CORRUPT', `manifest ${filename} does not match its persisted id ${manifest.id}`);
             }
-            if (manifest.workspace !== workspace) {
-                throw new ChangeLedgerError('STATE_CORRUPT', `manifest ${filename} belongs to a different workspace`);
-            }
             manifests.push(manifest);
         }
         return manifests.sort((left, right) => right.createdAt - left.createdAt || right.id.localeCompare(left.id));
     }
     /** Delete one restore-point manifest. Blobs remain until garbage collection succeeds. */
     async deleteManifest(workspace, id) {
+        await this.deleteManifestInDir(this.workspaceDir(workspace), id);
+    }
+    /** Delete one restore-point manifest directly from its storage directory. */
+    async deleteManifestInDir(workspaceDir, id) {
         validateRestorePointId(id);
-        const directory = join(this.workspaceDir(workspace), 'manifests');
+        const directory = join(workspaceDir, 'manifests');
         try {
-            await unlink(this.manifestPath(workspace, id));
+            await unlink(join(directory, `${id}.json`));
         }
         catch (error) {
             if (isNodeError(error, 'ENOENT')) {
@@ -304,26 +320,45 @@ export class LedgerStore {
         this.assertGitCheckpointJournalOwned(parseGitCheckpointJournal(journal));
         await writeJsonAtomic(this.gitCheckpointJournalPath(manifest.workspace, manifest.id), journal);
     }
+    /** List every persisted workspace directory under this storage root. */
+    async listWorkspaceDirs(signal) {
+        const root = join(this.config.storageDir, 'workspaces');
+        const dirs = [];
+        for (const key of await safeDirectoryNames(root)) {
+            throwIfAborted(signal);
+            dirs.push(join(root, key));
+        }
+        return dirs;
+    }
     /** List every pending Git checkpoint transition across this storage root. */
     async listGitCheckpointJournals() {
         const journals = [];
         for (const workspaceKey of await safeDirectoryNames(join(this.config.storageDir, 'workspaces'))) {
             const workspaceDir = join(this.config.storageDir, 'workspaces', workspaceKey);
-            for (const filename of await safeJsonNames(join(workspaceDir, 'git-journals'))) {
-                const journal = parseGitCheckpointJournal(await readJson(join(workspaceDir, 'git-journals', filename)));
-                this.assertGitCheckpointJournalOwned(journal);
-                await this.assertGitCheckpointJournalWorkspaceIdentity(journal, workspaceDir);
-                if (filename !== `${journal.restorePointId}.json`) {
-                    throw new ChangeLedgerError('STATE_CORRUPT', `Git checkpoint journal ${filename} does not match its restore-point id`);
-                }
+            for (const journal of await this.listGitCheckpointJournalsInDir(workspaceDir)) {
                 if (this.workspaceDir(journal.workspace) !== workspaceDir) {
-                    throw new ChangeLedgerError('STATE_CORRUPT', `Git checkpoint journal ${filename} is stored under the wrong workspace key`);
+                    throw new ChangeLedgerError('STATE_CORRUPT', `Git checkpoint journal ${journal.restorePointId}.json is stored under the wrong workspace key`);
                 }
                 journals.push(journal);
             }
         }
         return journals.sort((left, right) => left.createdAt - right.createdAt || left.restorePointId.localeCompare(right.restorePointId));
     }
+    /** List pending Git checkpoint transitions directly from one storage directory. */
+    async listGitCheckpointJournalsInDir(workspaceDir, signal) {
+        const journals = [];
+        for (const filename of await safeJsonNames(join(workspaceDir, 'git-journals'))) {
+            throwIfAborted(signal);
+            const journal = parseGitCheckpointJournal(await readJson(join(workspaceDir, 'git-journals', filename)));
+            this.assertGitCheckpointJournalOwned(journal);
+            await this.assertGitCheckpointJournalWorkspaceIdentity(journal, workspaceDir);
+            if (filename !== `${journal.restorePointId}.json`) {
+                throw new ChangeLedgerError('STATE_CORRUPT', `Git checkpoint journal ${filename} does not match its restore-point id`);
+            }
+            journals.push(journal);
+        }
+        return journals;
+    }
     /** Remove one completed Git checkpoint transition journal. */
     async deleteGitCheckpointJournal(workspace, id) {
         validateRestorePointId(id);
@@ -396,15 +431,23 @@ export class LedgerStore {
     }
     /** List validated restore operations for one workspace. */
     async listOperations(workspace) {
+        const operations = await this.listOperationsInDir(this.workspaceDir(workspace));
+        for (const operation of operations) {
+            if (operation.workspace !== workspace) {
+                throw new ChangeLedgerError('STATE_CORRUPT', `operation ${operation.id} belongs to a different workspace`);
+            }
+        }
+        return operations;
+    }
+    /** List validated restore operations directly from one storage directory. */
+    async listOperationsInDir(workspaceDir, signal) {
         const operations = [];
-        for (const filename of await safeJsonNames(join(this.workspaceDir(workspace), 'operations'))) {
-            const operation = parseOperation(await readJson(join(this.workspaceDir(workspace), 'operations', filename)));
+        for (const filename of await safeJsonNames(join(workspaceDir, 'operations'))) {
+            throwIfAborted(signal);
+            const operation = parseOperation(await readJson(join(workspaceDir, 'operations', filename)));
             if (filename !== `${operation.id}.json`) {
                 throw new ChangeLedgerError('STATE_CORRUPT', `operation ${filename} does not match its persisted id ${operation.id}`);
             }
-            if (operation.workspace !== workspace) {
-                throw new ChangeLedgerError('STATE_CORRUPT', `operation ${filename} belongs to a different workspace`);
-            }
             operations.push(operation);
         }
         return operations.sort((left, right) => right.startedAt - left.startedAt || right.id.localeCompare(left.id));
@@ -419,16 +462,40 @@ export class LedgerStore {
         const referenced = new Set(additionalReferenced);
         for (const hash of referenced)
             validateBlobHash(hash);
-        for (const manifest of await this.listManifests(workspace, signal)) {
+        for (const manifest of await this.listManifestsInDir(this.workspaceDir(workspace), signal)) {
+            throwIfAborted(signal);
+            for (const entry of Object.values(manifest.entries)) {
+                if (entry.kind === 'file' && entry.provider !== 'git')
+                    referenced.add(entry.blob);
+            }
+        }
+        return this.sweepBlobs(this.workspaceDir(workspace), referenced, signal);
+    }
+    /** Delete blobs under one storage directory that no manifest in it references. */
+    async collectGarbageInDir(workspaceDir, signal) {
+        const referenced = new Set();
+        for (const manifest of await this.listManifestsInDir(workspaceDir, signal)) {
             throwIfAborted(signal);
             for (const entry of Object.values(manifest.entries)) {
                 if (entry.kind === 'file' && entry.provider !== 'git')
                     referenced.add(entry.blob);
             }
         }
+        return this.sweepBlobs(workspaceDir, referenced, signal);
+    }
+    /** Remove every persisted automatic-checkpoint skip marker under one storage directory. */
+    async clearTurnOutcomesInDir(workspaceDir) {
+        let removed = 0;
+        for (const filename of await safeJsonNames(join(workspaceDir, 'turn-outcomes'))) {
+            await unlink(join(workspaceDir, 'turn-outcomes', filename));
+            removed += 1;
+        }
+        return removed;
+    }
+    async sweepBlobs(workspaceDir, referenced, signal) {
         let deletedBlobs = 0;
         let retainedBlobs = 0;
-        const blobsRoot = join(this.workspaceDir(workspace), 'blobs');
+        const blobsRoot = join(workspaceDir, 'blobs');
         for (const prefix of await safeDirectoryNames(blobsRoot)) {
             throwIfAborted(signal);
             const prefixPath = join(blobsRoot, prefix);

package/lib/types/client/index.d.ts

@@ -37,14 +37,14 @@ interface RewindPortalBridgeProps {
 }
 interface SlotsLike {
     inject(name: string, install: () => unknown): void;
-    register(entry: {
+    register<I, P>(entry: {
         readonly name: string;
-        readonly id: string;
-        readonly order: number;
-        readonly inject: () => {
-            readonly openRestoredSession: (sessionId: string, promptText: string) => Promise<void>;
-        };
-    }, component: (props: RewindPortalBridgeProps) => ReactNode): () => void;
+        readonly id?: string;
+        readonly key?: string;
+        readonly order?: number;
+        readonly locale?: string;
+        readonly inject?: () => I;
+    }, component: (props: P) => ReactNode): () => void;
 }
 interface ClientContextLike {
     readonly slots: SlotsLike;
@@ -59,9 +59,69 @@ interface ClientContextLike {
             };
         };
     };
+    readonly settingsScope?: {
+        bind<T>(spec: {
+            readonly namespace: string;
+        }): SettingsScopeLike<T>;
+    };
     effect(setup: () => (() => void), label?: string): unknown;
 }
 type ChangeKind = 'added' | 'deleted' | 'modified' | 'mode-changed' | 'type-changed';
+/** Runtime-tunable Turn Rewind settings mirrored from the `turn-rewind` namespace. */
+export interface TurnRewindSettingsValue {
+    readonly maxRestorePoints: number;
+    readonly maxTurnCheckpointsPerSession: number;
+    readonly maxFiles: number;
+    readonly maxFileBytes: number;
+    readonly maxSnapshotBytes: number;
+    readonly planTtlMs: number;
+    readonly staleLockMs: number;
+    readonly turnCheckpointMode: 'off' | 'git-native' | 'legacy';
+    readonly turnCheckpointTimeoutMs: number;
+    readonly turnCheckpointMaxNewBytes: number;
+    readonly turnCheckpointTrust: 'fast' | 'strict';
+}
+/** Browser mirror of one settings namespace, as bound by `ctx.settingsScope`. */
+export interface SettingsScopeLike<T> {
+    getSnapshot(): SettingsScopeSnapshotLike<T>;
+    subscribe(listener: () => void): () => void;
+    set(field: string, value: unknown): Promise<void>;
+    unset(field: string): Promise<void>;
+}
+/** Sync snapshot shape shared by every settings scope. */
+export interface SettingsScopeSnapshotLike<T> {
+    readonly status: 'loading' | 'ready' | 'unavailable';
+    readonly value: T | undefined;
+    readonly base: unknown;
+    readonly user: unknown;
+    readonly revision: number | undefined;
+    readonly writable: boolean;
+    readonly mode: 'host' | 'memory';
+}
+/** One checkpoint row in the storage-management overview. */
+export interface ManageRestorePoint {
+    readonly id: string;
+    readonly kind: string;
+    readonly format: number;
+    readonly createdAt: number;
+    readonly totalBytes: number;
+    readonly fileCount: number;
+    readonly sessionId?: string;
+    readonly label?: string;
+}
+/** One workspace group in the storage-management overview. */
+export interface ManageWorkspace {
+    readonly workspace: string;
+    readonly totalBytes: number;
+    readonly recoveryCount: number;
+    readonly restorePoints: readonly ManageRestorePoint[];
+}
+/** Storage-management overview served by `/turn-rewind/manage`. */
+export interface ManageOverview {
+    readonly storageDir: string;
+    readonly totalBytes: number;
+    readonly workspaces: readonly ManageWorkspace[];
+}
 /** Return the rewind anchor and editable text owned by one direct user message. */
 export declare function selectRewindMessage(node: ConversationNodeLike): RewindMatch | null;
 /** Browser plugin entry: bridge every direct user-message action row to the rewind UI. */
@@ -71,6 +131,13 @@ export declare function apply(ctx: ClientContextLike): void;
 export declare function RewindMessagePortals({ sessionId, openRestoredSession, useSession }: RewindPortalBridgeProps): ReactNode;
 /** User-message action and its review-first file/conversation restore dialog. */
 export declare function RewindMessageAction({ matched, sessionId, openRestoredSession }: RewindMessageActionProps): ReactNode;
+interface TurnRewindSettingsCardProps {
+    readonly scope: SettingsScopeLike<TurnRewindSettingsValue> | undefined;
+}
+/** Settings card for the `turn-rewind` namespace: runtime options plus checkpoint management. */
+export declare function TurnRewindSettingsCard({ scope }: TurnRewindSettingsCardProps): ReactNode;
+/** Format one byte count with human-friendly units. */
+export declare function formatBytes(bytes: number): string;
 /** Resolve one conversation node to its DOM row key and rewind match. */
 export declare function selectRewindMessageTarget(value: RewindNodeLike): {
     readonly matched: RewindMatch;

package/lib/types/engine.d.ts

@@ -1,14 +1,21 @@
 import { LedgerStore } from './store.js';
-import { type ChangeLedgerConfig, type RecoverySummary, type ResolvedChangeLedgerConfig, type RestorePlan, type RestorePointInspection, type RestorePointManifest, type RestorePointSummary, type RestoreResult } from './types.js';
+import { type ChangeLedgerConfig, type RecoverySummary, type ResolvedChangeLedgerConfig, type RestorePlan, type RestorePointInspection, type RestorePointManifest, type RestorePointSummary, type RestoreResult, type WorkspaceOverview, type WorkspacePurgeReport } from './types.js';
 /** Persistent workspace change-set engine, independent of the DSH tool adapter. */
 export declare class ChangeLedgerEngine {
-    readonly config: ResolvedChangeLedgerConfig;
+    private readonly currentConfig;
     readonly store: LedgerStore;
     private readonly plans;
     private readonly activePlans;
     private readonly ready;
     /** Build an engine and start crash-journal reconciliation. */
     constructor(config?: ChangeLedgerConfig);
+    /** Currently resolved configuration; runtime-tunable fields update in place. */
+    get config(): ResolvedChangeLedgerConfig;
+    /**
+     * Swap runtime-tunable configuration (limits, modes, timeouts, trust) in place.
+     * The storage root must never move once the engine owns locks and journals.
+     */
+    updateConfig(config: ChangeLedgerConfig): void;
     /** Wait for startup reconciliation and return the number of interrupted journals found. */
     initialize(): Promise<number>;
     private initializeStore;
@@ -105,6 +112,18 @@ export declare class ChangeLedgerEngine {
         readonly cwd: string;
         readonly signal?: AbortSignal;
     }): Promise<RecoverySummary[]>;
+    /** Inventory every workspace this storage root has ever persisted state for. */
+    listWorkspaces(options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<WorkspaceOverview[]>;
+    /** Delete unprotected restore points recorded for one workspace and collect unused blobs. */
+    purgeWorkspace(options: {
+        readonly workspace: string;
+        /** Restrict the purge to these restore points; protection rules still apply. */
+        readonly restorePointIds?: readonly string[];
+        readonly signal?: AbortSignal;
+    }): Promise<WorkspacePurgeReport>;
+    private purgeWorkspaceDir;
     private createLocked;
     private restorePaths;
     private assertPathFresh;

package/lib/types/index.d.ts

@@ -8,6 +8,7 @@ import type { ChangeLedgerConfig } from './types.js';
 export * from './engine.js';
 export * from './errors.js';
 export * from './rewind-host.js';
+export * from './settings.js';
 export * from './types.js';
 declare module '@deepseek-ai/cordis' {
     interface Context {
@@ -39,5 +40,11 @@ export declare class ChangeLedgerService {
     delete(options: Parameters<ChangeLedgerEngine['delete']>[0]): ReturnType<ChangeLedgerEngine['delete']>;
     /** List interrupted restore operations and their rescue points. */
     listRecovery(options: Parameters<ChangeLedgerEngine['listRecovery']>[0]): ReturnType<ChangeLedgerEngine['listRecovery']>;
+    /** Inventory every workspace this storage root has persisted state for. */
+    listWorkspaces(options?: Parameters<ChangeLedgerEngine['listWorkspaces']>[0]): ReturnType<ChangeLedgerEngine['listWorkspaces']>;
+    /** Delete unprotected restore points recorded for one workspace. */
+    purgeWorkspace(options: Parameters<ChangeLedgerEngine['purgeWorkspace']>[0]): ReturnType<ChangeLedgerEngine['purgeWorkspace']>;
+    /** Swap runtime-tunable configuration; the storage root must stay fixed. */
+    updateConfig(config: ChangeLedgerConfig): void;
 }
 export default ChangeLedgerService;

package/lib/types/rewind-host.d.ts

@@ -20,6 +20,11 @@ interface AgentLike {
     readonly status: 'idle' | 'running';
     readonly session: SessionLike;
 }
+interface ToolExecutionLike {
+    readonly agent?: AgentLike;
+    readonly parent?: symbol;
+    readonly signal: AbortSignal;
+}
 interface AgentsLike {
     list(): AgentLike[];
 }
@@ -106,10 +111,11 @@ declare module '@deepseek-ai/cordis' {
             readonly step: number;
             readonly signal: AbortSignal;
         }, next: () => Promise<unknown>): Promise<unknown>;
+        'tools/execute'(exec: ToolExecutionLike, next: () => Promise<unknown>): Promise<unknown>;
     }
 }
 export declare const REWIND_HTTP_PATH = "/turn-rewind";
-/** Capture each turn before its opening user message can trigger model or tool work. */
+/** Capture each turn beside model work and gate root tool side effects on its bounded outcome. */
 export declare class TurnCheckpointCoordinator {
     private readonly engine;
     private readonly captures;
@@ -118,7 +124,7 @@ export declare class TurnCheckpointCoordinator {
     private readonly skips;
     private readonly workspaceTails;
     constructor(engine: ChangeLedgerEngine);
-    /** Install the first-step gate; checkpoint failures are recorded but never reject the user turn. */
+    /** Keep sidecar checkpoint work out of the Agent response waterfall. */
     install(ctx: Context): void;
     /** Current capture state for a session turn when no durable checkpoint exists yet. */
     state(sessionId: string, turn: number): {
@@ -126,7 +132,10 @@ export declare class TurnCheckpointCoordinator {
         readonly error?: string;
         readonly reason?: string;
     };
+    private startCapture;
     private capture;
+    /** Wait only for the bounded checkpoint outcome of the Agent's open turn. */
+    private waitForOpenTurn;
     private serializeWorkspace;
     private recordFailure;
 }
@@ -136,4 +145,9 @@ export declare function installRewindHttp(ctx: Context, engine: ChangeLedgerEngi
 export declare function createRewindHttpHandler(ctx: Pick<Context, 'sessions' | 'sessionQuery' | 'apiProxy'> & {
     readonly agents?: AgentsLike;
 }, engine: ChangeLedgerEngine, coordinator: TurnCheckpointCoordinator): (request: HttpRequestLike, response: HttpResponseLike) => Promise<void>;
+export declare const MANAGE_HTTP_PATH = "/turn-rewind/manage";
+/** Register the same-origin storage-management endpoint consumed by the settings card. */
+export declare function installManageHttp(ctx: Context, engine: ChangeLedgerEngine): void;
+/** Build the storage-management route as a testable unit. */
+export declare function createManageHttpHandler(engine: ChangeLedgerEngine): (request: HttpRequestLike, response: HttpResponseLike) => Promise<void>;
 export {};

package/lib/types/settings.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Runtime settings surface for Turn Rewind on the DSH web settings page.
+ * @module @anionex/dsh-turn-rewind
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type ChangeLedgerEngine } from './engine.js';
+import type { ChangeLedgerConfig } from './types.js';
+/** Namespace join key shared by the host section and the browser settings card. */
+export declare const TURN_REWIND_SETTINGS_NAMESPACE: Branded<"SettingsNamespace">;
+/** Every runtime-tunable field of {@link ChangeLedgerConfig}; `storageDir` stays config-layer only. */
+export interface TurnRewindSettings {
+    /** Maximum user and rescue restore points retained per workspace. */
+    maxRestorePoints: number;
+    /** Maximum automatic turn checkpoints retained per session. */
+    maxTurnCheckpointsPerSession: number;
+    /** Maximum number of files in one restore point. */
+    maxFiles: number;
+    /** Maximum bytes read from one regular file. */
+    maxFileBytes: number;
+    /** Maximum aggregate regular-file bytes in one restore point. */
+    maxSnapshotBytes: number;
+    /** Restore-plan lifetime in milliseconds. */
+    planTtlMs: number;
+    /** Age after which a lock whose owner is gone may be reclaimed. */
+    staleLockMs: number;
+    /** Automatic turn-checkpoint implementation; `off` records durable skips instead. */
+    turnCheckpointMode: 'off' | 'git-native' | 'legacy';
+    /** Maximum time one automatic checkpoint may block the first Agent step. */
+    turnCheckpointTimeoutMs: number;
+    /** Maximum uncached worktree bytes read by one automatic Git-native checkpoint. */
+    turnCheckpointMaxNewBytes: number;
+    /** Fast trusts fenced Git/stat metadata; strict rereads every eligible path. */
+    turnCheckpointTrust: 'fast' | 'strict';
+}
+/** Schemastery schema for the `turn-rewind` settings namespace. */
+export declare const TurnRewindSettingsSchema: z<TurnRewindSettings>;
+/**
+ * Register the `turn-rewind` settings namespace and apply its resolved value to the
+ * running engine. The composition entry (from `cordis.patch.yml`) is the base layer;
+ * the user layer persists through the DSH settings provider. `storageDir` is never
+ * carried by the namespace: the storage root must not move while the engine runs.
+ */
+export declare function installTurnRewindSettings(ctx: Context, config: ChangeLedgerConfig, engine: ChangeLedgerEngine): void;

package/lib/types/store.d.ts

@@ -35,6 +35,8 @@ export declare class LedgerStore {
         readonly gitDir: string;
         readonly worktreeId: string;
     }, signal?: AbortSignal): Promise<() => Promise<void>>;
+    /** Acquire only the durable directory lock when the recorded worktree is no longer available. */
+    acquireWorkspaceDir(workspaceDir: string, workspace: string, signal?: AbortSignal): Promise<() => Promise<void>>;
     private acquireOne;
     /** Persist a blob if it is not already present, and verify existing content. */
     putBlob(workspace: string, hash: string, content: Buffer): Promise<void>;
@@ -46,12 +48,20 @@ export declare class LedgerStore {
     readManifest(workspace: string, id: string): Promise<RestorePointManifest>;
     /** List all validated restore points for one workspace, newest first. */
     listManifests(workspace: string, signal?: AbortSignal): Promise<RestorePointManifest[]>;
+    /** List validated manifests directly from one storage directory, newest first. */
+    listManifestsInDir(workspaceDir: string, signal?: AbortSignal): Promise<RestorePointManifest[]>;
     /** Delete one restore-point manifest. Blobs remain until garbage collection succeeds. */
     deleteManifest(workspace: string, id: string): Promise<void>;
+    /** Delete one restore-point manifest directly from its storage directory. */
+    deleteManifestInDir(workspaceDir: string, id: string): Promise<void>;
     /** Persist the intent needed to finish or roll back a Git ref/manifest transition after a crash. */
     writeGitCheckpointJournal(action: GitCheckpointJournal['action'], manifest: RestorePointManifestV2): Promise<void>;
+    /** List every persisted workspace directory under this storage root. */
+    listWorkspaceDirs(signal?: AbortSignal): Promise<string[]>;
     /** List every pending Git checkpoint transition across this storage root. */
     listGitCheckpointJournals(): Promise<GitCheckpointJournal[]>;
+    /** List pending Git checkpoint transitions directly from one storage directory. */
+    listGitCheckpointJournalsInDir(workspaceDir: string, signal?: AbortSignal): Promise<GitCheckpointJournal[]>;
     /** Remove one completed Git checkpoint transition journal. */
     deleteGitCheckpointJournal(workspace: string, id: string): Promise<void>;
     /** Persist one explicit automatic-checkpoint skip so the UI survives restarts. */
@@ -68,6 +78,8 @@ export declare class LedgerStore {
     writeOperation(operation: RestoreOperation): Promise<void>;
     /** List validated restore operations for one workspace. */
     listOperations(workspace: string): Promise<RestoreOperation[]>;
+    /** List validated restore operations directly from one storage directory. */
+    listOperationsInDir(workspaceDir: string, signal?: AbortSignal): Promise<RestoreOperation[]>;
     /** Return whether an incomplete operation still references a restore point. */
     isReferencedByRecovery(workspace: string, restorePointId: string): Promise<boolean>;
     /** Delete blobs not referenced by any remaining manifest. */
@@ -75,6 +87,14 @@ export declare class LedgerStore {
         deletedBlobs: number;
         retainedBlobs: number;
     }>;
+    /** Delete blobs under one storage directory that no manifest in it references. */
+    collectGarbageInDir(workspaceDir: string, signal?: AbortSignal): Promise<{
+        deletedBlobs: number;
+        retainedBlobs: number;
+    }>;
+    /** Remove every persisted automatic-checkpoint skip marker under one storage directory. */
+    clearTurnOutcomesInDir(workspaceDir: string): Promise<number>;
+    private sweepBlobs;
     /** Finish a prior bounded legacy capture's orphan cleanup, if one is pending. */
     reconcileSnapshotCleanup(workspace: string, signal?: AbortSignal): Promise<boolean>;
     private workspaceDir;

package/lib/types/types.d.ts

@@ -218,3 +218,22 @@ export interface RecoverySummary {
     readonly error?: string;
     readonly rollbackError?: string;
 }
+/** Aggregated checkpoint inventory for one workspace, addressed by its recorded path. */
+export interface WorkspaceOverview {
+    /** Canonical workspace path recorded in the persisted manifests. */
+    readonly workspace: string;
+    /** Every restore point stored for the workspace, newest first. */
+    readonly restorePoints: readonly RestorePointSummary[];
+    /** Sum of every restore point's logical bytes. */
+    readonly totalBytes: number;
+    /** Incomplete restore operations that still reference this workspace's points. */
+    readonly recoveryCount: number;
+}
+/** Aggregate cleanup report for one workspace purge. */
+export interface WorkspacePurgeReport {
+    readonly workspace: string;
+    readonly deletedRestorePoints: number;
+    readonly retainedRestorePoints: number;
+    readonly deletedBlobs: number;
+    readonly retainedBlobs: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anionex/dsh-turn-rewind",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Turn-level conversation and workspace rewind for DeepSeek Harness, powered by a persistent Change Ledger",
   "repository": {
     "type": "git",
@@ -55,7 +55,19 @@
       "platform": "web",
       "inject": [
         "@deepseek-ai/dsh-client-runtime",
-        "@deepseek-ai/dsh-client-ui-conversation"
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-settings-plugins"
+      ]
+    },
+    "compatibility": {
+      "dsh": ">=0.1.0-rc.8 <0.2.0",
+      "dshReleases": {
+        "0.1.0-rc.8": "compatible",
+        "0.1.1-rc.1": "compatible",
+        "0.1.1-rc.2": "compatible"
+      },
+      "profiles": [
+        "web"
       ]
     }
   },
@@ -77,10 +89,14 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-settings": ">=0.1.0-rc.8 <0.2.0",
+    "@deepseek-ai/schemastery": "^3.18.1"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-settings": ">=0.1.0-rc.8 <0.2.0",
+    "@deepseek-ai/schemastery": "^3.18.1",
     "@types/node": "^24.0.0",
     "@types/react": "18.3.28",
     "react": "18.3.1",