@wrongstack/core 0.303.0 → 0.305.1

package/dist/coordination/mailbox-project-server.js

@@ -2,10 +2,10 @@
 
 // src/coordination/mailbox-project-server.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import * as fs5 from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import * as net from "node:net";
 import * as path7 from "node:path";
+import { bindProjectEndpoint } from "@wrongstack/persistence";
 
 // src/kernel/events.ts
 var MAX_WILDCARDS = 500;
@@ -1173,17 +1173,9 @@ var MailboxEventEmitter = class {
 
 // src/coordination/mailbox-project-server-endpoint.ts
 import { createHash as createHash2 } from "node:crypto";
-import * as fs2 from "node:fs";
 import * as os2 from "node:os";
 import * as path4 from "node:path";
 
-// src/utils/socket-path.ts
-import {
-  assertUnixSocketPathWithinLimit,
-  checkUnixSocketPath,
-  unixSocketPathLimit
-} from "@wrongstack/persistence";
-
 // src/coordination/mailbox-project-server-protocol.ts
 var MAILBOX_PROJECT_SERVER_PROTOCOL_VERSION = 4;
 var MAILBOX_PROJECT_SERVER_MAX_FRAME_CHARS = 16 * 1024 * 1024;
@@ -1317,16 +1309,10 @@ function mailboxProjectServerEndpoint(projectDir2) {
 function mailboxProjectServerMetadataPath(projectDir2) {
   return path4.join(path4.resolve(projectDir2), MAILBOX_PROJECT_SERVER_METADATA_FILE);
 }
-function ensureMailboxProjectServerSocketDirectory(endpoint2) {
-  if (process.platform !== "win32") {
-    assertUnixSocketPathWithinLimit(endpoint2, "mailbox");
-    fs2.mkdirSync(path4.dirname(endpoint2), { recursive: true, mode: 448 });
-  }
-}
 
 // src/coordination/sqlite-mailbox.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs";
 import * as path6 from "node:path";
 
 // src/coordination/global-mailbox-completion.ts
@@ -2218,7 +2204,7 @@ function credentialRotate(db, transaction, credentialId, options) {
 }
 
 // src/coordination/sqlite-mailbox-schema.ts
-import * as fs3 from "node:fs";
+import * as fs2 from "node:fs";
 import { createRequire } from "node:module";
 import * as path5 from "node:path";
 
@@ -2473,7 +2459,7 @@ function migrateLegacyCredentials(ctx) {
   const legacyPath = path5.join(ctx.projectDir, CREDENTIAL_STORE_FILE);
   const credentials = [];
   try {
-    for (const line of fs3.readFileSync(legacyPath, "utf8").split(/\r?\n/u)) {
+    for (const line of fs2.readFileSync(legacyPath, "utf8").split(/\r?\n/u)) {
       if (!line.trim()) continue;
       try {
         const credential = JSON.parse(line);
@@ -2526,7 +2512,7 @@ function migrateLegacyFiles(ctx) {
 function readLegacyMessages(projectDir2) {
   try {
     return parseMailboxFile(
-      fs3.readFileSync(path5.join(projectDir2, GLOBAL_MAILBOX_FILE), "utf8")
+      fs2.readFileSync(path5.join(projectDir2, GLOBAL_MAILBOX_FILE), "utf8")
     );
   } catch (error) {
     if (error.code === "ENOENT") return [];
@@ -2535,7 +2521,7 @@ function readLegacyMessages(projectDir2) {
 }
 function readLegacyRegistry(filePath, parseEntry) {
   try {
-    const raw = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+    const raw = JSON.parse(fs2.readFileSync(filePath, "utf8"));
     const result = /* @__PURE__ */ new Map();
     for (const [id, value] of Object.entries(raw)) {
       const parsed = parseEntry(value);
@@ -2555,7 +2541,7 @@ var HEARTBEAT_TRACKING_TTL_MS = 30 * 6e4;
 var SqliteMailbox = class {
   constructor(projectDir2, events2, eventEmitter2) {
     this.projectDir = projectDir2;
-    fs4.mkdirSync(projectDir2, { recursive: true });
+    fs3.mkdirSync(projectDir2, { recursive: true });
     this.databasePath = path6.join(projectDir2, SQLITE_MAILBOX_FILE);
     this.messagePath = this.databasePath;
     this.events = events2;
@@ -3451,7 +3437,6 @@ async function stop(_reason) {
   }
   await stopMemoryWatchdog();
 }
-ensureMailboxProjectServerSocketDirectory(endpoint);
 var server = net.createServer((socket) => {
   if (stopping) {
     socket.destroy();
@@ -3481,42 +3466,28 @@ var leaseSweep = setInterval(() => {
   scheduleIdleStop();
 }, leaseSweepMs);
 leaseSweep.unref?.();
-var probingExistingEndpoint = false;
-function listenForOwnership() {
-  server.listen(endpoint);
-}
-server.on("error", (error) => {
-  if (error.code === "EADDRINUSE" && process.platform === "win32") {
+void (async () => {
+  const bind = await bindProjectEndpoint({ server, endpoint, service: "mailbox" });
+  if (bind.outcome === "already-owned") {
     process.exitCode = 0;
     return;
   }
-  if (error.code === "EADDRINUSE" && !probingExistingEndpoint) {
-    probingExistingEndpoint = true;
-    const probe = net.createConnection(endpoint);
-    probe.once("connect", () => {
-      probe.destroy();
-      process.exitCode = 0;
-    });
-    probe.once("error", () => {
-      probe.destroy();
-      try {
-        fs5.rmSync(endpoint, { force: true });
-      } catch {
-      }
-      probingExistingEndpoint = false;
-      listenForOwnership();
-    });
+  if (bind.outcome === "failed") {
+    process.stderr.write(`mailbox project server failed: ${bind.error.message}
+`);
+    process.exitCode = 1;
     return;
   }
-  process.exitCode = 1;
-});
-server.on("listening", () => {
-  if (process.platform !== "win32") {
-    try {
-      fs5.chmodSync(endpoint, 384);
-    } catch {
-    }
+  if (bind.reclaimedStaleEndpoint) {
+    process.stderr.write(`mailbox project server reclaimed stale endpoint ${endpoint}
+`);
   }
+  server.on("error", (error) => {
+    if (stopping) return;
+    process.stderr.write(`mailbox project server error: ${error.message}
+`);
+    process.exitCode = 1;
+  });
   try {
     mailbox = new SqliteMailbox(projectDir, events, eventEmitter);
   } catch {
@@ -3526,16 +3497,16 @@ server.on("listening", () => {
     return;
   }
   stopAutoCompact = mailbox.startAutoCompactTimer();
-  void writeMetadata().then(() => {
+  try {
+    await writeMetadata();
     markMetadataWritten?.();
     scheduleIdleStop();
-  }).catch(() => {
+  } catch {
     void stop("metadata-write-failed").finally(() => {
       process.exitCode = 1;
     });
-  });
-});
-listenForOwnership();
+  }
+})();
 for (const signal of ["SIGINT", "SIGTERM"]) {
   process.once(signal, () => {
     void stop(signal).finally(() => {

package/dist/core/agent-types.d.ts

@@ -2,17 +2,17 @@
  * Agent type definitions — extracted from agent.ts to break circular
  * dependencies and keep the Agent class focused on runtime logic.
  */
-import { Pipeline } from '../kernel/pipeline.js';
 import type { ExtensionRegistry } from '../extension/registry.js';
 import type { Container } from '../kernel/container.js';
 import type { EventBus } from '../kernel/events.js';
+import { Pipeline } from '../kernel/pipeline.js';
 import type { ProviderRegistry } from '../registry/provider-registry.js';
 import type { ToolRegistry } from '../registry/tool-registry.js';
 import type { ContentBlock, TextBlock, ToolResultBlock, ToolUseBlock } from '../types/blocks.js';
+import type { LoopDetectionConfig } from '../types/config.js';
 import type { WrongStackError } from '../types/errors.js';
 import type { Tracer } from '../types/observability.js';
 import type { PermissionPolicy } from '../types/permission.js';
-import type { LoopDetectionConfig } from '../types/config.js';
 import type { Request, Response } from '../types/provider.js';
 import type { Tool } from '../types/tool.js';
 import type { ToolExecutorLike } from '../types/tool-executor.js';
@@ -44,6 +44,8 @@ export interface AgentInit {
     perIterationOutputCapBytes?: number | undefined;
     autoExtendLimit?: boolean | undefined;
     autonomousContinue?: boolean | undefined;
+    /** Rebuild the host system prompt from the live direct/catalog tool surfaces before each run. */
+    refreshSystemPrompt?: boolean | undefined;
     confirmAwaiter?: import('../types/tool-executor.js').ConfirmAwaiter | undefined;
     permissionPolicy?: PermissionPolicy | undefined;
     tracer?: Tracer | undefined;

package/dist/core/agent.d.ts

@@ -33,6 +33,7 @@ export declare class Agent {
     /** Resolved loop-detector settings (see `tools.loopDetection`). */
     readonly loopDetection: ResolvedLoopDetectionConfig;
     private readonly autonomousContinue;
+    private readonly refreshSystemPrompt;
     readonly tracer: Tracer | undefined;
     readonly extensions: ExtensionRegistry;
     private readonly _toolHandler;

package/dist/core/context.d.ts

@@ -21,6 +21,17 @@ export interface TodoItem {
     kanbanBoardId?: string | undefined;
     /** Durable Kanban card represented by this todo row. */
     kanbanTaskId?: string | undefined;
+    /**
+     * Titles of the unfinished work this row waits on, derived from the Kanban
+     * card's dependencies. Always board-derived, never model-supplied.
+     *
+     * A blocked item is genuinely `pending` — it has not started — so this is an
+     * extra field rather than a fourth status. What was missing was never the
+     * state but the *reason*: the board computes readiness on every mutation,
+     * then the projection dropped it, leaving blocked work indistinguishable
+     * from ready work on screen and in the model's context.
+     */
+    blockedBy?: string[] | undefined;
 }
 export interface RunOptions {
     signal?: AbortSignal | undefined;
@@ -333,6 +344,10 @@ export declare class Context implements RunEnv {
     /** Wait until every exact conversation-state event queued so far is in the writer buffer. */
     flushConversationJournal(): Promise<void>;
     private conversationJournalBytes;
+    private _journalDropCount;
+    private _journalDropWarnAt;
+    /** Throttled notice that a conversation event never reached the journal. */
+    private warnConversationJournalDrop;
     private enqueueConversationJournal;
     private startConversationJournalDrain;
     get state(): ConversationState;

package/dist/core/conversation-state.d.ts

@@ -88,6 +88,20 @@ export declare class ConversationState {
      * cap determines the starting index for the sum but does not gate it.
      */
     private overflowCount;
+    /**
+     * Front eviction must not retain a `tool_result` after evicting the
+     * immediately preceding assistant `tool_use`. Long tool-heavy sessions sit
+     * at the retention cap, so an unsafe boundary would create a fresh orphan on
+     * nearly every append and make the request-time repair discard protocol
+     * history continuously.
+     *
+     * Move the boundary backward to retain the complete exchange for one more
+     * eviction cycle. Moving it forward would also drop non-protocol text/images
+     * that may share either message. The temporary one-message cap overshoot is
+     * the minimum lossless representation; once enough newer messages exist, the
+     * next eviction boundary naturally moves past both halves together.
+     */
+    private protocolSafeDropCount;
     /**
      * Append a content block to the trailing user message's content array.
      * Mutates only that one message (a single indexed assignment) — avoids

package/dist/core/fallback-profile-manager.d.ts

@@ -98,14 +98,60 @@ export declare class FallbackProfileManager {
         model: string;
     }): FallbackChain;
     /**
-     * Resolve every usable configured target as an uncapped last-resort chain.
+     * Resolve every usable configured target as a bounded last-resort chain.
      * Normal smart defaults stay bounded; callers append this only after the
-     * preferred chain and only when automatic fallback is enabled.
+     * preferred chain and only when automatic fallback is enabled. The cap
+     * ({@link MAX_LAST_RESORT_CANDIDATES}) prevents a config with many providers
+     * from producing a degenerate chain of doomed requests during a systemic
+     * outage — by this point the smart default, bridge, and default profile
+     * have already failed.
      */
     resolveAllConfigured(exclude?: {
         providerId: string;
         model: string;
     }): FallbackChain;
+    /**
+     * Effective cap for the last-resort append. Reads the user-configurable
+     * {@link Config.fallbackMaxLastResortCandidates} when set and valid;
+     * otherwise falls back to the compiled-in default
+     * {@link MAX_LAST_RESORT_CANDIDATES}.
+     */
+    private lastResortCap;
+    /**
+     * Build the complete fallback candidate chain shared by the agent-loop
+     * extension and the one-shot orchestrator. Centralizes the bridge → primary →
+     * selected → default-profile → all-configured ladder and the fromExplicitSource
+     * gate so both consumers produce identical ordering and depth semantics.
+     *
+     * Layering (each step deduped against all prior):
+     *  1. Bridge (emergency continuity route).
+     *  2. Configured primary, when the live context drifted from it.
+     *  3. The selected chain (explicit refs → named profile → smart default),
+     *     via {@link resolveEffective}.
+     *  4. The "default" profile — extra depth, ONLY when the chain was auto-derived.
+     *  5. Every other configured provider — last resort, ONLY when the chain was
+     *     auto-derived AND `effectiveFallbackAuto` is true.
+     *
+     * Returns the empty chain when `closedWorld` is true and no explicit
+     * refs/profile resolved — a model allowlist never leaks to unlisted models.
+     *
+     * @internal caller-aware options (primary, closedWorld) are accepted because
+     *   the agent loop has context the manager does not own; the resolution
+     *   pipeline itself is identical for both callers.
+     */
+    resolveCandidates(current: {
+        providerId: string;
+        model: string;
+    }, opts?: {
+        fallbackModels?: readonly string[] | undefined;
+        fallbackProfile?: string | undefined;
+        fallbackAuto?: boolean | undefined;
+        primary?: {
+            providerId: string;
+            model: string;
+        } | undefined;
+        closedWorld?: boolean | undefined;
+    }): FallbackChain;
     checkProvider(providerId: string): ProviderHealth;
     /**
      * Atomically replace the active immutable snapshot while preserving this
@@ -127,4 +173,26 @@ export declare class FallbackProfileManager {
      */
     private smartDefault;
 }
+/**
+ * Maximum number of candidates the last-resort append ({@link FallbackProfileManager.resolveAllConfigured})
+ * may produce. By the time this append fires, the smart default, the bridge, and the
+ * default profile have all failed — in a systemic outage every additional entry is a
+ * doomed request. The cap bounds the blast radius without starving legitimate diversity
+ * (3× the smart-default depth of 4). Exposed for tests and for callers that want to
+ * surface it in config tooling.
+ */
+export declare const MAX_LAST_RESORT_CANDIDATES = 12;
+/**
+ * Deduplicate fallback chain entries by `providerId/model`, dropping the
+ * current (already-active) model and any repeat. Preserves first-occurrence
+ * order so the layering produced by {@link FallbackProfileManager.resolveCandidates}
+ * determines which entry wins when the same model appears at multiple depths.
+ *
+ * Shared by both the agent-loop and one-shot paths so dedup semantics can never
+ * drift between them.
+ */
+export declare function dedupeChain(entries: readonly FallbackChainEntry[], current: {
+    providerId: string;
+    model: string;
+}): FallbackChain;
 //# sourceMappingURL=fallback-profile-manager.d.ts.map