@wrongstack/core 0.302.2 → 0.305.0

package/dist/kernel/events/agent-events.d.ts

@@ -139,6 +139,34 @@ export interface AgentEventMap {
          */
         transcriptPath?: string | undefined;
     };
+    /**
+     * A spawn resolved fewer skills than it selected. Emitted so a skill that
+     * silently failed to load — missing from the loader, gated by a capability
+     * the subagent lacks, or cut by the prompt budget — is observable instead of
+     * leaving the agent believing it received guidance it never got.
+     */
+    'subagent.skills.dropped': {
+        sessionId?: string | undefined;
+        role?: string | undefined;
+        /** Skills whose body (and project addendum) reached the prompt. */
+        selected: string[];
+        /** skill → reason it was dropped. */
+        dropped: Record<string, string>;
+    };
+    /**
+     * A background learning-distillation pass finished for a roster role.
+     * Emitted by the fleet host's auto-optimize scheduler so surfaces can show
+     * that an agent's skills were refined without a user action.
+     */
+    'agent.learning.optimized': {
+        sessionId?: string | undefined;
+        role: string;
+        trigger: string;
+        status: string;
+        /** Skill addenda refreshed by the pass. */
+        skills: string[];
+        error?: string | undefined;
+    };
     'subagent.task_started': {
         /** Parent/host session id. */
         sessionId?: string | undefined;

package/dist/plugin/index.js

@@ -2443,12 +2443,97 @@ var FallbackProfileManager = class {
     return this.resolveRefs([ref], exclude);
   }
   /**
-   * 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) {
-    return this.smartDefault(exclude, Number.POSITIVE_INFINITY);
+    return this.smartDefault(exclude, this.lastResortCap());
+  }
+  /**
+   * 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}.
+   */
+  lastResortCap() {
+    const configured = this.config.fallbackMaxLastResortCandidates;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured >= 0) {
+      return Math.floor(configured);
+    }
+    return MAX_LAST_RESORT_CANDIDATES;
+  }
+  /**
+   * 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, opts = {}) {
+    const configuredPrimary = opts.primary ?? {
+      providerId: this.config.provider,
+      model: this.config.model
+    };
+    const configFallbackAuto = this.config.fallbackAuto;
+    const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
+    const explicitRefs = opts.fallbackModels ?? this.config.fallbackModels;
+    const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && this.resolveRefs(explicitRefs, current).length > 0;
+    const profileUsable = opts.fallbackProfile !== void 0 && this.hasProfile(opts.fallbackProfile) && this.resolve(opts.fallbackProfile, { exclude: current }).length > 0;
+    const fromExplicitSource = explicitUsable || profileUsable;
+    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : opts.fallbackProfile ? this.resolve(opts.fallbackProfile, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
+      fallbackModels: explicitRefs,
+      fallbackProfile: opts.fallbackProfile,
+      fallbackAuto: effectiveFallbackAuto,
+      exclude: current
+    });
+    const candidates = [];
+    if (opts.closedWorld) {
+      candidates.push(...selectedChain);
+    } else {
+      candidates.push(...this.resolveBridge(current));
+      if (!(configuredPrimary.providerId === current.providerId && configuredPrimary.model === current.model)) {
+        candidates.push({
+          providerId: configuredPrimary.providerId,
+          model: configuredPrimary.model,
+          providerSwitched: configuredPrimary.providerId !== current.providerId
+        });
+      }
+      candidates.push(...selectedChain);
+      if (!fromExplicitSource && effectiveFallbackAuto && opts.fallbackProfile !== "default") {
+        candidates.push(...this.resolve("default", { exclude: current }));
+      }
+      if (!fromExplicitSource && effectiveFallbackAuto) {
+        const cap = this.lastResortCap();
+        if (cap > 0) {
+          const usedKeys = new Set(
+            candidates.map((c) => `${c.providerId}/${c.model}`)
+          );
+          const lastResort = this.smartDefault(current, Number.POSITIVE_INFINITY).filter((c) => !usedKeys.has(`${c.providerId}/${c.model}`)).slice(0, cap);
+          candidates.push(...lastResort);
+        }
+      }
+    }
+    return dedupeChain(candidates, current);
   }
   // ── Provider availability (read-only) ──────────────────────────────────
   checkProvider(providerId) {
@@ -2572,7 +2657,20 @@ var FallbackProfileManager = class {
     );
   }
 };
+var MAX_LAST_RESORT_CANDIDATES = 12;
 var FREEZER_EMPTY = Object.freeze([]);
+function dedupeChain(entries, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const currentKey = `${current.providerId}/${current.model}`;
+  return Object.freeze(
+    entries.filter((entry) => {
+      const key = `${entry.providerId}/${entry.model}`;
+      if (key === currentKey || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
+  );
+}
 
 // src/plugins/auto-review-plugin.ts
 init_error();
@@ -6371,7 +6469,9 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
     const agentRange = dayFilter("day");
     const uniqueAgents = this.db.prepare(`SELECT COUNT(DISTINCT agent_id) n FROM agent_daily${agentRange.where}`).get(...agentRange.params).n;
     const requestRange = dayFilter("day");
-    const logicalRequests = this.db.prepare(`SELECT COUNT(DISTINCT logical_request_id) n FROM logical_request_daily${requestRange.where}`).get(...requestRange.params).n;
+    const logicalRequests = this.db.prepare(
+      `SELECT COUNT(DISTINCT logical_request_id) n FROM logical_request_daily${requestRange.where}`
+    ).get(...requestRange.params).n;
     const fileRange = dayFilter("day");
     const uniqueFiles = this.db.prepare(`SELECT COUNT(DISTINCT path_key) n FROM file_seen_daily${fileRange.where}`).get(...fileRange.params).n;
     const costRange = dayFilter("day");
@@ -6680,10 +6780,13 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
        ON CONFLICT(day, family) DO UPDATE SET count = count + 1, failure_count = failure_count + excluded.failure_count`
     ).run(day, family, failed);
     if (failed) bump("failures = failures + 1");
-    if (event.outcome === "cancelled" || event.outcome === "abandoned") bump("cancellations = cancellations + 1");
+    if (event.outcome === "cancelled" || event.outcome === "abandoned")
+      bump("cancellations = cancellations + 1");
     if (family === "agent") bump("agent_events = agent_events + 1");
     if (event.correlation.logicalRequestId) {
-      this.db.prepare("INSERT OR IGNORE INTO logical_request_daily (day, logical_request_id) VALUES (?, ?)").run(day, event.correlation.logicalRequestId);
+      this.db.prepare(
+        "INSERT OR IGNORE INTO logical_request_daily (day, logical_request_id) VALUES (?, ?)"
+      ).run(day, event.correlation.logicalRequestId);
     }
     if (event.scope.agentId) {
       this.db.prepare("INSERT OR IGNORE INTO agent_daily (day, agent_id) VALUES (?, ?)").run(day, event.scope.agentId);
@@ -6703,7 +6806,8 @@ var ChronicleMetricsStore = class _ChronicleMetricsStore {
         durationCount
       );
     } else if (type === "process.started") bump("processes = processes + 1");
-    else if (type === "process.completed" && event.outcome === "failure") bump("failed_processes = failed_processes + 1");
+    else if (type === "process.completed" && event.outcome === "failure")
+      bump("failed_processes = failed_processes + 1");
     if (event.resource?.kind === "file" || type.startsWith("file.")) {
       bump("file_events_all = file_events_all + 1");
       if (event.resource?.path) {

package/dist/registry/index.js

@@ -759,6 +759,17 @@ var ToolRegistry = class _ToolRegistry {
     this._providerListSnapshotVersion = this._version;
     return arr;
   }
+  /**
+   * Whether an enabled catalog tool is part of the direct provider surface.
+   *
+   * This is intentionally different from `get()`/`list()`: a tool can remain
+   * executable through a lazy gateway while its schema is omitted from the
+   * next provider request. Disabled and unknown tools always return false.
+   */
+  isExposedToProvider(name) {
+    if (this._disabled.has(name) || !this.tools.has(name)) return false;
+    return this._providerToolNames?.has(name) ?? true;
+  }
   /**
    * Group tools by their `category` field. Tools without a category
    * are placed under the key `""` (empty string). Returns a Map of

package/dist/registry/tool-registry.d.ts

@@ -149,6 +149,14 @@ export declare class ToolRegistry {
     exposeToProvider(names: string | readonly string[]): void;
     /** Tools serialized into provider requests and described by the system prompt. */
     listForProvider(): Tool[];
+    /**
+     * Whether an enabled catalog tool is part of the direct provider surface.
+     *
+     * This is intentionally different from `get()`/`list()`: a tool can remain
+     * executable through a lazy gateway while its schema is omitted from the
+     * next provider request. Disabled and unknown tools always return false.
+     */
+    isExposedToProvider(name: string): boolean;
     /**
      * Group tools by their `category` field. Tools without a category
      * are placed under the key `""` (empty string). Returns a Map of

package/dist/replay/hash.d.ts

@@ -17,6 +17,15 @@ import type { Request } from '../types/provider.js';
  *     sampling knobs (`temperature`, `topP`, `stopSequences`,
  *     `toolChoice`). Anything else on the `Request` (metadata,
  *     future extensions) is ignored so replay stays forward-compat.
+ *   - The same rule applies *inside* each message. `Request.messages`
+ *     is the live `ctx.messages` array, whose entries carry local
+ *     bookkeeping the provider adapters explicitly drop: `ts` (wall
+ *     clock at the moment the turn was created), `_estTokens` (a
+ *     mutation-time cache) and `origin`. Hashing those made every
+ *     hash a function of when the run happened, so a recorded
+ *     response could never be found again and `mode: 'replay'` threw
+ *     on the first call it was asked to serve. See
+ *     {@link semanticMessage}.
  *   - We serialize to JSON. The `ContentBlock` and `Message` shapes
  *     are pure data; this works as long as no `undefined` values
  *     sneak in (those get dropped by `JSON.stringify`, which is

package/dist/replay/index.js

@@ -15,11 +15,15 @@ function sortKeys(value) {
   }
   return value;
 }
+function semanticMessage(message) {
+  const { ts: _ts, _estTokens: _estimate, origin: _origin, ...semantic } = message;
+  return semantic;
+}
 function hashRequest(request) {
   const payload = {
     model: request.model,
     system: request.system,
-    messages: request.messages,
+    messages: request.messages.map(semanticMessage),
     tools: request.tools,
     maxTokens: request.maxTokens,
     temperature: request.temperature,
@@ -40,16 +44,22 @@ var ReplayProviderRunner = class {
   }
   inner;
   opts;
+  /** Resolve the target session for this call. See {@link ReplayProviderRunnerOptions.sessionId}. */
+  resolveSessionId() {
+    const { sessionId } = this.opts;
+    return typeof sessionId === "function" ? sessionId() : sessionId;
+  }
   async run(runOpts) {
     const hash = hashRequest(runOpts.request);
-    const cached = await this.opts.log.lookup(this.opts.sessionId, hash);
+    const sessionId = this.resolveSessionId();
+    const cached = await this.opts.log.lookup(sessionId, hash);
     if (this.opts.mode === "replay") {
       if (!cached) {
         this.opts.logger?.warn?.(
           `replay: no recorded response for hash ${hash} (model ${runOpts.request.model})`
         );
         throw new Error(
-          `ReplayProviderRunner: no recorded response for hash ${hash} in session ${this.opts.sessionId}. Either the request changed since recording, or this session has no replay log.`
+          `ReplayProviderRunner: no recorded response for hash ${hash} in session ${sessionId}. Either the request changed since recording, or this session has no replay log.`
         );
       }
       this.opts.logger?.debug?.(
@@ -65,7 +75,7 @@ var ReplayProviderRunner = class {
     }
     const response = await this.inner.run(runOpts);
     await this.opts.log.record({
-      sessionId: this.opts.sessionId,
+      sessionId,
       request: runOpts.request,
       response
     });

package/dist/replay/replay-provider-runner.d.ts

@@ -26,11 +26,39 @@ import type { Response } from '../types/provider.js';
  *     a particular request is seen, it's recorded; the next time
  *     the same request is made, the recorded response is served.
  *     This is the cheapest path to a deterministic test harness.
+ *
+ * ## What a hit requires
+ *
+ * The lookup key is `hashRequest`, which covers everything the provider is
+ * actually sent — including `system`. The agent loop appends volatile blocks
+ * to the system prompt on every request (the continuity ledger, the live
+ * next-steps gate, memory evidence; see `agent-response.ts`), and those blocks
+ * describe the state of *this* run. A re-run whose ledger or retrieved memory
+ * differs therefore produces a different request, and correctly misses: the
+ * recorded response answered a different prompt.
+ *
+ * So `mode: 'replay'` reproduces a run faithfully only when the loop is driven
+ * back through the same states — which is what a test harness does, and what a
+ * fresh interactive session does not. In an interactive session, prefer
+ * `'record'` (build the log) and use `'replay'` from a harness that pins the
+ * volatile inputs. `hashRequest` itself is stable across time: local message
+ * bookkeeping (`ts`, `_estTokens`, `origin`) is stripped before hashing.
  */
 export type ReplayMode = 'record' | 'replay' | 'auto';
 export interface ReplayProviderRunnerOptions {
     log: ReplayLogStore;
-    sessionId: string;
+    /**
+     * Which session's log to read and write.
+     *
+     * Accepts a resolver because recording is wired before the session exists:
+     * the boot path binds this runner while the session writer is still being
+     * created, and the user may then swap sessions (`/resume`, new session)
+     * without the runner being rebuilt. A frozen string there meant the log was
+     * filed under a synthetic id with no session behind it. A resolver keeps the
+     * log next to the transcript it belongs to, for the session that is actually
+     * live at the time of the call.
+     */
+    sessionId: string | (() => string);
     mode: ReplayMode;
     /**
      * Optional logger — receives a debug line on every replay hit
@@ -48,6 +76,8 @@ export declare class ReplayProviderRunner implements ProviderRunner {
     private readonly inner;
     private readonly opts;
     constructor(inner: ProviderRunner, opts: ReplayProviderRunnerOptions);
+    /** Resolve the target session for this call. See {@link ReplayProviderRunnerOptions.sessionId}. */
+    private resolveSessionId;
     run(runOpts: RunProviderOptions): Promise<Response>;
 }
 //# sourceMappingURL=replay-provider-runner.d.ts.map

package/dist/security/index.js

@@ -1298,11 +1298,13 @@ function windowsAccountName() {
 import { realpath } from "node:fs/promises";
 import * as path2 from "node:path";
 import {
+  evaluateContractGraphReadiness,
   evaluateKanbanBoundaryOpaque,
   evaluateKanbanBoundaryPath,
   readBoard,
   resolveKanbanBoundaryLayers
 } from "@wrongstack/kanban";
+var GOVERNANCE_CONTROL_TOOLS = /* @__PURE__ */ new Set(["kanban", "plan", "task", "todo"]);
 var PATH_KEYS2 = /* @__PURE__ */ new Set([
   "path",
   "paths",
@@ -1327,12 +1329,62 @@ var TOOL_PATH_KEYS = {
   // filesystem target in language_info. Keep ambiguous names tool-specific.
   language_info: ["target"]
 };
-async function evaluateToolKanbanBoundary(tool, input, ctx) {
+async function evaluateToolKanbanBoundary(tool, input, ctx, options = {}) {
+  if (tool.name === "kanban") return { decision: "allow" };
   const identity = resolveKanbanIdentity(ctx);
-  if (!identity.boardId) return { decision: "allow" };
+  const governanceRequired = options.requireGovernance && isGovernedMutation(tool, input);
+  if (!identity.boardId) {
+    return governanceRequired ? {
+      decision: "block",
+      reason: "Kanban governance is mandatory before product mutation. Create a managed card, add its required details and executable acceptance criteria, then call kanban start_task to bind it to this run."
+    } : { decision: "allow" };
+  }
   const board = await readBoard(identity.policyRoot ?? ctx.projectRoot, identity.boardId);
-  if (!board) return { decision: "allow" };
+  if (!board) {
+    return governanceRequired ? {
+      decision: "block",
+      reason: `Active Kanban board not found: ${identity.boardId}. Recreate or select a valid managed card before mutation.`,
+      boardId: identity.boardId,
+      ...identity.taskId ? { taskId: identity.taskId } : {}
+    } : { decision: "allow" };
+  }
   const task = identity.taskId ? board.tasks.find((candidate) => candidate.id === identity.taskId) : void 0;
+  if (governanceRequired && board.lifecycle?.mode === "managed") {
+    if (!identity.taskId) {
+      return {
+        decision: "block",
+        reason: "Kanban governance requires an active task, not only a board. Complete the card details and call kanban start_task before mutation.",
+        boardId: board.id
+      };
+    }
+    if (!task) {
+      return {
+        decision: "block",
+        reason: `Active Kanban task not found: ${identity.taskId}. Call kanban start_task with a valid card.`,
+        boardId: board.id,
+        taskId: identity.taskId
+      };
+    }
+    const readiness = evaluateContractGraphReadiness(board, task.id);
+    if (!readiness.ready) {
+      return {
+        decision: "block",
+        reason: "Active card is not implementation-ready: " + readiness.issues.map((issue) => issue.message).join(" | "),
+        boardId: board.id,
+        taskId: task.id
+      };
+    }
+    if (task.lifecycle?.currentStage !== "running" || task.assignment?.status !== "running") {
+      const lifecycleStage = task.lifecycle?.currentStage ?? "missing";
+      const assignmentStatus = task.assignment?.status ?? "missing";
+      return {
+        decision: "block",
+        reason: `Active card must be in Running with a live assignment before product mutation (lifecycle: ${lifecycleStage}; assignment: ${assignmentStatus}). Call kanban start_task after completing the required card details.`,
+        boardId: board.id,
+        taskId: task.id
+      };
+    }
+  }
   if (identity.leaseId && task?.assignment) {
     const caps2 = tool.capabilities ?? [];
     const isWrite = caps2.includes("fs.write") || caps2.includes("fs.write.outside-project") || caps2.some((c) => c.startsWith("shell."));
@@ -1368,6 +1420,19 @@ async function evaluateToolKanbanBoundary(tool, input, ctx) {
     ...task ? { taskId: task.id } : {}
   };
 }
+function isGovernedMutation(tool, input) {
+  if (!tool.mutating || GOVERNANCE_CONTROL_TOOLS.has(tool.name)) return false;
+  if (tool.capabilities?.includes("tool.meta")) return false;
+  if (tool.name === "git") {
+    const command = input["command"];
+    if (command === "status" || command === "log" || command === "diff") return false;
+    if (command === "worktree" && input["worktreeAction"] === "list") return false;
+  }
+  const capabilities = tool.capabilities ?? [];
+  return capabilities.some(
+    (capability) => capability === "fs.write" || capability === "fs.write.outside-project" || capability === "package.install" || capability === "tool.mutate.any" || capability.startsWith("shell.") || capability === "net.outbound"
+  );
+}
 function resolveKanbanIdentity(ctx) {
   const metaKanban = ctx.meta["kanban"];
   const record = metaKanban && typeof metaKanban === "object" ? metaKanban : void 0;
@@ -1685,6 +1750,9 @@ function subjectForToolInput(toolName, input, subjectKey) {
   const obj = input;
   if (subjectKey) {
     const value = obj[subjectKey];
+    if (Array.isArray(value)) {
+      return escapeGlobSubject(JSON.stringify(value));
+    }
     if (typeof value === "string") {
       if (isPathSubjectKey(subjectKey)) {
         const normalized = normalizePathSubject(value);
@@ -3541,23 +3609,21 @@ function unwrapDataKey(buf, keyFile) {
     });
   }
 }
-function checkKeyFilePermissions(keyFile, opts) {
-  if (process.platform === "win32") return;
+function keyFileNeedsHardening(keyFile, opts) {
+  if (process.platform === "win32") return false;
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
     const stat = fs2.statSync(keyFile);
     const actualMode = stat.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
-      void restrictFilePermissions(keyFile, {
-        label: "secret-vault",
-        warn
-      }).catch(() => void 0);
       warn(
         `Key file ${keyFile} has mode ${actualMode.toString(8)} \u2014 expected ${KEY_FILE_MODE.toString(8)}. Hardening\u2026`
       );
+      return true;
     }
   } catch {
   }
+  return false;
 }
 function writeKeyFileAtomicSync(keyFile, content) {
   const tmp = `${keyFile}.${randomBytes2(4).toString("hex")}.tmp`;
@@ -3623,6 +3689,14 @@ var DefaultSecretVault = class {
     }).catch(() => void 0);
     this.pendingHardening.push(p);
   }
+  /** Detect and schedule repair of a pre-existing POSIX key with loose mode bits. */
+  checkKeyFilePermissions() {
+    if (keyFileNeedsHardening(this.keyFile, {
+      warn: (msg) => this.logWarn(msg)
+    })) {
+      this.scheduleKeyHardening();
+    }
+  }
   /** Flush all pending key-file hardening promises. */
   flushHardening() {
     if (this.pendingHardening.length === 0) return Promise.resolve();
@@ -3710,7 +3784,7 @@ var DefaultSecretVault = class {
       writeKeyFileAtomicSync(this.keyFile, keyFileBuf);
     }
     this.scheduleKeyHardening();
-    checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+    this.checkKeyFilePermissions();
     this.key = newKey;
     this._keyVersion = newVersion;
     return { oldVersion, newVersion };
@@ -3726,12 +3800,9 @@ var DefaultSecretVault = class {
     const passphrase = getVaultPassphrase();
     if (!passphrase || !this.key) return;
     try {
-      writeKeyFileAtomicSync(
-        this.keyFile,
-        wrapDataKey(this.key, this._keyVersion, passphrase)
-      );
+      writeKeyFileAtomicSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase));
       this.scheduleKeyHardening();
-      checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+      this.checkKeyFilePermissions();
     } catch {
     }
   }
@@ -3743,13 +3814,13 @@ var DefaultSecretVault = class {
         const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
         this.key = key2;
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         this.migrateToWrappedIfPassphrase();
         return this.key;
       }
@@ -3773,7 +3844,7 @@ var DefaultSecretVault = class {
         }
         this.key = Buffer.from(key2);
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         this.migrateToWrappedIfPassphrase();
         return this.key;
       }
@@ -3800,13 +3871,13 @@ var DefaultSecretVault = class {
         const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
         this.key = winnerKey;
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       if (buf.length === VERSIONED_KEY_FILE_SIZE) {
@@ -3822,7 +3893,7 @@ var DefaultSecretVault = class {
         const winnerKey = buf.subarray(KEY_FILE_MAGIC.length + 1);
         this.key = Buffer.from(winnerKey);
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       throw new ConfigError({

package/dist/security/kanban-boundary.d.ts

@@ -5,6 +5,10 @@ export interface ToolKanbanBoundaryEvaluation extends KanbanBoundaryEvaluation {
     boardId?: string | undefined;
     taskId?: string | undefined;
 }
+export interface ToolKanbanGovernanceOptions {
+    /** Require every product mutation to run inside a ready, running Kanban card. */
+    requireGovernance?: boolean | undefined;
+}
 /** Resolve the live board/task policy and gate one tool invocation. */
-export declare function evaluateToolKanbanBoundary(tool: Tool, input: Record<string, unknown>, ctx: Context): Promise<ToolKanbanBoundaryEvaluation>;
+export declare function evaluateToolKanbanBoundary(tool: Tool, input: Record<string, unknown>, ctx: Context, options?: ToolKanbanGovernanceOptions): Promise<ToolKanbanBoundaryEvaluation>;
 //# sourceMappingURL=kanban-boundary.d.ts.map

package/dist/security/secret-vault.d.ts

@@ -46,6 +46,8 @@ export declare class DefaultSecretVault implements RotatableSecretVault {
      * can never become an unhandled one.
      */
     private scheduleKeyHardening;
+    /** Detect and schedule repair of a pre-existing POSIX key with loose mode bits. */
+    private checkKeyFilePermissions;
     /** Flush all pending key-file hardening promises. */
     flushHardening(): Promise<void>;
     /** Current key version. Starts at 1; incremented by rotateKey(). */