@wrongstack/core 0.257.2 → 0.264.0

package/dist/{pipeline-JG8XoudC.d.ts → pipeline-CXCeMz8J.d.ts}

@@ -1,5 +1,5 @@
-import { T as Tool, n as TextBlock, g as ContentBlock } from './context-CGdgA0q6.js';
-import { H as HookEvent, e as HookMatcher, I as InProcessHook, S as ShellHook, f as HookEntry } from './config-DuAu23zm.js';
+import { T as Tool, n as TextBlock, g as ContentBlock } from './context-BGSpZNSE.js';
+import { H as HookEvent, e as HookMatcher, I as InProcessHook, S as ShellHook, f as HookEntry } from './config-Dz2F3H2K.js';
 
 /**
  * Mailbox — persistent inter-agent messaging system with cross-session support.
@@ -196,6 +196,18 @@ interface MailboxAckInput {
     /** Optional outcome summary. */
     outcome?: string | undefined;
 }
+/**
+ * Batch acknowledgment input — applies a batch of acks under a single file
+ * lock + single file rewrite. Each entry has the same shape as
+ * {@link MailboxAckInput} minus the per-batch defaults documented on
+ * `ackMany`. Use this when an agent is acking several fresh messages at
+ * once (the common case in the mailbox loop) — it collapses N full-file
+ * rewrites into one.
+ */
+interface MailboxAckBatchInput {
+    /** Ack entries to apply. */
+    acks: MailboxAckInput[];
+}
 interface AgentRegistrationInput {
     agentId: string;
     sessionId: string;
@@ -239,6 +251,28 @@ interface AgentHeartbeatInput {
     iterations?: number | undefined;
     toolCalls?: number | undefined;
 }
+interface PurgeOptions {
+    /**
+     * Purge completed messages older than this many milliseconds.
+     * Default: 1 day (86_400_000 ms)
+     */
+    completedMaxAgeMs?: number | undefined;
+    /**
+     * Purge incomplete messages older than this many milliseconds.
+     * Default: 7 days (604_800_000 ms)
+     */
+    incompleteMaxAgeMs?: number | undefined;
+}
+interface PurgeResult {
+    /** Messages removed because they were completed and too old. */
+    completedPurged: number;
+    /** Messages removed because they were incomplete and too old. */
+    incompletePurged: number;
+    /** Total messages removed. */
+    totalPurged: number;
+    /** Messages remaining in the mailbox after purge. */
+    remaining: number;
+}
 interface Mailbox {
     /** Send a message. Returns the created message. */
     send(input: MailboxSendInput): Promise<MailboxMessage>;
@@ -246,6 +280,17 @@ interface Mailbox {
     query(query: MailboxQuery): Promise<MailboxMessage[]>;
     /** Acknowledge a message (read/complete). Returns updated message. */
     ack(input: MailboxAckInput): Promise<MailboxMessage | null>;
+    /**
+     * Acknowledge many messages in one shot. Acquires the file lock once and
+     * rewrites the message file once, regardless of how many acks are in the
+     * batch. Returns the messages that were actually updated (messages whose
+     * ids are not in the file are skipped silently).
+     *
+     * This is the preferred path when an agent has multiple fresh messages
+     * to receipt at once — the per-message {@link ack} path does a full
+     * read-modify-rewrite of the mailbox file for every call.
+     */
+    ackMany(input: MailboxAckBatchInput): Promise<MailboxMessage[]>;
     /** Get a snapshot of online/offline agents and their current tasks. */
     getAgentStatuses(): Promise<MailboxAgentStatus[]>;
     /**
@@ -275,6 +320,16 @@ interface Mailbox {
      * Agents and read receipts are preserved; only messages are cleared.
      */
     clearAll(): Promise<void>;
+    /**
+     * Purge orphaned and stale messages from the mailbox.
+     *
+     * Stale messages are:
+     *  - Completed messages older than `completedMaxAgeMs` (default: 1 day)
+     *  - Incomplete messages older than `incompleteMaxAgeMs` (default: 7 days)
+     *
+     * This does NOT touch agent registrations or client registry.
+     */
+    purgeStale(opts?: PurgeOptions): Promise<PurgeResult>;
     /**
      * Register a client (REPL/TUI/WebUI). Called once per client on startup.
      * Subsequent calls are idempotent — they update lastSeenAt.
@@ -530,4 +585,4 @@ declare class Pipeline<T> {
     private ensureUnique;
 }
 
-export { type AgentRegistrationInput as A, type BuildContext as B, Container as C, type Decorator as D, type Factory as F, HookRegistry as H, type MiddlewareHandler as M, type NextFn as N, Pipeline as P, type ReadonlyPipeline as R, type SystemPromptBuilder as S, type Token as T, type Renderer as a, type Mailbox as b, type MailboxSendInput as c, type MailboxMessage as d, type MailboxQuery as e, type MailboxAckInput as f, type MailboxAgentStatus as g, type AgentHeartbeatInput as h, type ClientRegistrationInput as i, type ClientHeartbeatInput as j, type ClientStatus as k, type MailboxMessageType as l, type MailboxTaskContext as m, type ReadReceipts as n, type RegisteredAgent as o, normalizeRecipient as p, type ModelCapabilities as q, type BindOptions as r, type Middleware as s, type PipelineOptions as t, hookMatcherMatches as u };
+export { type AgentHeartbeatInput as A, type BuildContext as B, Container as C, type Decorator as D, type Factory as F, HookRegistry as H, type MiddlewareHandler as M, type NextFn as N, Pipeline as P, type ReadonlyPipeline as R, type SystemPromptBuilder as S, type Token as T, type Renderer as a, type ModelCapabilities as b, type Mailbox as c, type MailboxMessage as d, type AgentRegistrationInput as e, type BindOptions as f, type MailboxAckInput as g, type MailboxAgentStatus as h, type MailboxMessageType as i, type MailboxQuery as j, type MailboxSendInput as k, type MailboxTaskContext as l, type Middleware as m, type PipelineOptions as n, type ReadReceipts as o, type RegisteredAgent as p, hookMatcherMatches as q, normalizeRecipient as r, type MailboxAckBatchInput as s, type PurgeOptions as t, type PurgeResult as u, type ClientRegistrationInput as v, type ClientHeartbeatInput as w, type ClientStatus as x };

package/dist/{plan-templates-DPiQMkBz.d.ts → plan-templates-BvzRBkJc.d.ts}

@@ -1,9 +1,9 @@
-import { E as EventBus, M as MemoryScope, k as MemoryEntry, l as MemoryStore, m as MemoryRelevanceContext, S as ScoredEntry } from './brain-TjEEwSpw.js';
-import { S as SecretScrubber } from './permission-CwBBpCoF.js';
-import { i as SessionStore, h as SessionMetadata, a as SessionWriter, p as ResumedSession, q as SessionData, r as SessionSummary, g as ContentBlock, S as SessionEvent, s as TodoItem, t as ConversationState } from './context-CGdgA0q6.js';
-import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-CqRvaL5v.js';
+import { E as EventBus, M as MemoryScope, b as MemoryEntry, c as MemoryStore, d as MemoryRelevanceContext, S as ScoredEntry } from './brain-O1IdKPaK.js';
+import { S as SecretScrubber } from './permission-4yvGmMRB.js';
+import { i as SessionStore, h as SessionMetadata, a as SessionWriter, p as ResumedSession, q as SessionData, r as SessionSummary, g as ContentBlock, S as SessionEvent, s as TodoItem, t as ConversationState } from './context-BGSpZNSE.js';
+import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-KdfVwkKP.js';
 import { W as WstackPaths } from './wstack-paths-CJjEwPXn.js';
-import { i as ConfigStore, h as Config, j as ConfigLoader, k as SyncConfig } from './config-DuAu23zm.js';
+import { i as ConfigStore, h as Config, j as ConfigLoader, k as SyncConfig } from './config-Dz2F3H2K.js';
 import { S as SecretVault } from './secret-vault-BJDY28ev.js';
 
 interface SessionStoreOptions {
@@ -25,6 +25,9 @@ declare class DefaultSessionStore implements SessionStore {
     private readonly events?;
     private readonly secretScrubber?;
     constructor(opts: SessionStoreOptions);
+    private emitRead;
+    private emitWrite;
+    private emitError;
     /** Absolute path to the session index file. */
     private get indexFile();
     /** Join session ID to its absolute path within the store directory. */
@@ -108,8 +111,12 @@ interface PersistedQueueItem {
  */
 declare class QueueStore {
     private readonly file;
+    private readonly events;
+    private readonly traceId;
     constructor(opts: {
         dir: string;
+        events?: EventBus;
+        traceId?: string;
     });
     write(items: PersistedQueueItem[]): Promise<void>;
     read(): Promise<PersistedQueueItem[]>;
@@ -198,6 +205,7 @@ interface MemoryStoreOptions {
 declare class DefaultMemoryStore implements MemoryStore {
     private readonly files;
     private readonly events?;
+    private traceId?;
     private readonly backend;
     /**
      * Per-scope serialization queue. `remember` / `forget` / `consolidate` /
@@ -249,7 +257,16 @@ declare class DefaultMemoryStore implements MemoryStore {
     forget(query: string, scope?: MemoryScope): Promise<number>;
     consolidate(scope: MemoryScope): Promise<void>;
     clear(scope?: MemoryScope): Promise<void>;
-    /** Mirror current memory content to the persistent backup directory. */
+    /**
+     * Return a new MemoryStore proxy that carries `traceId` on every storage
+     * event. The original store is left unchanged — callers that need a
+     * trace-decorated view (e.g. session-run tools) receive the proxy while
+     * the singleton remains trace-free for boot-time use.
+     *
+     * The proxy implements the full `MemoryStore` interface; all other
+     * properties (backend, etc.) are delegated to the original store.
+     */
+    withTraceId(traceId: string): MemoryStore;
     private mirrorBackup;
 }
 
@@ -296,12 +313,16 @@ interface ConfigLoaderOptions {
     vault?: SecretVault | undefined;
     /** Extra sources merged after the built-in layers. */
     sources?: ConfigSource[] | undefined;
+    events?: EventBus;
+    traceId?: string;
 }
 declare class DefaultConfigLoader implements ConfigLoader {
     private readonly paths;
     private readonly strict;
     private readonly vault;
     private readonly extraSources;
+    private readonly events;
+    private readonly traceId;
     constructor(opts: ConfigLoaderOptions);
     load(opts?: {
         cliFlags?: Partial<Config> | undefined;
@@ -544,12 +565,12 @@ type TodosCheckpointDetach = () => Promise<void>;
 /** Read a checkpoint from disk. Returns null when the file doesn't
  *  exist or is corrupt — callers treat both cases as "no prior state".
  */
-declare function loadTodosCheckpoint(filePath: string): Promise<TodoItem[] | null>;
+declare function loadTodosCheckpoint(filePath: string, events?: EventBus, traceId?: string): Promise<TodoItem[] | null>;
 /** Write the checkpoint atomically. Best-effort: a write failure is
  *  logged but does not throw — losing one checkpoint shouldn't bring
  *  down the agent run.
  */
-declare function saveTodosCheckpoint(filePath: string, sessionId: string, todos: readonly TodoItem[]): Promise<void>;
+declare function saveTodosCheckpoint(filePath: string, sessionId: string, todos: readonly TodoItem[], events?: EventBus, traceId?: string): Promise<void>;
 /**
  * Subscribe a `ConversationState` so every `todos_replaced` mutation
  * triggers an atomic write to disk. Returns the unsubscribe function.
@@ -558,7 +579,7 @@ declare function saveTodosCheckpoint(filePath: string, sessionId: string, todos:
  * marking three items done in the same tool call) coalesces into one
  * disk hit.
  */
-declare function attachTodosCheckpoint(state: ConversationState, filePath: string, sessionId: string): TodosCheckpointDetach;
+declare function attachTodosCheckpoint(state: ConversationState, filePath: string, sessionId: string, events?: EventBus, traceId?: string): TodosCheckpointDetach;
 
 /**
  * Plan items are the strategic counterpart to todos. Where `ctx.todos`
@@ -586,8 +607,8 @@ interface PlanFile {
     updatedAt: string;
     items: PlanItem[];
 }
-declare function loadPlan(filePath: string): Promise<PlanFile | null>;
-declare function savePlan(filePath: string, plan: PlanFile): Promise<void>;
+declare function loadPlan(filePath: string, events?: EventBus): Promise<PlanFile | null>;
+declare function savePlan(filePath: string, plan: PlanFile, events?: EventBus): Promise<void>;
 /** Create a new PlanFile when none exists on disk. */
 declare function emptyPlan(sessionId: string, title?: string): PlanFile;
 declare function addPlanItem(plan: PlanFile, title: string, details?: string | undefined): {

package/dist/{provider-runner-hM7EXlLI.d.ts → provider-runner-C5aQpDWE.d.ts}

@@ -1,8 +1,8 @@
-import { E as EventBus } from './brain-TjEEwSpw.js';
+import { E as EventBus } from './brain-O1IdKPaK.js';
 import { L as Logger } from './logger-B63L5bTg.js';
 import { T as Tracer } from './observability-D-HZN_mF.js';
-import { P as Provider, R as Request, C as Context, b as Response } from './context-CGdgA0q6.js';
-import { R as RetryPolicy } from './retry-policy-Tg7LXkoK.js';
+import { P as Provider, R as Request, C as Context, b as Response } from './context-BGSpZNSE.js';
+import { R as RetryPolicy } from './retry-policy-CFhdtRzz.js';
 
 /**
  * Options passed to a ProviderRunner when calling the provider.

package/dist/{retry-policy-Tg7LXkoK.d.ts → retry-policy-CFhdtRzz.d.ts}

@@ -1,4 +1,4 @@
-import { C as Context, b as Response, e as ProviderError } from './context-CGdgA0q6.js';
+import { C as Context, b as Response, e as ProviderError } from './context-BGSpZNSE.js';
 
 type RecoveryDecision = {
     /**

package/dist/sdd/index.d.ts

@@ -1,15 +1,15 @@
 import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../spec-TBi3Jr6T.js';
 import { d as TaskGraph, e as TaskNode, i as TaskFilter, j as TaskSort, c as TaskProgress, T as TaskType, a as TaskPriority } from '../task-graph-u1q9Jkyk.js';
-import { E as EventBus } from '../brain-TjEEwSpw.js';
-import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-US741uBH.js';
-import '../context-CGdgA0q6.js';
-import '../index-CitPrI3a.js';
+import { E as EventBus } from '../brain-O1IdKPaK.js';
+import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-c9DLkaas.js';
+import '../context-BGSpZNSE.js';
+import '../index-CbLSI66_.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-JG8XoudC.js';
-import '../config-DuAu23zm.js';
+import '../pipeline-CXCeMz8J.js';
+import '../config-Dz2F3H2K.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-CwBBpCoF.js';
-import '../retry-policy-Tg7LXkoK.js';
+import '../permission-4yvGmMRB.js';
+import '../retry-policy-CFhdtRzz.js';
 
 declare class SpecParser {
     parse(content: string): Specification;

package/dist/sdd/index.js

@@ -80,7 +80,12 @@ async function withFileLock(targetPath, fn, opts = {}) {
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
-      if (err.code !== "EEXIST") throw err;
+      const code = err.code;
+      if (code === "ENOENT") {
+        await fs.mkdir(dir, { recursive: true });
+        continue;
+      }
+      if (code !== "EEXIST") throw err;
       try {
         const stat2 = await fs.stat(lockPath);
         if (Date.now() - stat2.mtimeMs > staleMs) {
@@ -622,6 +627,35 @@ function topologicalSort(graph) {
   return result;
 }
 
+// src/utils/error.ts
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+
+// src/utils/assert-never.ts
+function assertNever(x, message) {
+  const err = new Error(
+    `Unhandled case: ${JSON.stringify(x)}`
+  );
+  err.name = "AssertNeverError";
+  throw err;
+}
+
 // src/types/errors.ts
 var ERROR_CODES = {
   // Provider
@@ -929,7 +963,7 @@ var TaskTracker = class {
       this.opts.onPersistError ? this.opts.onPersistError(err) : console.warn(JSON.stringify({
         level: "warn",
         event: "task_tracker.save_graph_failed",
-        message: err instanceof Error ? err.message : String(err),
+        message: toErrorMessage(err),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
     });
@@ -1358,16 +1392,6 @@ var TaskGraphStore = class {
   }
 };
 
-// src/utils/expect-defined.ts
-function expectDefined(value, label) {
-  if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
-    err.name = "ExpectDefinedError";
-    throw err;
-  }
-  return value;
-}
-
 // src/sdd/spec-builder.ts
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
@@ -1609,7 +1633,7 @@ var AISpecBuilder = class {
    *  ENOSPC / EACCES doesn't silently strand session edits in memory. */
   autoSave() {
     this.saveSession().catch((err) => {
-      const detail = err instanceof Error ? err.message : String(err);
+      const detail = toErrorMessage(err);
       process.emitWarning(
         `SpecBuilder autoSave failed: ${detail}`,
         "SpecBuilderWarning"
@@ -2021,11 +2045,6 @@ function templateToMarkdown(template, title) {
   return lines.join("\n");
 }
 
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
-}
-
 // src/sdd/task-visualizer.ts
 var STATUS_ICON = {
   pending: "\u25CB",
@@ -2348,15 +2367,6 @@ function computeParallelGroups(graph, blockedByMap) {
   return groups;
 }
 
-// src/utils/assert-never.ts
-function assertNever(x, message) {
-  const err = new Error(
-    `Unhandled case: ${JSON.stringify(x)}`
-  );
-  err.name = "AssertNeverError";
-  throw err;
-}
-
 // src/sdd/spec-versioning.ts
 var SpecVersioning = class {
   versions = /* @__PURE__ */ new Map();
@@ -3125,6 +3135,20 @@ var SubagentBudget = class _SubagentBudget {
 };
 
 // src/coordination/agent-subagent-runner.ts
+function withDisabledToolFiltering(factory) {
+  return async (config) => {
+    const result = await factory(config);
+    const disabled = config.disabledTools ?? [];
+    if (disabled.length === 0) return result;
+    const registry = result.agent.tools;
+    if (registry && typeof registry.unregister === "function") {
+      for (const toolName of disabled) {
+        registry.unregister(toolName);
+      }
+    }
+    return result;
+  };
+}
 function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
@@ -3402,7 +3426,7 @@ function classifySubagentError(err, hints = {}) {
     const baseMessage2 = err.describe();
     return providerErrorToSubagentError(err, baseMessage2, cause);
   }
-  const baseMessage = err instanceof Error ? err.message : String(err);
+  const baseMessage = toErrorMessage(err);
   if (err instanceof BudgetExceededError) {
     const map = {
       iterations: "budget_iterations",
@@ -7012,7 +7036,9 @@ var SddParallelRun = class {
       doneCondition: { type: "all_tasks_done" }
     };
     this.coordinator = new DefaultMultiAgentCoordinator(config);
-    const runner = makeAgentSubagentRunner({ factory: this.opts.subagentFactory ?? this.defaultFactory() });
+    const baseFactory = this.opts.subagentFactory ?? this.defaultFactory();
+    const filteredFactory = withDisabledToolFiltering(baseFactory);
+    const runner = makeAgentSubagentRunner({ factory: filteredFactory });
     this.coordinator.setRunner?.(runner);
   }
   defaultFactory() {
@@ -7054,7 +7080,9 @@ var SddParallelRun = class {
         id: subagentId,
         name: subagentId,
         role: "executor",
-        timeoutMs: this.timeoutMs
+        timeoutMs: this.timeoutMs,
+        // Disable delegation — subagents are leaf workers, not orchestrators
+        disabledTools: ["delegate"]
       })
     );
     const spawnResults = await Promise.all(spawns);
@@ -7099,7 +7127,7 @@ var SddParallelRun = class {
     const failCount = results.length - successCount;
     for (let i = 0; i < results.length; i++) {
       const result = expectDefined(results[i]);
-      const taskId = expectDefined(taskIds[i]);
+      const taskId = expectDefined(tasks[i]).id;
       if (result.status === "success") {
         this.opts.tracker.updateNodeStatus(taskId, "completed");
         this.retryMap.delete(taskId);