@wrongstack/core 0.272.2 → 0.273.0

package/dist/{index-DqW4o62H.d.ts → worktree-manager-BDuXTaWL.d.ts}

@@ -1,16 +1,4 @@
-import { T as Token, a as Renderer, S as SystemPromptBuilder, H as HookRegistry } from './pipeline-Ckkn3AOA.js';
-import { E as EventBus, c as MemoryStore, B as BrainArbiter } from './brain-etbcbRwV.js';
-import { C as Compactor } from './compactor-72ug-ZRB.js';
-import { k as ConfigLoader, j as ConfigStore, M as ModelsRegistry } from './config-rRS8yorV.js';
-import { E as ErrorHandler, R as RetryPolicy } from './retry-policy-BV7nzeAd.js';
-import { I as InputReader } from './input-reader-E-ffP2ee.js';
-import { L as Logger } from './logger-B63L5bTg.js';
-import { M as ModeStore } from './mode-CZlO9iU1.js';
-import { P as PathResolver } from './path-resolver-CPRj4bFY.js';
-import { P as PermissionPolicy, S as SecretScrubber } from './permission-CC7XFYWG.js';
-import { P as ProviderRunner } from './provider-runner-zVOn1p67.js';
-import { e as TokenCounter, k as SessionStore } from './context-Dw55zZ_Q.js';
-import { S as SkillLoader } from './skill-DGIXCtdv.js';
+import { E as EventBus } from './brain-BxN2k2HP.js';
 
 /**
  * Lifecycle of a single worktree handle.
@@ -115,6 +103,52 @@ declare class WorktreeManager {
     }>;
     /** Merge the worktree branch back into the base branch (squash by default). */
     merge(handle: WorktreeHandle, opts?: MergeOpts): Promise<MergeResult>;
+    /**
+     * Current tip SHA of a handle's base branch (without checking it out). Capture
+     * this before a merge so a regressed merge can be reverted to exactly this
+     * commit — unambiguous even when a squash produced no diff. Returns null on
+     * failure (caller then skips the revert).
+     */
+    baseHead(handle: WorktreeHandle): Promise<string | null>;
+    /**
+     * Hard-reset the base branch back to `sha` (a value previously returned by
+     * {@link baseHead}). Used to undo a squash-merge whose integrated result failed
+     * re-verification, so an auto-resolved-but-broken merge never sticks on base.
+     * Safe because SDD merges are serialized — no other commit lands in between.
+     */
+    revertBaseTo(handle: WorktreeHandle, sha: string): Promise<boolean>;
+    /**
+     * Current base branch + tip SHA, captured WITHOUT a handle. The SDD run calls
+     * this once at start so a later rollback knows which branch the run's squash
+     * commits landed on. Returns null when not in a usable git state.
+     */
+    currentBase(): Promise<{
+        branch: string;
+        sha: string;
+    } | null>;
+    /**
+     * Force-remove EVERY managed worktree + branch this project owns, without
+     * relying on the in-memory `handles` map — so it works post-run (a fresh
+     * manager can clean up a previous run's leftovers). Enumerates
+     * `git worktree list --porcelain`, removes every checkout living under the
+     * `.wrongstack/worktrees` root, deletes every `wstack/ap/*` branch, then prunes.
+     * Returns the number of worktrees removed. Never throws — best-effort cleanup.
+     */
+    cleanupAllManaged(): Promise<{
+        removed: number;
+    }>;
+    /**
+     * Undo a run's squash commits by reverting each (newest → oldest) on the base
+     * branch — history-preserving, never a destructive reset. Refuses on a dirty
+     * working tree (so uncommitted work is never clobbered) and aborts cleanly if a
+     * revert conflicts, reporting which SHA. `shas` are the run commit SHAs in the
+     * order they landed; this reverses them. Returns the count reverted.
+     */
+    revertCommits(baseBranch: string, shas: string[]): Promise<{
+        ok: boolean;
+        reverted: number;
+        reason?: string;
+    }>;
     /**
      * Run the caller-supplied resolver against a conflicted squash-merge, then
      * commit if it cleared every marker. Returns a successful `MergeResult` on a
@@ -162,80 +196,4 @@ declare class WorktreeManager {
 /** Throw if `dir` resolves outside `projectRoot`. */
 declare function assertSafePath(dir: string, projectRoot: string): void;
 
-declare const TOKENS: {
-    readonly Logger: Token<Logger>;
-    readonly TokenCounter: Token<TokenCounter>;
-    readonly SessionStore: Token<SessionStore>;
-    readonly MemoryStore: Token<MemoryStore>;
-    readonly PermissionPolicy: Token<PermissionPolicy>;
-    readonly Compactor: Token<Compactor>;
-    readonly PathResolver: Token<PathResolver>;
-    readonly ConfigLoader: Token<ConfigLoader>;
-    readonly ConfigStore: Token<ConfigStore>;
-    readonly Renderer: Token<Renderer>;
-    readonly InputReader: Token<InputReader>;
-    readonly ErrorHandler: Token<ErrorHandler>;
-    readonly RetryPolicy: Token<RetryPolicy>;
-    readonly SkillLoader: Token<SkillLoader>;
-    readonly SystemPromptBuilder: Token<SystemPromptBuilder>;
-    readonly SecretScrubber: Token<SecretScrubber>;
-    readonly ModelsRegistry: Token<ModelsRegistry>;
-    readonly ModeStore: Token<ModeStore>;
-    /** Replaces the entire provider call layer — retry, streaming, tracing. */
-    readonly ProviderRunner: Token<ProviderRunner>;
-    /** Optional git-worktree lifecycle manager (per-phase isolation in AutoPhase). */
-    readonly WorktreeManager: Token<WorktreeManager>;
-    /** Optional global Brain arbiter for policy/decision escalation. */
-    readonly BrainArbiter: Token<BrainArbiter>;
-    /** Lifecycle hook registry (shell + in-process hooks). */
-    readonly HookRegistry: Token<HookRegistry>;
-};
-
-/**
- * RunController centralises abort + cleanup for a single agent run. It
- * wraps a single AbortController and exposes a registry of teardown
- * hooks that fire (LIFO, exactly once) when the run aborts OR ends
- * normally. Anyone holding the controller can:
- *
- *   - read `signal` to bail out cooperatively
- *   - call `abort(reason?)` to abort the run
- *   - call `onAbort(fn)` to register a cleanup hook
- *   - call `dispose()` when the run ends normally — this fires the
- *     hooks too, so cleanup runs regardless of outcome
- *
- * Hooks must be idempotent and synchronous-or-quick. Errors thrown
- * inside hooks are caught and surfaced through `errorSink` (or the
- * console as a last resort) so one bad hook can't block the others.
- */
-interface RunControllerOptions {
-    /** Optional parent signal — abort propagates from parent → this. */
-    parentSignal?: AbortSignal | undefined;
-    /** Receives errors thrown by cleanup hooks. Defaults to console.warn. */
-    errorSink?: (err: unknown, where: string) => void;
-}
-declare class RunController {
-    private readonly ctrl;
-    private readonly hooks;
-    private disposed;
-    private hooksDrained;
-    private readonly errorSink;
-    constructor(opts?: RunControllerOptions);
-    get signal(): AbortSignal;
-    get aborted(): boolean;
-    abort(reason?: unknown): void;
-    /**
-     * Register a teardown hook. Returns an unsubscribe function so callers
-     * can opt out before the hook fires (e.g. when a tool finishes cleanly
-     * before abort happens).
-     */
-    onAbort(fn: () => void | Promise<void>): () => void;
-    /**
-     * Fire cleanup hooks and tear down listeners — called when the run
-     * ends *normally* so cleanup happens regardless of outcome. Subsequent
-     * aborts become no-ops.
-     */
-    dispose(): Promise<void>;
-    private runHooks;
-}
-
-export { type AllocateOpts as A, type MergeOpts as M, RunController as R, TOKENS as T, WorktreeManager as W, type MergeResult as a, type RunControllerOptions as b, type WorktreeHandle as c, type WorktreeManagerOptions as d, type RunResult as e, type WorktreeStatus as f, assertSafePath as g };
+export { type AllocateOpts as A, type MergeOpts as M, type RunResult as R, WorktreeManager as W, type MergeResult as a, type WorktreeHandle as b, type WorktreeManagerOptions as c, type WorktreeStatus as d, assertSafePath as e };

package/dist/{wstack-paths-hOpNLmvf.d.ts → wstack-paths-BqkDAkoh.d.ts}

@@ -79,6 +79,8 @@ interface WstackPaths {
     projectPlan: string;
     /** ~/.wrongstack/projects/<hash>/autophase — AutoPhase phase-graph JSON files */
     projectAutophase: string;
+    /** ~/.wrongstack/projects/<hash>/sdd-boards — live SDD board snapshots + JSONL event logs */
+    projectSddBoards: string;
     /** ~/.wrongstack/sync.json — CloudSync configuration */
     syncConfig: string;
     /** Function to get the status.json path for a project given its hash. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/core",
-  "version": "0.272.2",
+  "version": "0.273.0",
   "license": "MIT",
   "description": "WrongStack core: kernel, types, defaults, and shared utilities for the WrongStack CLI agent.",
   "repository": {