workspacecord 1.1.3 → 1.1.4

package/dist/{chunk-WON3DPE4.js → chunk-JR4B4L7I.js}

@@ -15,7 +15,7 @@ import {
   parseSessionPersistData,
   resolvePath,
   sanitizeName
-} from "./chunk-IVXCJA5I.js";
+} from "./chunk-MJ5JKFGS.js";
 
 // ../../node_modules/.pnpm/xstate@5.30.0/node_modules/xstate/dev/dist/xstate-dev.esm.js
 function getGlobal() {
@@ -3257,7 +3257,12 @@ function toProjection(state) {
     updatedAt: state.updatedAt,
     turn: state.turn,
     phase: state.phase,
-    humanResolved: state.humanResolved
+    humanResolved: state.humanResolved,
+    todoList: state.todoList,
+    todoUpdatedAt: state.todoUpdatedAt,
+    recentPermissionDenials: state.recentPermissionDenials,
+    batchApprovalMode: state.batchApprovalMode,
+    pendingApprovals: state.pendingApprovals
   };
 }
 function toPanelProjection(state) {
@@ -3433,6 +3438,8 @@ function resolveHumanResolved(event, current) {
 }
 
 // ../state/src/xstate-session-machine.ts
+var MAX_RECENT_DENIALS = 5;
+var MAX_PENDING_APPROVALS = 100;
 var LIFECYCLE_TRANSITIONS = {
   initializing: ["active", "waiting_human", "paused", "completed", "error"],
   active: ["waiting_human", "paused", "completed", "error"],
@@ -3479,6 +3486,22 @@ var sessionMachine = setup({
       if ("humanResolved" in event && event.humanResolved !== void 0) {
         updates.humanResolved = event.humanResolved;
       }
+      if ("todoList" in event && event.todoList !== void 0) {
+        updates.todoList = event.todoList;
+        updates.todoUpdatedAt = event.updatedAt;
+      }
+      if ("todoUpdatedAt" in event && event.todoUpdatedAt !== void 0) {
+        updates.todoUpdatedAt = event.todoUpdatedAt;
+      }
+      if ("recentPermissionDenials" in event && event.recentPermissionDenials !== void 0) {
+        updates.recentPermissionDenials = event.recentPermissionDenials;
+      }
+      if ("batchApprovalMode" in event && event.batchApprovalMode !== void 0) {
+        updates.batchApprovalMode = event.batchApprovalMode;
+      }
+      if ("pendingApprovals" in event && event.pendingApprovals !== void 0) {
+        updates.pendingApprovals = event.pendingApprovals;
+      }
       return { ...context, ...updates };
     }),
     markAutoIdle: assign(({ context, event }) => ({
@@ -3488,11 +3511,81 @@ var sessionMachine = setup({
       stateSource: "formal",
       confidence: "high",
       updatedAt: event.type === "AUTO_IDLE" ? event.updatedAt : Date.now()
-    }))
+    })),
+    applyTodoList: assign(({ context, event }) => {
+      if (event.type !== "TODO_UPDATED") return context;
+      return {
+        ...context,
+        todoList: event.items,
+        todoUpdatedAt: event.updatedAt,
+        updatedAt: event.updatedAt
+      };
+    }),
+    pushPermissionDenial: assign(({ context, event }) => {
+      if (event.type !== "PERMISSION_DENIED") return context;
+      const previous = context.recentPermissionDenials ?? [];
+      const next = [
+        { toolName: event.toolName, reason: event.reason, timestamp: event.updatedAt },
+        ...previous
+      ].slice(0, MAX_RECENT_DENIALS);
+      return {
+        ...context,
+        recentPermissionDenials: next,
+        updatedAt: event.updatedAt
+      };
+    }),
+    applyBatchApprovalSet: assign(({ context, event }) => {
+      if (event.type !== "BATCH_APPROVAL_SET") return context;
+      const pending = event.enabled ? [...event.pendingApprovals ?? context.pendingApprovals ?? []] : [];
+      return {
+        ...context,
+        batchApprovalMode: event.enabled,
+        pendingApprovals: pending,
+        updatedAt: event.updatedAt
+      };
+    }),
+    enqueuePendingApproval: assign(({ context, event }) => {
+      if (event.type !== "BATCH_APPROVAL_ENQUEUE") return context;
+      const previous = context.pendingApprovals ?? [];
+      return {
+        ...context,
+        pendingApprovals: [...previous, event.approval].slice(-MAX_PENDING_APPROVALS),
+        updatedAt: event.updatedAt
+      };
+    }),
+    clearPendingApprovals: assign(({ context, event }) => {
+      if (event.type !== "BATCH_APPROVAL_CLEAR") return context;
+      return {
+        ...context,
+        pendingApprovals: [],
+        updatedAt: event.updatedAt
+      };
+    }),
+    removePendingApproval: assign(({ context, event }) => {
+      if (event.type !== "BATCH_APPROVAL_REMOVE") return context;
+      const previous = context.pendingApprovals ?? [];
+      const next = previous.filter((e) => e.gateId !== event.gateId);
+      if (next.length === previous.length) return context;
+      return {
+        ...context,
+        pendingApprovals: next,
+        updatedAt: event.updatedAt
+      };
+    })
   }
 }).createMachine({
   id: "session",
   type: "parallel",
+  // 顶层事件:TODO_UPDATED / PERMISSION_DENIED / BATCH_APPROVAL_* 只更新 context,
+  // 不改变 lifecycle 或 execution 子状态,因此放在顶层而不是某个子节点。
+  on: {
+    TODO_UPDATED: { actions: "applyTodoList" },
+    PERMISSION_DENIED: { actions: "pushPermissionDenial" },
+    BATCH_APPROVAL_SET: { actions: "applyBatchApprovalSet" },
+    BATCH_APPROVAL_ENQUEUE: { actions: "enqueuePendingApproval" },
+    BATCH_APPROVAL_CLEAR: { actions: "clearPendingApprovals" },
+    BATCH_APPROVAL_REMOVE: { actions: "removePendingApproval" }
+  },
   context: {
     gate: null,
     displayState: "idle",
@@ -3501,7 +3594,12 @@ var sessionMachine = setup({
     updatedAt: 0,
     turn: 0,
     phase: STATE_LABELS.idle,
-    humanResolved: false
+    humanResolved: false,
+    todoList: void 0,
+    todoUpdatedAt: void 0,
+    recentPermissionDenials: void 0,
+    batchApprovalMode: false,
+    pendingApprovals: void 0
   },
   states: {
     lifecycle: {
@@ -3835,7 +3933,66 @@ var StateMachine2 = class {
     );
     return toProjection(settled.success ? settled.state : baseState);
   }
+  /**
+   * Context-only updaters. These dispatch to the XState actor and rely on
+   * subscribe() to mirror the new context into entry.snapshot synchronously.
+   * No manual snapshot mutation — keeps a single source of truth.
+   */
+  applyTodoUpdate(sessionId, items) {
+    const entry = this.ensureSession(sessionId);
+    entry.actor.send({ type: "TODO_UPDATED", items, updatedAt: Date.now() });
+    return toProjection(entry.snapshot);
+  }
+  applyPermissionDenial(sessionId, toolName, reason) {
+    const entry = this.ensureSession(sessionId);
+    entry.actor.send({ type: "PERMISSION_DENIED", toolName, reason, updatedAt: Date.now() });
+    return toProjection(entry.snapshot);
+  }
+  setBatchApprovalMode(sessionId, enabled, pendingApprovals) {
+    const entry = this.ensureSession(sessionId);
+    entry.actor.send({
+      type: "BATCH_APPROVAL_SET",
+      enabled,
+      pendingApprovals,
+      updatedAt: Date.now()
+    });
+    return toProjection(entry.snapshot);
+  }
+  enqueuePendingApproval(sessionId, approval) {
+    const entry = this.ensureSession(sessionId);
+    entry.actor.send({ type: "BATCH_APPROVAL_ENQUEUE", approval, updatedAt: Date.now() });
+    return toProjection(entry.snapshot);
+  }
+  clearPendingApprovals(sessionId) {
+    const entry = this.ensureSession(sessionId);
+    entry.actor.send({ type: "BATCH_APPROVAL_CLEAR", updatedAt: Date.now() });
+    return toProjection(entry.snapshot);
+  }
+  /**
+   * Drop one pending approval by its gateId without touching the rest of the
+   * queue. Used by the abort handler to keep state consistent when a single
+   * deferred tool call is cancelled out-of-band (provider-side abort).
+   */
+  removePendingApproval(sessionId, gateId) {
+    const entry = this.ensureSession(sessionId);
+    entry.actor.send({ type: "BATCH_APPROVAL_REMOVE", gateId, updatedAt: Date.now() });
+    return toProjection(entry.snapshot);
+  }
   applyPlatformEvent(event) {
+    if (event.type === "todo_updated") {
+      const items = event.metadata?.items ?? [];
+      return this.applyTodoUpdate(event.sessionId, items);
+    }
+    if (event.type === "permission_denied") {
+      const toolName = typeof event.metadata?.toolName === "string" ? event.metadata.toolName : "tool";
+      const reason = typeof event.metadata?.reason === "string" ? event.metadata.reason : "";
+      return this.applyPermissionDenial(event.sessionId, toolName, reason);
+    }
+    if (event.type === "batch_approval_changed") {
+      const enabled = Boolean(event.metadata?.enabled);
+      const pending = event.metadata?.pendingApprovals;
+      return this.setBatchApprovalMode(event.sessionId, enabled, pending);
+    }
     const current = this.getState(event.sessionId);
     const mapped = mapEventToTransition(event, current, {
       shouldTransition: this.shouldTransition.bind(this),
@@ -4665,6 +4822,50 @@ function getOutputPort() {
   return outputPort;
 }
 
+// ../engine/src/output/batch-approval-store.ts
+var MAX_BATCH_APPROVAL_STORE_SIZE = 100;
+var store = /* @__PURE__ */ new Map();
+function enqueueBatchApproval(sessionId, entry) {
+  if (!store.has(sessionId)) store.set(sessionId, []);
+  const queue = store.get(sessionId);
+  if (queue.length >= MAX_BATCH_APPROVAL_STORE_SIZE) {
+    return "overflow";
+  }
+  queue.push(entry);
+  return "enqueued";
+}
+function removeBatchApproval(sessionId, gateId) {
+  const queue = store.get(sessionId);
+  if (!queue) return false;
+  const idx = queue.findIndex((e) => e.gateId === gateId);
+  if (idx === -1) return false;
+  queue.splice(idx, 1);
+  if (queue.length === 0) store.delete(sessionId);
+  return true;
+}
+function drainBatchApprovals(sessionId, action) {
+  const queue = store.get(sessionId);
+  if (!queue || queue.length === 0) return 0;
+  const count = queue.length;
+  for (const entry of queue) {
+    try {
+      entry.resolve(action);
+    } catch (err) {
+      console.warn(
+        `[batch-approval-store] failed to resolve ${entry.gateId}: ${err.message}`
+      );
+    }
+  }
+  store.delete(sessionId);
+  return count;
+}
+function getBatchApprovalCount(sessionId) {
+  return store.get(sessionId)?.length ?? 0;
+}
+function clearBatchApprovalStore(sessionId) {
+  drainBatchApprovals(sessionId, "reject");
+}
+
 // ../engine/src/session-registry.ts
 function createDefaultWorkflowState() {
   return {
@@ -4925,6 +5126,8 @@ async function endSession(id) {
   }
   sessionControllers.delete(session.id);
   sessionAbortReasons.delete(session.id);
+  clearBatchApprovalStore(session.id);
+  stateMachine.clearPendingApprovals(session.id);
   const channelId = session.channelId;
   const categoryId = session.categoryId;
   await sessionRepo.delete(id);
@@ -5004,6 +5207,8 @@ function abortSessionWithReason(sessionId, reason) {
     controller.abort();
     sessionControllers.delete(session.id);
   }
+  clearBatchApprovalStore(session.id);
+  stateMachine.clearPendingApprovals(session.id);
   if (session.isGenerating) {
     session.isGenerating = false;
     sessionRepo.reindex(sessionId);
@@ -5057,6 +5262,10 @@ export {
   toPlatformEvent,
   mapPlatformEventToState,
   gateService,
+  enqueueBatchApproval,
+  removeBatchApproval,
+  drainBatchApprovals,
+  getBatchApprovalCount,
   resolveEffectiveClaudePermissionMode,
   resolveEffectiveCodexOptions,
   getSessionPermissionSummary,

package/dist/{chunk-IVXCJA5I.js → chunk-MJ5JKFGS.js}

@@ -6321,6 +6321,15 @@ var config = {
   codexNetworkAccessEnabled: optionalBool("CODEX_NETWORK_ACCESS_ENABLED", true),
   codexWebSearchMode: optionalEnum("CODEX_WEB_SEARCH", "live", ["disabled", "cached", "live"]),
   codexReasoningEffort: optionalEnum("CODEX_REASONING_EFFORT", "", ["", "minimal", "low", "medium", "high", "xhigh"]),
+  /**
+   * Reasoning effort applied to Monitor-mode evaluation passes (across both providers).
+   * - Codex: forwarded to `modelReasoningEffort` on the monitor thread.
+   * - Claude: if set to 'high' or 'xhigh', switches the monitor to `monitorClaudeModel` (default: claude-opus-4-7).
+   * Empty string = inherit from the worker settings.
+   */
+  monitorReasoningEffort: optionalEnum("MONITOR_REASONING_EFFORT", "high", ["", "minimal", "low", "medium", "high", "xhigh"]),
+  /** Claude model used for monitor passes when `monitorReasoningEffort` is high/xhigh. */
+  monitorClaudeModel: optional("MONITOR_CLAUDE_MODEL", "claude-opus-4-7"),
   codexBaseUrl: optional("CODEX_BASE_URL", ""),
   codexApiKey: optional("CODEX_API_KEY", ""),
   codexPath: optional("CODEX_PATH", ""),