@wrongstack/core 0.302.2 → 0.303.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

@@ -6371,7 +6371,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 +6682,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 +6708,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/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,60 @@ 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) {
+    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") {
+      return {
+        decision: "block",
+        reason: "Active card must be in Running with a live assignment before product mutation. 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 +1418,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 +1748,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);

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/session-catalog/index.js

@@ -1392,6 +1392,25 @@ var SessionCatalogStore = class {
   leaseRow(sessionId) {
     return this.db.prepare("SELECT * FROM session_leases WHERE session_id=?").get(sessionId);
   }
+  /**
+   * True when `sessionId` has a live `session_leases` row owned by a
+   * different OS process than the *caller*. Used by
+   * `acquireMaintenance` to distinguish "another running wstack" (which
+   * must be fenced off) from "this very TUI owning its own session"
+   * (which is allowed to claim a non-destructive maintenance lease on
+   * its own transcript).
+   *
+   * `callerPid` must be the pid of the process that asked for the lease,
+   * NOT `process.pid`. In the built runtime this store lives inside the
+   * detached project-catalog daemon, so `process.pid` is the daemon's and
+   * would mark every lease — including the caller's own session — foreign,
+   * making `/clear` and `/rewind` fail with "Session … is live". Callers
+   * that run the store in-process may omit it.
+   */
+  foreignLiveLease(sessionId, callerPid = process.pid) {
+    const live = this.leaseRow(sessionId);
+    return Boolean(live) && live.owner_pid !== callerPid;
+  }
   verifyCredential(credential) {
     assertId(credential.sessionId);
     const row = this.leaseRow(credential.sessionId);
@@ -1725,11 +1744,14 @@ var SessionCatalogStore = class {
       throw error;
     }
   }
-  acquireMaintenance(sessionId, operation, holderId, leaseMs) {
+  acquireMaintenance(sessionId, operation, holderId, leaseMs, holderPid) {
     assertId(sessionId);
     return this.transaction(() => {
       this.reapExpired();
-      if (this.leaseRow(sessionId)) throw conflict(`Session ${sessionId} is live`);
+      const live = this.leaseRow(sessionId);
+      if (live && (operation === "delete" || this.foreignLiveLease(sessionId, holderPid))) {
+        throw conflict(`Session ${sessionId} is live`);
+      }
       const reservation = this.db.prepare(
         "SELECT 1 AS yes FROM resume_reservations WHERE target_session_id=? AND expires_at>?"
       ).get(sessionId, Date.now());

package/dist/session-catalog/project-server.js

@@ -761,6 +761,25 @@ var SessionCatalogStore = class {
   leaseRow(sessionId) {
     return this.db.prepare("SELECT * FROM session_leases WHERE session_id=?").get(sessionId);
   }
+  /**
+   * True when `sessionId` has a live `session_leases` row owned by a
+   * different OS process than the *caller*. Used by
+   * `acquireMaintenance` to distinguish "another running wstack" (which
+   * must be fenced off) from "this very TUI owning its own session"
+   * (which is allowed to claim a non-destructive maintenance lease on
+   * its own transcript).
+   *
+   * `callerPid` must be the pid of the process that asked for the lease,
+   * NOT `process.pid`. In the built runtime this store lives inside the
+   * detached project-catalog daemon, so `process.pid` is the daemon's and
+   * would mark every lease — including the caller's own session — foreign,
+   * making `/clear` and `/rewind` fail with "Session … is live". Callers
+   * that run the store in-process may omit it.
+   */
+  foreignLiveLease(sessionId, callerPid = process.pid) {
+    const live = this.leaseRow(sessionId);
+    return Boolean(live) && live.owner_pid !== callerPid;
+  }
   verifyCredential(credential) {
     assertId(credential.sessionId);
     const row = this.leaseRow(credential.sessionId);
@@ -1094,11 +1113,14 @@ var SessionCatalogStore = class {
       throw error;
     }
   }
-  acquireMaintenance(sessionId, operation, holderId, leaseMs) {
+  acquireMaintenance(sessionId, operation, holderId, leaseMs, holderPid) {
     assertId(sessionId);
     return this.transaction(() => {
       this.reapExpired();
-      if (this.leaseRow(sessionId)) throw conflict(`Session ${sessionId} is live`);
+      const live = this.leaseRow(sessionId);
+      if (live && (operation === "delete" || this.foreignLiveLease(sessionId, holderPid))) {
+        throw conflict(`Session ${sessionId} is live`);
+      }
       const reservation = this.db.prepare(
         "SELECT 1 AS yes FROM resume_reservations WHERE target_session_id=? AND expires_at>?"
       ).get(sessionId, Date.now());
@@ -1404,7 +1426,7 @@ var OPERATION_KEYS = {
   resolve_id: ["query"],
   get_summary: ["sessionId"],
   rename: ["sessionId", "name"],
-  acquire_maintenance: ["sessionId", "operation", "holderId", "leaseMs"],
+  acquire_maintenance: ["sessionId", "operation", "holderId", "leaseMs", "holderPid"],
   release_maintenance: ["lease"],
   delete: ["sessionId", "lease"],
   prune: ["maxAgeDays", "holderId"],
@@ -1584,7 +1606,8 @@ async function dispatch(op, args) {
         value.sessionId,
         value.operation,
         value.holderId,
-        value.leaseMs
+        value.leaseMs,
+        value.holderPid
       );
     }
     case "release_maintenance": {

package/dist/session-catalog/protocol.d.ts

@@ -76,6 +76,12 @@ export interface SessionCatalogEvent {
     generation: number;
     at: string;
 }
+/**
+ * NOTE: adding a field to any `args` below also requires adding it to
+ * `OPERATION_KEYS` in `project-server.ts` — the daemon validates every
+ * request against that allowlist and rejects unknown fields at runtime,
+ * which TypeScript cannot catch.
+ */
 export interface SessionCatalogOperations {
     ping: {
         args: Record<string, never>;
@@ -210,6 +216,9 @@ export interface SessionCatalogOperations {
             operation: MaintenanceLease['operation'];
             holderId: string;
             leaseMs?: number;
+            /** Caller's OS pid. The server runs in the detached catalog daemon, so
+             *  it cannot use its own `process.pid` to recognise the session owner. */
+            holderPid?: number;
         };
         result: MaintenanceLease;
     };

package/dist/session-catalog/store.d.ts

@@ -17,6 +17,22 @@ export declare class SessionCatalogStore {
     private reapExpired;
     private maintenanceExists;
     private leaseRow;
+    /**
+     * True when `sessionId` has a live `session_leases` row owned by a
+     * different OS process than the *caller*. Used by
+     * `acquireMaintenance` to distinguish "another running wstack" (which
+     * must be fenced off) from "this very TUI owning its own session"
+     * (which is allowed to claim a non-destructive maintenance lease on
+     * its own transcript).
+     *
+     * `callerPid` must be the pid of the process that asked for the lease,
+     * NOT `process.pid`. In the built runtime this store lives inside the
+     * detached project-catalog daemon, so `process.pid` is the daemon's and
+     * would mark every lease — including the caller's own session — foreign,
+     * making `/clear` and `/rewind` fail with "Session … is live". Callers
+     * that run the store in-process may omit it.
+     */
+    private foreignLiveLease;
     private verifyCredential;
     private createLease;
     claimNew(entry: SessionRegistryEntry, ownerInstanceId: string, leaseMs?: number): SessionLeaseCredential;
@@ -40,7 +56,7 @@ export declare class SessionCatalogStore {
     getSummary(sessionId: string): CatalogSessionRecord | null;
     resolveId(query: string): string;
     rename(sessionId: string, name: string): Promise<CatalogSessionRecord>;
-    acquireMaintenance(sessionId: string, operation: MaintenanceLease['operation'], holderId: string, leaseMs?: number): MaintenanceLease;
+    acquireMaintenance(sessionId: string, operation: MaintenanceLease['operation'], holderId: string, leaseMs?: number, holderPid?: number): MaintenanceLease;
     releaseMaintenance(lease: MaintenanceLease): void;
     delete(sessionId: string, lease: MaintenanceLease): void;
     prune(maxAgeDays: number, holderId: string): number;

package/dist/storage/index.js

@@ -8039,8 +8039,31 @@ function simpleHash(s) {
 }
 
 // src/storage/plan-store.ts
-import * as fsp5 from "node:fs/promises";
 import { randomUUID as randomUUID5 } from "node:crypto";
+import * as fsp5 from "node:fs/promises";
+function assertPlanMutationInvariants(previous, updated) {
+  const ids = updated.items.map((item) => item.id);
+  const uniqueIds = new Set(ids);
+  if (uniqueIds.size !== ids.length) {
+    throw new SessionError({
+      message: "Plan mutation rejected: plan item IDs must be unique.",
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutatePlan", invariant: "unique_plan_item_ids" }
+    });
+  }
+  const omittedUnfinished = previous.items.filter(
+    (item) => item.status !== "done" && !uniqueIds.has(item.id)
+  );
+  if (omittedUnfinished.length > 0) {
+    throw new SessionError({
+      message: `Plan mutation rejected: unfinished items cannot be omitted: ${omittedUnfinished.map((item) => item.id).join(", ")}. Complete them first.`,
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutatePlan", invariant: "unfinished_plan_coverage" }
+    });
+  }
+}
 async function loadPlan(filePath, events) {
   const t0 = Date.now();
   let raw;
@@ -8222,7 +8245,9 @@ function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
 async function mutatePlan(filePath, sessionId, fn) {
   return withFileLock(filePath, async () => {
     const plan = await loadPlan(filePath) ?? emptyPlan(sessionId);
+    const previous = structuredClone(plan);
     const updated = await fn(plan);
+    assertPlanMutationInvariants(previous, updated);
     const persisted = await savePlan(filePath, updated);
     if (!persisted) {
       throw new SessionError({
@@ -14441,7 +14466,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const maintenance = this.catalogClient ? await this.catalogClient.call("acquire_maintenance", {
       sessionId: canonical,
       operation: "clear",
-      holderId: this.maintenanceHolderId
+      holderId: this.maintenanceHolderId,
+      // The catalog store runs inside the detached project daemon; without
+      // our pid it cannot tell "this TUI clearing its own session" from
+      // "another running wstack" and refuses every /clear as `is live`.
+      holderPid: process.pid
     }) : void 0;
     await this.ensureShardDir(canonical);
     const file = this.sessionPath(canonical, ".jsonl");
@@ -14698,6 +14727,54 @@ async function revertSnapshots(snapshots, projectRoot) {
 
 // src/storage/task-store.ts
 import * as fsp21 from "node:fs/promises";
+function assertTaskMutationInvariants(previous, updated) {
+  const ids = updated.tasks.map((task) => task.id);
+  const uniqueIds = new Set(ids);
+  if (uniqueIds.size !== ids.length) {
+    throw new SessionError({
+      message: "Task mutation rejected: task IDs must be unique.",
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutateTasks", invariant: "unique_task_ids" }
+    });
+  }
+  const omittedUnfinished = previous.tasks.filter(
+    (task) => task.status !== "completed" && !uniqueIds.has(task.id)
+  );
+  if (omittedUnfinished.length > 0) {
+    throw new SessionError({
+      message: `Task mutation rejected: unfinished tasks cannot be omitted: ${omittedUnfinished.map((task) => task.id).join(", ")}. Complete them first.`,
+      code: "SESSION_WRITE_FAILED",
+      sessionId: updated.sessionId,
+      context: { operation: "mutateTasks", invariant: "unfinished_task_coverage" }
+    });
+  }
+  const byId = new Map(updated.tasks.map((task) => [task.id, task]));
+  for (const task of updated.tasks) {
+    const missing = (task.dependsOn ?? []).filter((dependencyId) => !byId.has(dependencyId));
+    if (missing.length > 0) {
+      throw new SessionError({
+        message: `Task mutation rejected: task "${task.id}" references missing dependencies: ${missing.join(", ")}.`,
+        code: "SESSION_WRITE_FAILED",
+        sessionId: updated.sessionId,
+        context: { operation: "mutateTasks", invariant: "dependency_identity" }
+      });
+    }
+    if (task.status === "in_progress" || task.status === "review" || task.status === "completed") {
+      const unmet = (task.dependsOn ?? []).filter(
+        (dependencyId) => byId.get(dependencyId)?.status !== "completed"
+      );
+      if (unmet.length > 0) {
+        throw new SessionError({
+          message: `Task mutation rejected: task "${task.id}" cannot be ${task.status} before dependencies complete: ${unmet.join(", ")}.`,
+          code: "SESSION_WRITE_FAILED",
+          sessionId: updated.sessionId,
+          context: { operation: "mutateTasks", invariant: "dependency_completion" }
+        });
+      }
+    }
+  }
+}
 function emptyTaskFile(sessionId) {
   return {
     version: 1,
@@ -14802,7 +14879,9 @@ async function saveTasks(filePath, tasks, events, traceId, warn) {
 async function mutateTasks(filePath, sessionId, fn, events, traceId) {
   return withFileLock(filePath, async () => {
     const file = await loadTasks(filePath, events, traceId) ?? emptyTaskFile(sessionId);
+    const previous = structuredClone(file);
     const updated = await fn(file);
+    assertTaskMutationInvariants(previous, updated);
     const persisted = await saveTasks(filePath, updated, events, traceId);
     if (!persisted) {
       throw new SessionError({

package/dist/storage/plan-store.d.ts

@@ -1,5 +1,5 @@
-import type { EventBus } from '../kernel/events.js';
 import type { ConversationState } from '../core/conversation-state.js';
+import type { EventBus } from '../kernel/events.js';
 /**
  * Plan items are the strategic counterpart to todos. Where `ctx.todos`
  * is the moment-to-moment task board the LLM mutates per-turn, a plan

package/dist/tasking/index.js

@@ -367,6 +367,11 @@ var TaskTracker = class _TaskTracker {
     if (!this.graph) return false;
     const node = this.graph.nodes.get(id);
     if (!node) return false;
+    if (node.specRequirementId && this.graph.requiredRequirementIds?.includes(node.specRequirementId) && !Array.from(this.graph.nodes.values()).some(
+      (candidate) => candidate.id !== id && candidate.specRequirementId === node.specRequirementId
+    )) {
+      return false;
+    }
     this.graph.nodes.delete(id);
     this.graph.edges = this.graph.edges.filter((e) => e.from !== id && e.to !== id);
     this.graph.rootNodes = this.graph.rootNodes.filter((r) => r !== id);