cogpit 3.5.1 → 3.5.2

package/dist/instance-worker.js

@@ -953,6 +953,65 @@ function refreshDirs() {
   return true;
 }
 
+// ../../shared/objects.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : null;
+}
+
+// ../../server/agents/runtimeTypes.ts
+function resolvedApproval({ requestId, toolUseId, toolName }) {
+  return { requestId, toolUseId, toolName };
+}
+var AgentRuntimeError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "AgentRuntimeError";
+  }
+};
+var NO_ACTIVITY = Object.freeze({ live: false, running: false, agentsRunning: false });
+var startingSessions = /* @__PURE__ */ new Set();
+function isSessionStarting(sessionId) {
+  return startingSessions.has(sessionId);
+}
+function finishSessionStartup(sessionId) {
+  startingSessions.delete(sessionId);
+}
+function reportSessionId(req, sessionId) {
+  if (req.beforeFirstTurn) startingSessions.add(sessionId);
+  try {
+    req.onSessionId?.(sessionId);
+  } catch (error2) {
+    console.error(`[agents] onSessionId failed for session ${sessionId}:`, error2);
+  }
+}
+function selectAvailableDecision(available, requested) {
+  if (available.includes(requested)) return requested;
+  if (requested === "allow_always" && available.includes("allow")) return "allow";
+  return null;
+}
+
+// ../../server/agents/startup.ts
+var failures = /* @__PURE__ */ new WeakSet();
+var isStartupFailure = (error2) => typeof error2 === "object" && error2 !== null && failures.has(error2);
+async function beforeFirstTurn(request, identity) {
+  try {
+    request.signal?.throwIfAborted();
+    await request.beforeFirstTurn?.(identity);
+    request.signal?.throwIfAborted();
+    if (identity.sessionId) finishSessionStartup(identity.sessionId);
+  } catch (error2) {
+    if (identity.sessionId) finishSessionStartup(identity.sessionId);
+    if (typeof error2 === "object" && error2 !== null) failures.add(error2);
+    throw error2;
+  }
+}
+
 // ../../server/agents/acpRuntime.ts
 import { spawn } from "node:child_process";
 import { appendFileSync, chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -1204,10 +1263,17 @@ function publishCompacting(sessionId, active) {
   emit(state, { type: "compacting", active });
   if (!active) maybeGc(sessionId, state);
 }
+var rateLimitListeners = /* @__PURE__ */ new Set();
 function publishRateLimit(sessionId, block) {
   const state = block ? getOrCreate(sessionId) : sessions.get(sessionId);
   if (!state || sameBlock(state.rateLimit, block)) return;
   state.rateLimit = block;
+  for (const listener of rateLimitListeners) {
+    try {
+      listener(sessionId, block);
+    } catch {
+    }
+  }
   emit(state, { type: "rate_limit", block });
   if (!block) maybeGc(sessionId, state);
 }
@@ -1294,14 +1360,6 @@ function isWithinDir(parent, child2) {
 // ../../server/agents/claudeMetadata.ts
 import { open as open3 } from "node:fs/promises";
 
-// ../../shared/objects.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asRecord(value) {
-  return isRecord(value) ? value : null;
-}
-
 // ../../shared/session/backgroundAgents.ts
 function awaitingAgentsStatus(launches, pendingQueue = 0) {
   if (!launches.some((launch) => launch.endedAt === void 0)) return null;
@@ -2208,6 +2266,29 @@ function buildTurns(messages) {
   return buildTurnsWithStarts(messages).turns;
 }
 
+// ../../shared/session/resultProjection.ts
+var ELISION_THRESHOLD_BYTES = 16 * 1024;
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function visitField(holder, key, visit, kind2 = "text") {
+  const value = holder[key];
+  if (typeof value !== "string") return false;
+  const next = visit(value, kind2);
+  if (next === value) return false;
+  holder[key] = next;
+  return true;
+}
+function visitJoinedText(parts, textOf, separator, withText, visit) {
+  const texts = parts.map(textOf);
+  const first = texts.findIndex((text2) => text2 !== void 0);
+  if (first < 0) return null;
+  const joined = texts.filter((text2) => Boolean(text2)).join(separator);
+  const replacement = visit(joined, "text");
+  if (replacement === joined) return null;
+  return parts.flatMap((part, index) => index === first ? [withText(part, replacement)] : texts[index] === void 0 ? [part] : []);
+}
+
 // ../../shared/session/claude.ts
 function isClaudeSessionText() {
   return true;
@@ -2332,17 +2413,17 @@ function collectClaudeBackgroundWork(rawMessages) {
   const resolvedAt = /* @__PURE__ */ new Map();
   const queuedIds = /* @__PURE__ */ new Set();
   const deliveredIds = /* @__PURE__ */ new Set();
-  function resolve9(id, index) {
+  function resolve10(id, index) {
     if (!resolvedAt.has(id)) resolvedAt.set(id, index);
   }
   function noteNotifications(text2, index, sink) {
     if (!text2.includes(TASK_NOTIFICATION_MARKER)) return;
     for (const match of text2.matchAll(TASK_ID_RE)) {
-      resolve9(match[1], index);
+      resolve10(match[1], index);
       sink?.add(match[1]);
     }
     for (const match of text2.matchAll(TOOL_USE_ID_RE)) {
-      resolve9(match[1], index);
+      resolve10(match[1], index);
       sink?.add(match[1]);
     }
   }
@@ -2369,7 +2450,7 @@ function collectClaudeBackgroundWork(rawMessages) {
         if (!isObject(block) || block.type !== "tool_use" || block.name !== "TaskStop") continue;
         const input = isObject(block.input) ? block.input : null;
         const taskId = input?.task_id ?? input?.shell_id;
-        if (typeof taskId === "string") resolve9(taskId, index);
+        if (typeof taskId === "string") resolve10(taskId, index);
       }
       continue;
     }
@@ -2482,6 +2563,44 @@ function brandClaudeBranch(firstRecord, sessionId, turnIndex) {
 function claudeTurnBoundaries(records) {
   return buildTurnsWithStarts(records).turnStartIndices;
 }
+var KEPT_TOOL_USE_RESULT_KEYS = /* @__PURE__ */ new Set(["bashEditDiff", "structuredPatch", "prompt", "summary", "description", "status"]);
+function visitStrings(holder, visit, depth) {
+  let changed = false;
+  for (const key of Object.keys(holder)) {
+    if (KEPT_TOOL_USE_RESULT_KEYS.has(key)) continue;
+    const value = holder[key];
+    if (typeof value === "string") changed = visitField(holder, key, visit) || changed;
+    else if (isPlainObject(value) && depth < 3) changed = visitStrings(value, visit, depth + 1) || changed;
+  }
+  return changed;
+}
+function projectClaudeResults(record3, visit) {
+  if (record3.type !== "user") return false;
+  const message = isPlainObject(record3.message) ? record3.message : null;
+  let changed = false;
+  if (message && Array.isArray(message.content)) {
+    for (const block of message.content) {
+      if (!isPlainObject(block) || block.type !== "tool_result") continue;
+      if (typeof block.content === "string") changed = visitField(block, "content", visit) || changed;
+      else if (Array.isArray(block.content)) {
+        const joined = visitJoinedText(block.content, (item) => isPlainObject(item) && item.type === "text" && typeof item.text === "string" ? item.text : void 0, "\n", (item, text2) => ({ ...item, text: text2 }), visit);
+        if (joined) {
+          block.content = joined;
+          changed = true;
+        }
+        for (const item of block.content) {
+          if (isPlainObject(item) && item.type === "image" && isPlainObject(item.source)) changed = visitField(item.source, "data", visit, "image") || changed;
+        }
+      }
+    }
+  }
+  const result = record3.toolUseResult;
+  if (typeof result === "string") changed = visitField(record3, "toolUseResult", visit) || changed;
+  else if (isPlainObject(result) && !result.agentId) {
+    changed = visitStrings(result, visit, 0) || changed;
+  }
+  return changed;
+}
 
 // ../../server/agents/transcriptHead.ts
 import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
@@ -3092,33 +3211,6 @@ function pluginSkillContext(workspacePath) {
   return current2 ? Promise.resolve().then(() => current2(workspacePath)).catch(() => "") : null;
 }
 
-// ../../server/agents/runtimeTypes.ts
-function resolvedApproval({ requestId, toolUseId, toolName }) {
-  return { requestId, toolUseId, toolName };
-}
-var AgentRuntimeError = class extends Error {
-  constructor(status, code, message, details) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.details = details;
-    this.name = "AgentRuntimeError";
-  }
-};
-var NO_ACTIVITY = Object.freeze({ live: false, running: false, agentsRunning: false });
-function reportSessionId(req, sessionId) {
-  try {
-    req.onSessionId?.(sessionId);
-  } catch (error2) {
-    console.error(`[agents] onSessionId failed for session ${sessionId}:`, error2);
-  }
-}
-function selectAvailableDecision(available, requested) {
-  if (available.includes(requested)) return requested;
-  if (requested === "allow_always" && available.includes("allow")) return "allow";
-  return null;
-}
-
 // ../../server/agents/acpRuntime.ts
 var descriptor = descriptorFor("acp");
 var sessions2 = /* @__PURE__ */ new Map();
@@ -3209,20 +3301,20 @@ async function connect() {
       if (!entry || generation !== currentGeneration || permissions.size >= 64) return { outcome: { outcome: "cancelled" } };
       const key = `${currentGeneration}:${JSON.stringify(requestId)}`;
       const decisions = params.options.flatMap((option) => option.kind === "allow_once" ? ["allow"] : option.kind === "allow_always" ? ["allow_always"] : ["deny"]);
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         const cancel = () => {
           const pending = permissions.get(key);
           if (!pending) return;
           clearTimeout(pending.timer);
           permissions.delete(key);
-          resolve9({ outcome: { outcome: "cancelled" } });
+          resolve10({ outcome: { outcome: "cancelled" } });
         };
         const timer = setTimeout(cancel, 15 * 60 * 1e3);
         timer.unref();
         signal.addEventListener("abort", cancel, { once: true });
         permissions.set(key, { approval: { timestamp: Date.now(), sessionId: entry[0], requestId: key, toolUseId: params.toolCall.toolCallId, toolName: params.toolCall.title || "Tool", input: { value: params.toolCall.rawInput ?? {} }, availableDecisions: [...new Set(decisions)] }, options: params.options, resolve: (value) => {
           signal.removeEventListener("abort", cancel);
-          resolve9(value);
+          resolve10(value);
         }, timer });
       });
     });
@@ -3264,6 +3356,7 @@ async function load(id, request) {
   return session;
 }
 async function send(id, request) {
+  if (isSessionStarting(id)) return { delivery: "busy" };
   if (request.onlyWhileRunning) return { delivery: "busy" };
   if (sending.has(id)) return { delivery: "busy" };
   sending.add(id);
@@ -3342,6 +3435,7 @@ var acpRuntime = {
   kind: "acp",
   descriptor,
   async start(request) {
+    request.signal?.throwIfAborted();
     const connected = await connect();
     const native = await bounded(connected.agent.request("session/new", { cwd: request.cwd, mcpServers: [] }, { cancellationSignal: AbortSignal.timeout(3e4) }), 3e4);
     const id = randomUUID();
@@ -3352,12 +3446,18 @@ var acpRuntime = {
     writeFileSync(path.filePath, JSON.stringify({ type: "acp_session", sessionId: id, nativeSessionId: native.sessionId, cwd: request.cwd, timestamp: (/* @__PURE__ */ new Date()).toISOString() }) + "\n", { mode: 384 });
     sessions2.set(id, { nativeId: native.sessionId, cwd: request.cwd, filePath: path.filePath, running: false, configOptions: native.configOptions ?? void 0 });
     reportSessionId(request, id);
+    try {
+      await beforeFirstTurn(request, { sessionId: id, cwd: request.cwd });
+    } catch (error2) {
+      sessions2.delete(id);
+      throw error2;
+    }
     if (request.message || request.images?.length) {
       const outcome = await send(id, request);
       void outcome.completion?.catch(() => {
       });
     }
-    return { sessionId: id, dirName, ...path, initialContent: readFileSync(path.filePath, "utf8") };
+    return { sessionId: id, dirName, cwd: request.cwd, ...path, initialContent: readFileSync(path.filePath, "utf8") };
   },
   send,
   async interrupt(id) {
@@ -3525,6 +3625,164 @@ function linkAsyncAnswers(turns) {
   });
 }
 
+// ../../shared/session/composerContext.ts
+var EMPTY_DRAFT = Object.freeze({ v: 1, text: "", context: [], attachments: [] });
+var CONTEXT_LIMITS = Object.freeze({ items: 12, itemChars: 2e4, metadataChars: 2e3, totalChars: 1e5, noteChars: 2e3 });
+var ID_RE = /^ctx-[a-z0-9]{8,32}$/;
+function itemChars(item) {
+  return item.kind === "browser" ? item.note.length : item.kind === "file" ? (item.text?.length ?? 0) + (item.comment?.length ?? 0) : item.text.length;
+}
+function itemRefusal(item) {
+  if (!ID_RE.test(item.id)) return "This context has no valid id";
+  if (itemChars(item) > CONTEXT_LIMITS.itemChars) return `This context is longer than ${CONTEXT_LIMITS.itemChars.toLocaleString("en-US")} characters`;
+  if (item.kind === "browser" && item.note.length > CONTEXT_LIMITS.noteChars) return `An annotation note is limited to ${CONTEXT_LIMITS.noteChars.toLocaleString("en-US")} characters`;
+  const metadata = attributes(item).filter(([key]) => key !== "comment");
+  if (metadata.some(([, value]) => value.length > CONTEXT_LIMITS.metadataChars)) return `This context's ${metadata.find(([, value]) => value.length > CONTEXT_LIMITS.metadataChars)[0]} is longer than ${CONTEXT_LIMITS.metadataChars.toLocaleString("en-US")} characters`;
+  return null;
+}
+function contextRefusal(context, item) {
+  if (context.some((existing) => existing.id === item.id)) return null;
+  if (context.length >= CONTEXT_LIMITS.items) return `A message holds at most ${CONTEXT_LIMITS.items} context items`;
+  const refusal = itemRefusal(item);
+  if (refusal) return refusal;
+  const total = [...context, item].reduce((sum, existing) => sum + renderContextItem(existing).length, 0);
+  if (total > CONTEXT_LIMITS.totalChars) return `The message's context would exceed ${CONTEXT_LIMITS.totalChars.toLocaleString("en-US")} characters`;
+  return null;
+}
+function validateContext(context) {
+  const accepted = [];
+  for (const item of context) {
+    if (accepted.some((existing) => existing.id === item.id)) return "The same context appears twice";
+    const refusal = contextRefusal(accepted, item);
+    if (refusal) return refusal;
+    accepted.push(item);
+  }
+  return null;
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;");
+}
+function unescapeAttribute(value) {
+  return value.replace(/&#10;/g, "\n").replace(/&#13;/g, "\r").replace(/&lt;/g, "<").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
+}
+var CLOSE = "</context>";
+function escapeBody(text2) {
+  return text2.split("\n").map((line) => /^ *<\/context>/.test(line) ? ` ${line}` : line).join("\n");
+}
+function unescapeBody(text2) {
+  return text2.split("\n").map((line) => /^ +<\/context>/.test(line) ? line.slice(1) : line).join("\n");
+}
+function attributes(item) {
+  switch (item.kind) {
+    case "file":
+      return [
+        ["path", item.path],
+        ...item.startLine !== void 0 ? [["lines", item.endLine !== void 0 && item.endLine !== item.startLine ? `${item.startLine}-${item.endLine}` : String(item.startLine)]] : [],
+        ...item.comment ? [["comment", item.comment]] : []
+      ];
+    case "terminal":
+      return item.label ? [["label", item.label]] : [];
+    case "quote":
+      return [["session", item.source.sessionId], ["turn", item.source.turnId], ["dir", item.source.dirName], ["file", item.source.fileName]];
+    case "browser":
+      return [
+        ["url", item.url],
+        ["title", item.title],
+        ["viewport", `${item.viewport.width}x${item.viewport.height}`],
+        ["region", `${item.region.x},${item.region.y},${item.region.width},${item.region.height}`],
+        ["captured", item.capturedAt],
+        ["browser", item.browser],
+        ...item.tab ? [["tab", item.tab]] : [],
+        ["image", String(item.image)]
+      ];
+  }
+}
+function body(item) {
+  return item.kind === "browser" ? item.note : item.kind === "file" ? item.text ?? "" : item.text;
+}
+function renderContextItem(item) {
+  const attrs = [["id", item.id], ["kind", item.kind], ...attributes(item)].map(([key, value]) => `${key}="${escapeAttribute(value)}"`).join(" ");
+  return `<context ${attrs}>
+${escapeBody(body(item))}
+${CLOSE}`;
+}
+var OPEN_RE = /^<context ((?:[a-z]+="[^"]*"\s*)+)>\n/;
+function parseAttributes(source) {
+  const found = /* @__PURE__ */ new Map();
+  for (const match of source.matchAll(/([a-z]+)="([^"]*)"/g)) found.set(match[1], unescapeAttribute(match[2]));
+  return found;
+}
+function positive(value) {
+  if (value === void 0 || !/^\d+$/.test(value)) return void 0;
+  return Number(value);
+}
+function itemFrom(attrs, text2) {
+  const id = attrs.get("id");
+  if (!id || !ID_RE.test(id)) return null;
+  switch (attrs.get("kind")) {
+    case "file": {
+      const path = attrs.get("path");
+      if (!path) return null;
+      const [start, end] = (attrs.get("lines") ?? "").split("-");
+      const startLine = positive(start);
+      const endLine = positive(end) ?? startLine;
+      const comment = attrs.get("comment");
+      return { id, kind: "file", path, ...startLine !== void 0 ? { startLine, endLine } : {}, ...text2 ? { text: text2 } : {}, ...comment ? { comment } : {} };
+    }
+    case "terminal": {
+      const label = attrs.get("label");
+      return { id, kind: "terminal", text: text2, ...label ? { label } : {} };
+    }
+    case "quote": {
+      const [sessionId, turnId, dirName, fileName] = ["session", "turn", "dir", "file"].map((key) => attrs.get(key));
+      if (!sessionId || !turnId || !dirName || !fileName) return null;
+      return { id, kind: "quote", text: text2, source: { sessionId, turnId, dirName, fileName } };
+    }
+    case "browser": {
+      const viewport = (attrs.get("viewport") ?? "").split("x").map(Number);
+      const region = (attrs.get("region") ?? "").split(",").map(Number);
+      const image = positive(attrs.get("image"));
+      if (viewport.length !== 2 || region.length !== 4 || ![...viewport, ...region].every(Number.isFinite) || !image) return null;
+      const tab = attrs.get("tab");
+      return {
+        id,
+        kind: "browser",
+        note: text2,
+        url: attrs.get("url") ?? "",
+        title: attrs.get("title") ?? "",
+        viewport: { width: viewport[0], height: viewport[1] },
+        region: { x: region[0], y: region[1], width: region[2], height: region[3] },
+        capturedAt: attrs.get("captured") ?? "",
+        browser: attrs.get("browser") ?? "",
+        ...tab ? { tab } : {},
+        image
+      };
+    }
+    default:
+      return null;
+  }
+}
+function parseComposerMessage(message) {
+  const context = [];
+  let rest = message;
+  for (; ; ) {
+    const open6 = OPEN_RE.exec(rest);
+    if (!open6) break;
+    const end = rest.indexOf(`
+${CLOSE}`, open6[0].length - 1);
+    if (end < 0) break;
+    const item = itemFrom(parseAttributes(open6[1]), unescapeBody(rest.slice(open6[0].length, end)));
+    if (!item) break;
+    context.push(item);
+    rest = rest.slice(end + CLOSE.length + 1).replace(/^\n{1,2}/, "");
+  }
+  if (context.length === 0 || validateContext(context)) return null;
+  return { context, text: rest.trim() };
+}
+function composerPromptText(message) {
+  return parseComposerMessage(message)?.text ?? message;
+}
+
 // ../../shared/session/codex-exec.ts
 var JS_SIMPLE_ESCAPES = {
   "0": "\0",
@@ -3646,11 +3904,11 @@ function parseApplyPatch(patchText, callId, timestamp, cwd = "") {
   for (let i = 0; i < sections.length; i++) {
     const section = sections[i];
     const endIdx = i + 1 < sections.length ? sections[i + 1].headerIdx : patchText.length;
-    const body = patchText.slice(section.startIdx, endIdx);
-    const movedTo = body.match(/^\*\*\*\s+Move to:\s*(.+)$/m)?.[1]?.trim();
+    const body2 = patchText.slice(section.startIdx, endIdx);
+    const movedTo = body2.match(/^\*\*\*\s+Move to:\s*(.+)$/m)?.[1]?.trim();
     const sourcePath = resolveCodexPatchPath(section.filePath, cwd);
     const filePath = resolveCodexPatchPath(movedTo || section.filePath, cwd);
-    const hunkBodies = body.split(/^@@.*$/m).filter((s) => s.trim());
+    const hunkBodies = body2.split(/^@@.*$/m).filter((s) => s.trim());
     const oldLines = [];
     const newLines = [];
     for (const hunk of hunkBodies) {
@@ -4255,7 +4513,7 @@ function extractMetadataFromRecords(records) {
       model ||= typeof record3.payload.model === "string" ? record3.payload.model : "";
       cwd ||= typeof record3.payload.cwd === "string" ? record3.payload.cwd : "";
     }
-    const prompt = readPrompt(record3);
+    const prompt = composerPromptText(readPrompt(record3));
     if (!prompt) continue;
     if (!firstUserMessage) firstUserMessage = prompt;
     lastUserMessage = prompt;
@@ -5368,7 +5626,7 @@ function extractMetadata(events) {
     if (event.type !== "user.message") continue;
     metadata.turnCount++;
     metadata.timestamp ||= timestamp;
-    const content = readString(data.content).trim();
+    const content = composerPromptText(readString(data.content)).trim();
     if (!content) continue;
     metadata.firstUserMessage ||= content;
     metadata.lastUserMessage = content;
@@ -6131,6 +6389,24 @@ function copilotTurnBoundaries(records) {
   }
   return boundaries;
 }
+function projectCopilotResults(record3, visit) {
+  if (record3.type !== "tool.execution_complete" || !isObject4(record3.data)) return false;
+  const data = record3.data;
+  if (typeof data.result === "string") return visitField(data, "result", visit);
+  if (!isObject4(data.result)) return false;
+  const result = data.result;
+  let changed = visitField(result, "detailedContent", visit);
+  changed = visitField(result, "content", visit) || changed;
+  if (Array.isArray(result.contents)) {
+    const textOf = (part) => (typeof part === "string" ? part : isObject4(part) ? readString(part.text, part.content, part.output) : "") || void 0;
+    const joined = visitJoinedText(result.contents, textOf, "\n", (part, text2) => typeof part === "string" ? text2 : { ...part, text: text2 }, visit);
+    if (joined) {
+      result.contents = joined;
+      changed = true;
+    }
+  }
+  return changed;
+}
 
 // ../../server/agents/copilotMetadata.ts
 function parseSimpleYamlValue(raw) {
@@ -6286,7 +6562,22 @@ function openDatabase(path) {
   return new Database(path);
 }
 
+// ../../shared/contracts/triggers.ts
+var TERMINAL_OCCURRENCE_STATES = ["completed", "failed", "cancelled", "skipped"];
+function occurrenceCommandId(occurrenceId) {
+  return `trg-${occurrenceId}`;
+}
+function occurrenceCreationId(occurrenceId) {
+  return `trgc-${occurrenceId}`;
+}
+function isTerminalOccurrence(state) {
+  return TERMINAL_OCCURRENCE_STATES.includes(state);
+}
+
 // ../../server/orchestration/store.ts
+var OCCURRENCE_REQUEST_LIMIT = 256 * 1024;
+var OCCURRENCE_INPUTS_LIMIT = 1024 * 1024;
+var ACTIVE_OCCURRENCE = "('admitting','creating')";
 var OrchestrationError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -6323,7 +6614,7 @@ var OrchestrationStore = class {
     try {
       this.db.exec("PRAGMA busy_timeout=5000; PRAGMA foreign_keys=ON; PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL;");
       const version = Number(this.db.prepare("PRAGMA user_version").get().user_version);
-      if (version > 4) throw new Error("Orchestration database was created by a newer Cogpit; upgrade before opening it");
+      if (version > 5) throw new Error("Orchestration database was created by a newer Cogpit; upgrade before opening it");
       this.transaction(() => {
         this.db.exec(`
           CREATE TABLE IF NOT EXISTS conversations(id TEXT PRIMARY KEY, native_key TEXT UNIQUE NOT NULL, data TEXT NOT NULL);
@@ -6345,6 +6636,15 @@ var OrchestrationStore = class {
           CREATE TABLE IF NOT EXISTS crew_chat_listeners(root_id TEXT NOT NULL,session_id TEXT NOT NULL,listening INTEGER NOT NULL DEFAULT 1,cursor INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(root_id,session_id));
           CREATE TABLE IF NOT EXISTS crew_chat_deliveries(sequence INTEGER NOT NULL REFERENCES crew_chat_messages(sequence) ON DELETE CASCADE,session_id TEXT NOT NULL,scope TEXT NOT NULL,kind TEXT NOT NULL,state TEXT NOT NULL DEFAULT 'pending',error TEXT,PRIMARY KEY(sequence,session_id));
           CREATE INDEX IF NOT EXISTS crew_chat_pending ON crew_chat_deliveries(scope,state,sequence);
+          CREATE TABLE IF NOT EXISTS execution_grants(id TEXT PRIMARY KEY,scope TEXT NOT NULL,revision INTEGER NOT NULL,data TEXT NOT NULL,revoked_at INTEGER);
+          CREATE TABLE IF NOT EXISTS triggers(scope TEXT NOT NULL,id TEXT NOT NULL,kind TEXT NOT NULL,revision INTEGER NOT NULL,state TEXT NOT NULL,next_due_at INTEGER,data TEXT NOT NULL,created_at INTEGER NOT NULL,updated_at INTEGER NOT NULL,PRIMARY KEY(scope,id));
+          CREATE INDEX IF NOT EXISTS trigger_due ON triggers(kind,state,next_due_at);
+          CREATE TABLE IF NOT EXISTS trigger_secrets(scope TEXT NOT NULL,trigger_id TEXT NOT NULL,id TEXT NOT NULL,data TEXT NOT NULL,created_at INTEGER NOT NULL,retired_at INTEGER,PRIMARY KEY(scope,trigger_id,id));
+          CREATE TABLE IF NOT EXISTS trigger_occurrences(scope TEXT NOT NULL,id TEXT NOT NULL,trigger_id TEXT NOT NULL,kind TEXT NOT NULL,state TEXT NOT NULL,due_at INTEGER NOT NULL,attempt INTEGER NOT NULL DEFAULT 0,epoch INTEGER NOT NULL DEFAULT 0,fence_conversation TEXT,fence_position INTEGER,data TEXT NOT NULL,created_at INTEGER NOT NULL,updated_at INTEGER NOT NULL,PRIMARY KEY(scope,id));
+          CREATE INDEX IF NOT EXISTS occurrence_due ON trigger_occurrences(state,due_at);
+          CREATE INDEX IF NOT EXISTS occurrence_trigger ON trigger_occurrences(scope,trigger_id,created_at);
+          CREATE INDEX IF NOT EXISTS occurrence_fence ON trigger_occurrences(fence_conversation,state);
+          CREATE TABLE IF NOT EXISTS trigger_keys(scope TEXT NOT NULL,trigger_id TEXT NOT NULL,key TEXT NOT NULL,occurrence_id TEXT NOT NULL,fingerprint TEXT NOT NULL,created_at INTEGER NOT NULL,PRIMARY KEY(scope,trigger_id,key));
         `);
         if (!this.db.prepare("PRAGMA table_info(events)").all().some((row) => row.name === "scope")) this.db.exec("ALTER TABLE events ADD COLUMN scope TEXT");
         if (!this.db.prepare("PRAGMA table_info(operations)").all().some((row) => row.name === "updated_at")) this.db.exec("ALTER TABLE operations ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0");
@@ -6353,7 +6653,7 @@ var OrchestrationStore = class {
           this.db.exec("ALTER TABLE transitions ADD COLUMN scope TEXT");
           this.db.exec("UPDATE transitions SET scope=(SELECT scope FROM operations WHERE id=transitions.operation_id) WHERE (SELECT COUNT(*) FROM operations WHERE id=transitions.operation_id)=1");
         }
-        this.db.exec("PRAGMA user_version=4");
+        this.db.exec("PRAGMA user_version=5");
       });
       this.protectFiles();
     } catch (error2) {
@@ -6363,7 +6663,9 @@ var OrchestrationStore = class {
   }
   db;
   listeners = /* @__PURE__ */ new Set();
+  triggerListeners = /* @__PURE__ */ new Set();
   pendingEvents = null;
+  pendingTriggerEvents = [];
   protectFiles() {
     if (this.path === ":memory:" || process.platform === "win32") return;
     for (const file of [this.path, `${this.path}-wal`, `${this.path}-shm`]) if (existsSync(file)) chmodSync2(file, 384);
@@ -6380,6 +6682,7 @@ var OrchestrationStore = class {
       events = this.pendingEvents;
     } catch (error2) {
       this.db.exec("ROLLBACK");
+      this.pendingTriggerEvents = [];
       throw error2;
     } finally {
       this.pendingEvents = null;
@@ -6391,10 +6694,17 @@ var OrchestrationStore = class {
       } catch {
       }
     }
+    for (const change of this.pendingTriggerEvents.splice(0)) for (const listener of this.triggerListeners) {
+      try {
+        listener(change);
+      } catch {
+      }
+    }
     return result;
   }
   close() {
     this.listeners.clear();
+    this.triggerListeners.clear();
     this.db.close();
   }
   chatListener(rootId, sessionId) {
@@ -6560,6 +6870,7 @@ var OrchestrationStore = class {
       const accepted = { id, nativeMessageId, conversationId, sessionId: conversation.binding.sessionId, bindingRevision: conversation.revision, state: "queued", intent, message: typeof payload.message === "string" ? payload.message : void 0, questionId: typeof payload.questionId === "string" ? payload.questionId : void 0, createdAt: this.now(), updatedAt: this.now(), position, replaces };
       this.db.prepare("INSERT INTO commands(scope,id,conversation_id,fingerprint,payload,receipt,state,position,updated_at) VALUES(?,?,?,?,?,?,?,?,?)").run(scope, id, conversationId, hash, JSON.stringify(payload), JSON.stringify(accepted), accepted.state, position, accepted.updatedAt);
       this.event(conversationId, "command", accepted, scope);
+      if (!payload.trigger && payload.notification !== true) this.cancelFenced(conversationId, "Someone messaged the session after this was scheduled");
       return accepted;
     });
   }
@@ -6591,17 +6902,23 @@ var OrchestrationStore = class {
       for (const command of this.pending()) {
         if (["delivered", "unknown"].includes(command.receipt.state) && settlesOnDelivery(command.receipt.delivery, command.payload)) this.update(command, "completed", { error: void 0 });
         else if (command.receipt.state === "dispatching" || command.receipt.state === "delivered") this.update(command, "unknown", { error: "Host stopped during delivery. Inspect native history before resolving or resending." });
-        else if (command.receipt.state === "queued") this.update(command, "held", { error: "Host restarted; resume this queue after reviewing it." });
+        else if (command.receipt.state === "queued" && !command.payload.executionGrant) this.update(command, "held", { error: "Host restarted; resume this queue after reviewing it." });
       }
+      this.reconcileOccurrences(epoch);
       return { owner, epoch };
     });
   }
+  /** Gives the lease up for good: nothing the released owner still has in flight can write under it. */
   release(lease) {
-    this.db.prepare("UPDATE dispatcher SET expires_at=0 WHERE id=1 AND owner=? AND epoch=?").run(lease.owner, lease.epoch);
+    this.db.prepare("UPDATE dispatcher SET owner='',expires_at=0 WHERE id=1 AND owner=? AND epoch=?").run(lease.owner, lease.epoch);
   }
   owns(lease) {
     return Boolean(this.db.prepare("SELECT 1 FROM dispatcher WHERE id=1 AND owner=? AND epoch=?").get(lease.owner, lease.epoch));
   }
+  /** Whether `lease` is still the one held: released and taken-over leases are not. */
+  ownsLease(lease) {
+    return this.owns(lease);
+  }
   currentAttempt(command, lease) {
     const current2 = this.command(command.scope, command.receipt.id);
     return this.owns(lease) && Boolean(current2 && current2.attempt === command.attempt && current2.epoch === lease.epoch && ["dispatching", "delivered"].includes(current2.receipt.state));
@@ -6676,6 +6993,7 @@ var OrchestrationStore = class {
     return this.transaction(() => {
       const waiting = this.db.prepare("SELECT scope,id FROM commands WHERE conversation_id=? AND state IN ('queued','held')").all(conversationId).map((row) => this.command(String(row.scope), String(row.id)));
       for (const command of waiting) this.update(command, "cancelled", { error: "The session was stopped" });
+      this.cancelFenced(conversationId, "The session was stopped");
       return waiting.length;
     });
   }
@@ -6815,6 +7133,7 @@ var OrchestrationStore = class {
       this.db.prepare("DELETE FROM crew_chat_messages WHERE root_id=?").run(sessionId);
       this.db.prepare("DELETE FROM crew_chat_listeners WHERE root_id=? OR session_id=?").run(sessionId, sessionId);
       this.db.prepare("DELETE FROM crew_chat_deliveries WHERE session_id=?").run(sessionId);
+      for (const row of this.db.prepare("SELECT scope,id FROM trigger_occurrences WHERE json_extract(data,'$.sessionId')=? AND state NOT IN ('completed','failed','cancelled','skipped')").all(sessionId)) this.settleOccurrence(String(row.scope), String(row.id), "cancelled", { reason: "The session was deleted" });
       this.db.prepare("DELETE FROM commands WHERE json_extract(receipt,'$.sessionId')=?").run(sessionId);
       for (const row of this.db.prepare("SELECT native_key,conversation_id,data FROM bindings").all()) {
         if (decode(row.data).sessionId !== sessionId) continue;
@@ -6855,6 +7174,10 @@ var OrchestrationStore = class {
         const task = decode(row.data);
         if (task.acknowledgedAt && task.acknowledgedAt < cutoff) this.db.prepare("UPDATE tasks SET data=? WHERE id=?").run(JSON.stringify({ ...task, result: void 0 }), String(row.id));
       }
+      this.db.prepare("DELETE FROM trigger_occurrences WHERE updated_at<? AND state IN ('completed','failed','cancelled','skipped')").run(cutoff);
+      this.db.prepare("DELETE FROM trigger_keys WHERE created_at<? AND occurrence_id NOT IN (SELECT id FROM trigger_occurrences)").run(cutoff);
+      this.db.prepare("DELETE FROM trigger_secrets WHERE retired_at IS NOT NULL AND retired_at<?").run(cutoff);
+      this.db.prepare("DELETE FROM execution_grants WHERE revoked_at IS NOT NULL AND revoked_at<?").run(cutoff);
     });
   }
   instances() {
@@ -6894,11 +7217,410 @@ var OrchestrationStore = class {
       return { fresh: importedResult === void 0, ...importedResult === void 0 ? {} : { result: importedResult } };
     });
   }
+  /** Forgets a creation claim that provably started nothing, so the same identity can start it later. */
+  abandonOperation(scope, id) {
+    this.transaction(() => {
+      this.db.prepare("DELETE FROM operations WHERE scope=? AND id=? AND result IS NULL").run(scope, id);
+    });
+  }
   finishOperation(scope, id, result) {
     this.transaction(() => {
       this.db.prepare("UPDATE operations SET result=?,updated_at=? WHERE scope=? AND id=? AND result IS NULL").run(JSON.stringify(result), this.now(), scope, id);
     });
   }
+  // ── Unattended execution grants ──────────────────────────────────
+  putGrant(grant) {
+    return this.transaction(() => {
+      this.db.prepare("INSERT INTO execution_grants(id,scope,revision,data,revoked_at) VALUES(?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET revision=excluded.revision,data=excluded.data,revoked_at=excluded.revoked_at").run(grant.id, grant.scope, grant.revision, JSON.stringify(grant), grant.revokedAt ?? null);
+      return grant;
+    });
+  }
+  grant(id) {
+    const row = this.db.prepare("SELECT data FROM execution_grants WHERE id=?").get(id);
+    return row ? decode(row.data) : null;
+  }
+  grants(scope) {
+    return this.db.prepare("SELECT data FROM execution_grants WHERE scope=? ORDER BY id").all(scope).map((row) => decode(row.data));
+  }
+  /** Revokes a grant for good; work it admitted is held for reauthorization as soon as it is next claimed. */
+  revokeGrant(id, reason) {
+    return this.transaction(() => {
+      const grant = this.grant(id);
+      if (!grant || grant.revokedAt) return grant;
+      return this.putGrant({ ...grant, revision: grant.revision + 1, revokedAt: this.now(), revokedReason: reason, updatedAt: this.now() });
+    });
+  }
+  // ── Trigger definitions ──────────────────────────────────────────
+  /** Whether any definition is active or any occurrence is still open, so the scheduler must run. */
+  hasTriggerWork() {
+    return Boolean(this.db.prepare("SELECT 1 FROM triggers WHERE state='active' UNION ALL SELECT 1 FROM trigger_occurrences WHERE state NOT IN ('completed','failed','cancelled','skipped') LIMIT 1").get());
+  }
+  subscribeTriggers(listener) {
+    this.triggerListeners.add(listener);
+    return () => this.triggerListeners.delete(listener);
+  }
+  triggerEvent(type, scope, triggerId, id) {
+    this.pendingTriggerEvents.push({ type, scope, triggerId, id });
+  }
+  triggerRecord(row) {
+    const data = decode(row.data);
+    return { id: String(row.id), scope: String(row.scope), kind: String(row.kind), revision: Number(row.revision), state: row.state, grant: data.grant, nextDueAt: row.next_due_at === null ? null : Number(row.next_due_at), data: data.data, createdAt: Number(row.created_at), updatedAt: Number(row.updated_at) };
+  }
+  trigger(scope, id) {
+    const row = this.db.prepare("SELECT * FROM triggers WHERE scope=? AND id=?").get(scope, id);
+    return row ? this.triggerRecord(row) : null;
+  }
+  triggers(scope, kind2) {
+    const rows = scope === null ? this.db.prepare("SELECT * FROM triggers WHERE kind=? ORDER BY created_at,id").all(kind2) : this.db.prepare("SELECT * FROM triggers WHERE scope=? AND kind=? ORDER BY created_at,id").all(scope, kind2);
+    return rows.map((row) => this.triggerRecord(row));
+  }
+  /** Active definitions of `kind` whose consumer asked to be woken by now. */
+  dueTriggers(kind2) {
+    return this.db.prepare("SELECT * FROM triggers WHERE kind=? AND state='active' AND next_due_at IS NOT NULL AND next_due_at<=? ORDER BY next_due_at").all(kind2, this.now()).map((row) => this.triggerRecord(row));
+  }
+  /** Creates a definition, or replaces it when `expectedRevision` is the stored one. */
+  putTrigger(scope, input, expectedRevision) {
+    if (!/^[a-zA-Z0-9_-]{8,128}$/.test(input.id)) throw new OrchestrationError(400, "Trigger ids must contain 8\u2013128 letters, digits, underscores or hyphens");
+    if (JSON.stringify(input.data).length > OCCURRENCE_REQUEST_LIMIT) throw new OrchestrationError(413, "Trigger definition is too large");
+    return this.transaction(() => {
+      const old = this.trigger(scope, input.id);
+      if (old && old.kind !== input.kind) throw new OrchestrationError(409, "Trigger id already belongs to another kind");
+      if (old && expectedRevision === void 0) throw new OrchestrationError(409, "Trigger already exists");
+      if (expectedRevision !== void 0 && old?.revision !== expectedRevision) throw new OrchestrationError(409, "Trigger changed; refresh before saving");
+      const revision = (old?.revision ?? 0) + 1;
+      const data = JSON.stringify({ grant: input.grant, data: input.data });
+      this.db.prepare("INSERT INTO triggers(scope,id,kind,revision,state,next_due_at,data,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?) ON CONFLICT(scope,id) DO UPDATE SET revision=excluded.revision,state=excluded.state,next_due_at=excluded.next_due_at,data=excluded.data,updated_at=excluded.updated_at").run(scope, input.id, input.kind, revision, input.state, input.nextDueAt, data, old?.createdAt ?? this.now(), this.now());
+      this.triggerEvent("trigger", scope, input.id, input.id);
+      return this.trigger(scope, input.id);
+    });
+  }
+  /** Moves a definition's next wake-up without counting as an edit, unless it changed since `revision`. */
+  setTriggerDue(scope, id, revision, nextDueAt) {
+    return this.transaction(() => {
+      const changed = Number(this.db.prepare("UPDATE triggers SET next_due_at=? WHERE scope=? AND id=? AND revision=?").run(nextDueAt, scope, id, revision).changes) > 0;
+      if (changed) this.triggerEvent("trigger", scope, id, id);
+      return changed;
+    });
+  }
+  /** Deletes a definition with its secrets, cancels what it still has waiting, and revokes a grant nothing else uses. */
+  deleteTrigger(scope, id) {
+    this.transaction(() => {
+      const trigger = this.trigger(scope, id);
+      if (!trigger) return;
+      for (const row of this.db.prepare(`SELECT id FROM trigger_occurrences WHERE scope=? AND trigger_id=? AND state IN ('scheduled','held')`).all(scope, id)) this.cancelOccurrence(scope, String(row.id), "The task was deleted");
+      this.db.prepare("DELETE FROM trigger_secrets WHERE scope=? AND trigger_id=?").run(scope, id);
+      this.db.prepare("DELETE FROM triggers WHERE scope=? AND id=?").run(scope, id);
+      const grantId = trigger.grant?.grantId;
+      if (grantId && !this.db.prepare("SELECT 1 FROM triggers WHERE json_extract(data,'$.grant.grantId')=? LIMIT 1").get(grantId)) this.revokeGrant(grantId, "Its task was deleted");
+      this.triggerEvent("trigger", scope, id, id);
+    });
+  }
+  /** Key material a consumer verifies deliveries with. Never part of a definition, a list or a log. */
+  putTriggerSecret(scope, triggerId, id, data) {
+    this.transaction(() => {
+      this.db.prepare("INSERT INTO trigger_secrets(scope,trigger_id,id,data,created_at) VALUES(?,?,?,?,?)").run(scope, triggerId, id, JSON.stringify(data), this.now());
+    });
+  }
+  /** Retires every secret but `keep`, which stay valid for `graceMs` so a rotation does not drop deliveries already in flight. */
+  retireTriggerSecrets(scope, triggerId, keep, graceMs) {
+    this.transaction(() => {
+      this.db.prepare("UPDATE trigger_secrets SET retired_at=? WHERE scope=? AND trigger_id=? AND id<>? AND retired_at IS NULL").run(this.now() + graceMs, scope, triggerId, keep);
+    });
+  }
+  triggerSecrets(scope, triggerId) {
+    return this.db.prepare("SELECT id,data,created_at FROM trigger_secrets WHERE scope=? AND trigger_id=? AND (retired_at IS NULL OR retired_at>?) ORDER BY created_at DESC").all(scope, triggerId, this.now()).map((row) => ({ id: String(row.id), data: decode(row.data), createdAt: Number(row.created_at) }));
+  }
+  // ── Trigger occurrences ──────────────────────────────────────────
+  occurrenceRow(row) {
+    const data = decode(row.data);
+    const command = this.command(String(row.scope), data.commandId)?.receipt;
+    return { ...data, id: String(row.id), scope: String(row.scope), triggerId: String(row.trigger_id), kind: String(row.kind), state: row.state, dueAt: Number(row.due_at), attempt: Number(row.attempt), createdAt: Number(row.created_at), updatedAt: Number(row.updated_at), ...command ? { command } : {} };
+  }
+  occurrence(scope, id) {
+    const row = this.db.prepare("SELECT * FROM trigger_occurrences WHERE scope=? AND id=?").get(scope, id);
+    return row ? this.occurrenceRow(row) : null;
+  }
+  /** A trigger's occurrences, newest first. */
+  occurrences(scope, triggerId, options = {}) {
+    const limit = Math.min(200, Math.max(1, options.limit ?? 50));
+    return this.db.prepare("SELECT * FROM trigger_occurrences WHERE scope=? AND trigger_id=? AND created_at<? ORDER BY created_at DESC,id DESC LIMIT ?").all(scope, triggerId, options.before ?? Number.MAX_SAFE_INTEGER, limit).map((row) => this.occurrenceRow(row));
+  }
+  /** Every session a trigger's occurrences started, except `exceptId`'s. */
+  triggerSessionIds(scope, triggerId, exceptId) {
+    return this.db.prepare("SELECT DISTINCT json_extract(data,'$.sessionId') AS session FROM trigger_occurrences WHERE scope=? AND trigger_id=? AND id<>? AND json_extract(data,'$.sessionId') IS NOT NULL").all(scope, triggerId, exceptId ?? "").map((row) => String(row.session));
+  }
+  /** Occurrences of a trigger not yet settled: waiting, running, held or awaiting reconciliation. */
+  openOccurrences(scope, triggerId) {
+    return this.db.prepare("SELECT * FROM trigger_occurrences WHERE scope=? AND trigger_id=? AND state NOT IN ('completed','failed','cancelled','skipped') ORDER BY created_at").all(scope, triggerId).map((row) => this.occurrenceRow(row));
+  }
+  writeOccurrence(occurrence, patch, state = occurrence.state, dueAt = occurrence.dueAt) {
+    const old = decode(this.db.prepare("SELECT data FROM trigger_occurrences WHERE scope=? AND id=?").get(occurrence.scope, occurrence.id).data);
+    const terminal = isTerminalOccurrence(state);
+    const data = { ...old, ...patch, ...terminal && !old.finishedAt ? { finishedAt: this.now() } : {} };
+    this.db.prepare("UPDATE trigger_occurrences SET state=?,due_at=?,data=?,updated_at=? WHERE scope=? AND id=?").run(state, dueAt, JSON.stringify(data), this.now(), occurrence.scope, occurrence.id);
+    this.triggerEvent("occurrence", occurrence.scope, occurrence.triggerId, occurrence.id);
+  }
+  /**
+   * Records one due event. A key already recorded returns the occurrence it
+   * made (a replayed delivery or a slot computed twice); different content
+   * under the same key is refused. A burst can fold into the newest
+   * occurrence still waiting instead of starting another run.
+   */
+  recordOccurrence(scope, input) {
+    if (!input.key || input.key.length > 256) throw new OrchestrationError(400, "Occurrence keys must contain 1\u2013256 characters");
+    if (JSON.stringify(input.request).length > OCCURRENCE_REQUEST_LIMIT) throw new OrchestrationError(413, "Occurrence request is too large");
+    const hash = fingerprint({ request: input.request, data: input.input?.data ?? null, action: input.action });
+    return this.transaction(() => {
+      const seen = this.db.prepare("SELECT occurrence_id,fingerprint FROM trigger_keys WHERE scope=? AND trigger_id=? AND key=?").get(scope, input.triggerId, input.key);
+      if (seen) {
+        if (seen.fingerprint !== hash) throw new OrchestrationError(409, "This delivery id was already recorded with different content");
+        const existing = this.occurrence(scope, String(seen.occurrence_id));
+        if (existing) return { occurrence: existing, outcome: "duplicate" };
+        throw new OrchestrationError(409, "This delivery id was already recorded");
+      }
+      const received = input.input ? { key: input.key, receivedAt: this.now(), data: input.input.data } : void 0;
+      if (input.coalesce && received) {
+        const row = this.db.prepare("SELECT * FROM trigger_occurrences WHERE scope=? AND trigger_id=? AND state='scheduled' AND created_at>=? AND json_extract(data,'$.coalesceGroup')=? ORDER BY created_at DESC LIMIT 1").get(scope, input.triggerId, this.now() - input.coalesce.windowMs, input.coalesce.group);
+        const target = row && this.occurrenceRow(row);
+        if (target && target.inputs.length < input.coalesce.maxInputs && JSON.stringify([...target.inputs, received]).length <= OCCURRENCE_INPUTS_LIMIT) {
+          this.writeOccurrence(target, { inputs: [...target.inputs, received] });
+          this.db.prepare("INSERT INTO trigger_keys VALUES(?,?,?,?,?,?)").run(scope, input.triggerId, input.key, target.id, hash, this.now());
+          return { occurrence: this.occurrence(scope, target.id), outcome: "coalesced" };
+        }
+      }
+      if (received && JSON.stringify(received).length > OCCURRENCE_INPUTS_LIMIT) throw new OrchestrationError(413, "Occurrence input is too large");
+      const waiting = Number(this.db.prepare("SELECT COUNT(*) AS n FROM trigger_occurrences WHERE scope=? AND trigger_id=? AND state IN ('scheduled','held')").get(scope, input.triggerId).n);
+      if (waiting >= (input.backlog ?? 100)) throw new OrchestrationError(429, "Too many runs of this task are already waiting");
+      const id = `occ-${fingerprint([scope, input.triggerId, input.key]).slice(0, 32)}`;
+      const fencePosition = input.fence ? Number(this.db.prepare("SELECT COALESCE(MAX(position),0) AS n FROM commands WHERE conversation_id=?").get(input.fence.conversationId).n) : null;
+      const data = { key: input.key, action: input.action, grant: input.grant, request: input.request, inputs: received ? [received] : [], commandId: occurrenceCommandId(id), creationId: occurrenceCreationId(id), ...input.guarded ? { guarded: true } : {}, ...input.coalesce ? { coalesceGroup: input.coalesce.group } : {} };
+      this.db.prepare("INSERT INTO trigger_occurrences(scope,id,trigger_id,kind,state,due_at,fence_conversation,fence_position,data,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?)").run(scope, id, input.triggerId, input.kind, "scheduled", input.dueAt, input.fence?.conversationId ?? null, fencePosition, JSON.stringify(data), this.now(), this.now());
+      this.db.prepare("INSERT INTO trigger_keys VALUES(?,?,?,?,?,?)").run(scope, input.triggerId, input.key, id, hash, this.now());
+      this.triggerEvent("occurrence", scope, input.triggerId, id);
+      return { occurrence: this.occurrence(scope, id), outcome: "created" };
+    });
+  }
+  /**
+   * Claims due occurrences of `kinds` for this lease, one at a time per
+   * trigger: a trigger with an occurrence still being admitted or created
+   * waits for it.
+   */
+  claimOccurrences(lease, kinds, limit = 20) {
+    if (!kinds.length) return [];
+    return this.transaction(() => {
+      if (!this.owns(lease)) return [];
+      const rows = this.db.prepare(`SELECT * FROM trigger_occurrences o WHERE state='scheduled' AND due_at<=? AND kind IN (${kinds.map(() => "?").join(",")}) AND NOT EXISTS (SELECT 1 FROM trigger_occurrences a WHERE a.scope=o.scope AND a.trigger_id=o.trigger_id AND a.state IN ${ACTIVE_OCCURRENCE}) ORDER BY due_at,created_at LIMIT ?`).all(this.now(), ...kinds, limit);
+      const claimed = [];
+      const triggers = /* @__PURE__ */ new Set();
+      for (const row of rows) {
+        const key = JSON.stringify([row.scope, row.trigger_id]);
+        if (triggers.has(key)) continue;
+        triggers.add(key);
+        this.db.prepare("UPDATE trigger_occurrences SET state='admitting',attempt=attempt+1,epoch=?,updated_at=? WHERE scope=? AND id=?").run(lease.epoch, this.now(), String(row.scope), String(row.id));
+        this.triggerEvent("occurrence", String(row.scope), String(row.trigger_id), String(row.id));
+        const occurrence = this.occurrence(String(row.scope), String(row.id));
+        claimed.push({ occurrence, attempt: occurrence.attempt, epoch: lease.epoch });
+      }
+      return claimed;
+    });
+  }
+  claimCurrent(claim, lease, states) {
+    if (!this.owns(lease) || lease.epoch !== claim.epoch) return null;
+    const row = this.db.prepare("SELECT * FROM trigger_occurrences WHERE scope=? AND id=? AND attempt=? AND epoch=?").get(claim.occurrence.scope, claim.occurrence.id, claim.attempt, claim.epoch);
+    const occurrence = row && this.occurrenceRow(row);
+    return occurrence && states.includes(occurrence.state) ? occurrence : null;
+  }
+  /** Whether a claim still owns its occurrence; every write a claimed execution makes checks it first. */
+  occurrenceCurrent(claim, lease) {
+    return this.claimCurrent(claim, lease, ["admitting", "creating"]) !== null;
+  }
+  /** Settles a claimed occurrence; false when another attempt or host owns it now. */
+  finishOccurrence(claim, lease, state, details = {}) {
+    return this.transaction(() => {
+      const current2 = this.claimCurrent(claim, lease, ["admitting", "creating"]);
+      if (!current2) return false;
+      const { dueAt, ...patch } = details;
+      this.writeOccurrence(current2, { hold: void 0, reason: void 0, ...patch }, state, dueAt ?? current2.dueAt);
+      return true;
+    });
+  }
+  /**
+   * Marks a claimed occurrence as creating a session. From here a crash
+   * leaves its creation operation to say what happened: no operation means
+   * nothing started, one without a result means the outcome is unknown.
+   */
+  beginOccurrenceCreation(claim, lease) {
+    return this.transaction(() => {
+      const current2 = this.claimCurrent(claim, lease, ["admitting"]);
+      if (!current2) return false;
+      this.writeOccurrence(current2, {}, "creating");
+      return true;
+    });
+  }
+  /**
+   * Admits a claimed occurrence's durable command in the same transaction that
+   * records it, so a crash leaves either both or neither. Refuses, cancelling
+   * the occurrence, when someone else messaged its fenced conversation since
+   * it was recorded.
+   */
+  admitForOccurrence(claim, lease, conversationId, payload, intent, expectedRevision) {
+    return this.transaction(() => {
+      const current2 = this.claimCurrent(claim, lease, ["admitting"]);
+      if (!current2) return null;
+      const row = this.db.prepare("SELECT fence_conversation,fence_position FROM trigger_occurrences WHERE scope=? AND id=?").get(current2.scope, current2.id);
+      if (row.fence_conversation && this.intervened(String(row.fence_conversation), Number(row.fence_position))) {
+        this.writeOccurrence(current2, { reason: "Someone messaged the session after this was scheduled" }, "cancelled");
+        return null;
+      }
+      const conversation = this.conversation(conversationId);
+      if (expectedRevision !== void 0 && conversation?.revision !== expectedRevision) {
+        this.writeOccurrence(current2, { hold: "binding", reason: "The session moved to another provider binding; review this run before resuming it" }, "held");
+        return null;
+      }
+      const receipt2 = this.admit(current2.scope, current2.commandId, conversationId, { ...payload, trigger: { occurrenceId: current2.id } }, intent);
+      this.writeOccurrence(current2, { sessionId: receipt2.sessionId, hold: void 0, reason: void 0 }, "admitted");
+      return receipt2;
+    });
+  }
+  intervened(conversationId, position) {
+    return this.db.prepare("SELECT payload FROM commands WHERE conversation_id=? AND position>?").all(conversationId, position).some((row) => {
+      const payload = decode(row.payload);
+      return !payload.trigger && payload.notification !== true;
+    });
+  }
+  cancelFenced(conversationId, reason) {
+    for (const row of this.db.prepare("SELECT scope,id FROM trigger_occurrences WHERE fence_conversation=? AND state IN ('scheduled','held','admitting')").all(conversationId)) this.settleOccurrence(String(row.scope), String(row.id), "cancelled", { reason });
+  }
+  settleOccurrence(scope, id, state, patch) {
+    const occurrence = this.occurrence(scope, id);
+    if (occurrence) this.writeOccurrence(occurrence, patch, state);
+  }
+  /**
+   * Mirrors admitted occurrences' commands: a settled command settles its
+   * occurrence, a held or uncertain one holds it or marks it unknown with the
+   * command's reason, and one resumed from the queue makes it admitted again.
+   */
+  settleAdmittedOccurrences() {
+    return this.transaction(() => {
+      let changed = 0;
+      for (const row of this.db.prepare("SELECT * FROM trigger_occurrences WHERE state IN ('admitted','held','unknown')").all()) {
+        const occurrence = this.occurrenceRow(row);
+        const command = occurrence.command;
+        if (!command) {
+          if (occurrence.state !== "admitted") continue;
+          this.writeOccurrence(occurrence, { reason: "Its command no longer exists" }, "cancelled");
+          changed++;
+          continue;
+        }
+        const next = command.state === "completed" || command.state === "failed" || command.state === "cancelled" || command.state === "unknown" ? command.state : command.state === "held" ? "held" : "admitted";
+        if (next === occurrence.state) continue;
+        const hold = command.errorCode === "REAUTHORIZE" ? "reauthorize" : "review";
+        this.writeOccurrence(occurrence, next === "admitted" ? { hold: void 0, reason: void 0 } : { ...next === "held" ? { hold } : {}, ...command.error ? { reason: command.error } : {} }, next);
+        changed++;
+      }
+      return changed;
+    });
+  }
+  /**
+   * After another host's lease lapsed, reads what its claims left behind:
+   * an admission either committed its command or never happened, and a
+   * creation's operation says whether a session may exist.
+   */
+  reconcileOccurrences(epoch) {
+    for (const row of this.db.prepare(`SELECT * FROM trigger_occurrences WHERE state IN ${ACTIVE_OCCURRENCE} AND epoch<?`).all(epoch)) {
+      const occurrence = this.occurrenceRow(row);
+      if (occurrence.state === "admitting") {
+        if (occurrence.command) this.writeOccurrence(occurrence, { sessionId: occurrence.command.sessionId }, "admitted");
+        else this.writeOccurrence(occurrence, {}, "scheduled");
+        continue;
+      }
+      const operation = this.operation(occurrence.scope, occurrence.creationId);
+      const sessionId = operation?.result?.sessionId;
+      if (!operation) this.writeOccurrence(occurrence, {}, "scheduled");
+      else if (typeof sessionId === "string") this.writeOccurrence(occurrence, { sessionId }, "completed");
+      else this.writeOccurrence(occurrence, { reason: "The host stopped while this run was starting a session. Check the project's sessions before marking it." }, "unknown");
+    }
+  }
+  /** Cancels an occurrence that has not reached an agent yet, with its waiting command. */
+  cancelOccurrence(scope, id, reason = "Cancelled") {
+    return this.transaction(() => {
+      const occurrence = this.occurrence(scope, id);
+      if (!occurrence) throw new OrchestrationError(404, "Run not found");
+      if (isTerminalOccurrence(occurrence.state)) return occurrence;
+      if (occurrence.state === "admitting" || occurrence.state === "creating") throw new OrchestrationError(409, "This run is being started; wait for it to settle");
+      if (occurrence.state === "unknown") throw new OrchestrationError(409, "Resolve this run's unknown outcome instead");
+      const command = occurrence.command;
+      if (command && ["dispatching", "delivered", "unknown"].includes(command.state)) throw new OrchestrationError(409, "Delivery has begun; stop the session's turn instead");
+      if (command && ["queued", "held"].includes(command.state)) this.cancel(scope, command.id);
+      this.writeOccurrence(occurrence, { hold: void 0, reason }, "cancelled");
+      return this.occurrence(scope, id);
+    });
+  }
+  /**
+   * Returns a held occurrence to the schedule, due now, optionally under a
+   * renewed grant. One whose message was already admitted releases that same
+   * message — its payload and fingerprint untouched — with the grant replacing
+   * the occurrence's own, once the grant is checked to be the owner's, live,
+   * and for exactly what the old one allowed.
+   */
+  requeueOccurrence(scope, id, grant) {
+    return this.transaction(() => {
+      const occurrence = this.occurrence(scope, id);
+      if (!occurrence) throw new OrchestrationError(404, "Run not found");
+      if (occurrence.state !== "held") throw new OrchestrationError(409, "Only a held run can be resumed");
+      if (grant) this.checkReplacementGrant(scope, occurrence, grant);
+      const command = occurrence.command && this.command(scope, occurrence.command.id);
+      if (command) {
+        if (command.receipt.state !== "held") throw new OrchestrationError(409, "This run's message is not held");
+        if (this.conversation(command.receipt.conversationId)?.revision !== command.receipt.bindingRevision) throw new OrchestrationError(409, "The session moved to another provider binding; cancel this run instead");
+        this.update(command, "queued", { error: void 0, errorCode: void 0 });
+        this.writeOccurrence(occurrence, { hold: void 0, reason: void 0, ...grant ? { grant } : {} }, "admitted");
+        return this.occurrence(scope, id);
+      }
+      this.writeOccurrence(occurrence, { hold: void 0, reason: void 0, ...grant ? { grant } : {} }, "scheduled", Math.min(occurrence.dueAt, this.now()));
+      return this.occurrence(scope, id);
+    });
+  }
+  checkReplacementGrant(scope, occurrence, ref) {
+    const grant = this.grant(ref.grantId);
+    if (!grant || grant.revision !== ref.revision) throw new OrchestrationError(404, "Authorization not found");
+    if (grant.scope !== scope) throw new OrchestrationError(403, "That authorization belongs to another account");
+    if (grant.revokedAt || grant.expiresAt !== void 0 && grant.expiresAt <= this.now()) throw new OrchestrationError(409, "That authorization is no longer valid");
+    if (!grant.actions.includes(occurrence.action)) throw new OrchestrationError(409, "That authorization does not allow this run");
+    const previous = occurrence.grant && this.grant(occurrence.grant.grantId);
+    const command = occurrence.command;
+    const sameTarget = previous ? fingerprint(previous.target) === fingerprint(grant.target) : !command || grant.target.sessionId === command.sessionId && (grant.target.bindingRevision === void 0 || grant.target.bindingRevision === command.bindingRevision);
+    if (!sameTarget) throw new OrchestrationError(409, "That authorization is for a different target");
+  }
+  /** Holds a scheduled occurrence for review, such as one a missed-run policy will not start by itself. */
+  holdOccurrence(scope, id, hold, reason) {
+    return this.transaction(() => {
+      const occurrence = this.occurrence(scope, id);
+      if (!occurrence) throw new OrchestrationError(404, "Run not found");
+      if (occurrence.state !== "scheduled") throw new OrchestrationError(409, "Only a waiting run can be held");
+      this.writeOccurrence(occurrence, { hold, reason }, "held");
+      return this.occurrence(scope, id);
+    });
+  }
+  /** Marks a scheduled occurrence skipped, such as a missed slot or an overlapping run. */
+  skipOccurrence(scope, id, reason) {
+    return this.transaction(() => {
+      const occurrence = this.occurrence(scope, id);
+      if (!occurrence) throw new OrchestrationError(404, "Run not found");
+      if (occurrence.state !== "scheduled") throw new OrchestrationError(409, "Only a waiting run can be skipped");
+      this.writeOccurrence(occurrence, { reason }, "skipped");
+      return this.occurrence(scope, id);
+    });
+  }
+  /** The user's answer to an occurrence whose session creation outcome is unknown. */
+  resolveOccurrence(scope, id, disposition, sessionId) {
+    return this.transaction(() => {
+      const occurrence = this.occurrence(scope, id);
+      if (!occurrence || occurrence.state !== "unknown") throw new OrchestrationError(409, "Run is not awaiting reconciliation");
+      this.writeOccurrence(occurrence, { reason: disposition === "failed" ? "Marked as not started" : "Marked as started", ...sessionId ? { sessionId } : {} }, disposition);
+      return this.occurrence(scope, id);
+    });
+  }
 };
 
 // ../../server/orchestration/storage.ts
@@ -7034,6 +7756,68 @@ function allStores() {
   return [...registry.allStores(), ...instanceStores()];
 }
 
+// ../../shared/session/codex-results.ts
+var OUTPUT_ITEMS = /* @__PURE__ */ new Set(["function_call_output", "custom_tool_call_output"]);
+var EXEC_OUTPUT_KEYS = ["aggregated_output", "formatted_output", "stdout", "stderr"];
+function semantics(output) {
+  const parsed = parseCustomToolOutput(output);
+  return JSON.stringify([parsed.isError, parsed.images?.length ?? 0]);
+}
+function visitImage(block, visit) {
+  const source = isPlainObject(block.source) ? { ...block.source } : null;
+  if (source) return visitField(source, "data", visit, "image") ? { ...block, source } : block;
+  if (typeof block.image_url !== "string") return block;
+  const match = /^(data:image\/[^;,]+;base64,)(.+)$/is.exec(block.image_url);
+  if (!match) return block;
+  const next = visit(match[2], "image");
+  return next === match[2] ? block : { ...block, image_url: match[1] + next };
+}
+function projectBlocks(blocks, visit) {
+  const joined = visitJoinedText(blocks, (block) => isPlainObject(block) && typeof block.text === "string" ? block.text : void 0, "", (block, text2) => ({ ...block, text: text2 }), visit) ?? blocks;
+  let changed = joined !== blocks;
+  const next = joined.map((block) => {
+    if (!isPlainObject(block) || typeof block.text === "string") return block;
+    const projected = visitImage(block, visit);
+    if (projected !== block) changed = true;
+    return projected;
+  });
+  return changed ? next : blocks;
+}
+function projectValue(output, visit) {
+  if (Array.isArray(output)) return projectBlocks(output, visit);
+  if (typeof output !== "string") return output;
+  let envelope = null;
+  try {
+    envelope = JSON.parse(output);
+  } catch {
+  }
+  if (isPlainObject(envelope) && ("output" in envelope || "content" in envelope)) {
+    const key = envelope.output !== void 0 && envelope.output !== null ? "output" : "content";
+    const inner = envelope[key];
+    const projected = typeof inner === "string" ? visit(inner, "text") : Array.isArray(inner) ? projectValue(inner, visit) : inner;
+    return projected === inner ? output : JSON.stringify({ ...envelope, [key]: projected });
+  }
+  return visit(output, "text");
+}
+function projectOutput(payload, visit) {
+  const output = payload.output;
+  const next = projectValue(output, visit);
+  if (next === output || semantics(next) !== semantics(output)) return false;
+  payload.output = next;
+  return true;
+}
+function projectCodexResults(record3, visit) {
+  const payload = isPlainObject(record3.payload) ? record3.payload : null;
+  if (!payload) return false;
+  if (record3.type === "response_item" && OUTPUT_ITEMS.has(String(payload.type))) return projectOutput(payload, visit);
+  if (record3.type === "event_msg" && payload.type === "exec_command_end") {
+    let changed = false;
+    for (const key of EXEC_OUTPUT_KEYS) changed = visitField(payload, key, visit) || changed;
+    return changed;
+  }
+  return false;
+}
+
 // ../../shared/session/agents.ts
 var TERMINAL_AGENT_KIND = AGENT_KINDS[AGENT_KINDS.length - 1];
 var hasNoNoiseLines = () => false;
@@ -7049,7 +7833,8 @@ var codexFormat = {
   isNoiseLine: hasNoNoiseLines,
   pageHeaderLine: codexPageHeaderLine,
   brandBranch: brandCodexBranch,
-  turnBoundaries: codexTurnBoundaries
+  turnBoundaries: codexTurnBoundaries,
+  projectResults: projectCodexResults
 };
 var copilotFormat = {
   kind: "copilot",
@@ -7062,7 +7847,8 @@ var copilotFormat = {
   status: deriveCopilotSessionStatus,
   isNoiseLine: hasNoNoiseLines,
   brandBranch: brandCopilotBranch,
-  turnBoundaries: copilotTurnBoundaries
+  turnBoundaries: copilotTurnBoundaries,
+  projectResults: projectCopilotResults
 };
 var claudeFormat = {
   kind: "claude",
@@ -7076,7 +7862,8 @@ var claudeFormat = {
   status: deriveClaudeSessionStatus,
   isNoiseLine: isClaudeNoiseLine,
   brandBranch: brandClaudeBranch,
-  turnBoundaries: claudeTurnBoundaries
+  turnBoundaries: claudeTurnBoundaries,
+  projectResults: projectClaudeResults
 };
 var FORMATS = Object.freeze({
   acp: {
@@ -7611,7 +8398,7 @@ function extractVersion(output) {
 var DEFAULT_PROBE_TIMEOUT_MS = 5e3;
 var CLI_OUTPUT_MAX_CHARS = 1e4;
 function runCli(executable, args, timeoutMs) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const resolved = resolveAgentCommand(executable, [...args]);
     const child2 = spawn3(resolved.command, resolved.args, {
       stdio: ["ignore", "pipe", "pipe"],
@@ -7633,11 +8420,11 @@ function runCli(executable, args, timeoutMs) {
     });
     child2.on("error", () => {
       clearTimeout(timer);
-      resolve9({ code: null, stdout, stderr, timedOut });
+      resolve10({ code: null, stdout, stderr, timedOut });
     });
     child2.on("close", (code) => {
       clearTimeout(timer);
-      resolve9({ code, stdout, stderr, timedOut });
+      resolve10({ code, stdout, stderr, timedOut });
     });
   });
 }
@@ -7848,12 +8635,12 @@ function effortLabel(effort) {
 
 // ../../server/agents/timeout.ts
 function withTimeout(promise, ms, label) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
     promise.then(
       (value) => {
         clearTimeout(timer);
-        resolve9(value);
+        resolve10(value);
       },
       (error2) => {
         clearTimeout(timer);
@@ -8774,8 +9561,8 @@ var resultObservers = /* @__PURE__ */ new WeakMap();
 function observeSDKResult(state) {
   let observer;
   const turn = (inputTurns.get(state)?.sent.length ?? Number(state.running)) + 1;
-  const completion = new Promise((resolve9) => {
-    observer = { turn, resolve: resolve9 };
+  const completion = new Promise((resolve10) => {
+    observer = { turn, resolve: resolve10 };
   });
   const observers = resultObservers.get(state) ?? /* @__PURE__ */ new Set();
   observers.add(observer);
@@ -8810,16 +9597,16 @@ function makeCanUseTool(state) {
   return (toolName, input, options) => {
     if (toolName === "AskUserQuestion") {
       const toolUseId = options.toolUseID;
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         const pending = {
           input,
           askedAt: Date.now(),
-          resolve: resolve9
+          resolve: resolve10
         };
         state.pendingUserQuestions.set(toolUseId, pending);
         const onAbort = () => {
           if (state.pendingUserQuestions.delete(toolUseId)) {
-            resolve9({ behavior: "deny", message: "Session aborted", interrupt: true });
+            resolve10({ behavior: "deny", message: "Session aborted", interrupt: true });
           }
         };
         options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -8833,7 +9620,7 @@ function makeCanUseTool(state) {
       return Promise.resolve({ behavior: "allow", updatedInput: input });
     }
     const requestId = options.toolUseID;
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const pending = {
         requestId,
         toolName,
@@ -8848,12 +9635,12 @@ function makeCanUseTool(state) {
         defaultToNo: options.defaultToNo,
         suppressAlwaysAllowRule: options.suppressAlwaysAllowRule,
         timestamp: Date.now(),
-        resolve: resolve9
+        resolve: resolve10
       };
       state.pendingPermissions.set(requestId, pending);
       const onAbort = () => {
         if (state.pendingPermissions.delete(requestId)) {
-          resolve9({ behavior: "deny", message: "Session aborted", interrupt: true });
+          resolve10({ behavior: "deny", message: "Session aborted", interrupt: true });
         }
       };
       options.signal?.addEventListener("abort", onAbort, { once: true });
@@ -8870,16 +9657,16 @@ function makeOnElicitation(state) {
       );
       return Promise.resolve({ action: "decline" });
     }
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const requestId = options.requestId;
       state.pendingElicitations.set(requestId, {
         request,
         fields: projection.fields,
         askedAt: Date.now(),
-        resolve: resolve9
+        resolve: resolve10
       });
       const onAbort = () => {
-        if (state.pendingElicitations.delete(requestId)) resolve9({ action: "decline" });
+        if (state.pendingElicitations.delete(requestId)) resolve10({ action: "decline" });
       };
       options.signal?.addEventListener("abort", onAbort, { once: true });
     });
@@ -8908,14 +9695,14 @@ function makeOnUserDialog(state) {
     if (!(request.dialogKind in DIALOG_CHOICES)) return Promise.resolve(null);
     const projected = projectUserDialog(request);
     if (!projected) return Promise.resolve({ behavior: "cancelled" });
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const requestId = options.requestId;
       state.pendingUserDialogs.set(requestId, {
         dialog: { ...projected, requestId, askedAt: Date.now() },
-        resolve: resolve9
+        resolve: resolve10
       });
       const onAbort = () => {
-        if (state.pendingUserDialogs.delete(requestId)) resolve9({ behavior: "cancelled" });
+        if (state.pendingUserDialogs.delete(requestId)) resolve10({ behavior: "cancelled" });
       };
       options.signal?.addEventListener("abort", onAbort, { once: true });
     });
@@ -9115,8 +9902,8 @@ var SDKMessageStream = class {
   closed = false;
   enqueue(message) {
     if (this.closed) return false;
-    const resolve9 = this.waiting.shift();
-    if (resolve9) resolve9({ value: message, done: false });
+    const resolve10 = this.waiting.shift();
+    if (resolve10) resolve10({ value: message, done: false });
     else this.queued.push(message);
     return true;
   }
@@ -9124,15 +9911,15 @@ var SDKMessageStream = class {
     if (this.closed) return;
     this.closed = true;
     this.queued.length = 0;
-    for (const resolve9 of this.waiting.splice(0)) {
-      resolve9({ value: void 0, done: true });
+    for (const resolve10 of this.waiting.splice(0)) {
+      resolve10({ value: void 0, done: true });
     }
   }
   next() {
     const message = this.queued.shift();
     if (message) return Promise.resolve({ value: message, done: false });
     if (this.closed) return Promise.resolve({ value: void 0, done: true });
-    return new Promise((resolve9) => this.waiting.push(resolve9));
+    return new Promise((resolve10) => this.waiting.push(resolve10));
   }
   return() {
     this.close();
@@ -9181,7 +9968,28 @@ function runQuery(state, prompt, opts, pluginInstructions, preparation) {
   const messageStream = new SDKMessageStream();
   const first = buildUserMessage(prompt, opts.images);
   inputTurns.set(state, { sent: [first.uuid], completed: 0, taken: null });
-  messageStream.enqueue(first);
+  if (opts.beforeFirstTurn) {
+    let readiness2;
+    queryOpts.hooks = {
+      ...queryOpts.hooks,
+      SessionStart: [{ timeout: 86400, hooks: [async (input) => {
+        try {
+          await (readiness2 ??= (async () => {
+            state.cwd = input.cwd;
+            await opts.beforeFirstTurn({ sessionId: state.sessionId, cwd: input.cwd });
+            state.abort?.signal.throwIfAborted();
+            messageStream.enqueue(first);
+          })());
+          return {};
+        } catch (error2) {
+          opts.onStartupError?.(error2);
+          messageStream.close();
+          state.abort?.abort();
+          return { continue: false, decision: "block", reason: "Worktree startup did not complete" };
+        }
+      }] }]
+    };
+  } else messageStream.enqueue(first);
   state.messageStream = messageStream;
   const q = query2({ prompt: messageStream, options: queryOpts });
   state.activeQuery = q;
@@ -9310,6 +10118,8 @@ function createSDKSession(opts) {
   runQuery(state, opts.message, {
     name: opts.name,
     worktreeName: opts.worktreeName,
+    beforeFirstTurn: opts.beforeFirstTurn,
+    onStartupError: opts.onStartupError,
     mcpConfig: opts.mcpConfig,
     images: opts.images
   });
@@ -9693,8 +10503,13 @@ function sdkResumeOptions(req) {
   };
 }
 function startInteractive(req) {
+  req.signal?.throwIfAborted();
   const sessionId = randomUUID3();
   reportSessionId(req, sessionId);
+  let readinessComplete = !req.beforeFirstTurn;
+  let initialized = false;
+  let succeeded;
+  let startupError;
   const state = createSDKSession({
     sessionId,
     // An images-only send has no prompt; the SDK substitutes its own
@@ -9705,13 +10520,20 @@ function startInteractive(req) {
     ...sdkResumeOptions(req),
     ultracode: !!req.ultracode,
     name: req.name,
-    worktreeName: req.worktreeName
+    worktreeName: req.worktreeName,
+    beforeFirstTurn: req.beforeFirstTurn ? async (identity) => {
+      await beforeFirstTurn(req, { ...identity, nativeWorktree: !!req.worktreeName });
+      readinessComplete = true;
+      if (initialized) succeeded?.();
+    } : void 0,
+    onStartupError: (error2) => startupError?.(error2)
   });
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let settled = false;
     const succeed = async () => {
-      if (settled) return;
+      if (settled || !readinessComplete) return;
       settled = true;
+      req.signal?.removeEventListener("abort", abort);
       state.onInit = null;
       state.onResult = null;
       const dirName = descriptor2.dirName.encode(state.cwd);
@@ -9722,18 +10544,39 @@ function startInteractive(req) {
         initialContent = await readFile6(filePath, "utf-8");
       } catch {
       }
-      resolve9({ sessionId, dirName, cwd: state.cwd, fileName, filePath, initialContent });
+      resolve10({ sessionId, dirName, cwd: state.cwd, fileName, filePath, initialContent });
     };
     const fail = (message) => {
       if (settled) return;
       settled = true;
+      req.signal?.removeEventListener("abort", abort);
       state.onInit = null;
       state.onResult = null;
+      stopSDKSession(sessionId);
       reject(new AgentRuntimeError(500, "SPAWN_FAILED", message));
     };
+    const abort = () => {
+      stopSDKSession(sessionId);
+      startupError?.(req.signal?.reason ?? new Error("Session startup cancelled"));
+    };
+    startupError = (error2) => {
+      if (settled) return;
+      settled = true;
+      req.signal?.removeEventListener("abort", abort);
+      state.onInit = null;
+      state.onResult = null;
+      stopSDKSession(sessionId);
+      reject(error2);
+    };
+    succeeded = () => {
+      void succeed();
+    };
     state.onInit = () => {
+      initialized = true;
       void succeed();
     };
+    req.signal?.addEventListener("abort", abort, { once: true });
+    if (req.signal?.aborted) abort();
     state.onResult = (result) => {
       state.onResult = null;
       const outcome = turnResultFrom(result);
@@ -9790,6 +10633,7 @@ var claudeRuntime = {
     return startInteractive(req);
   },
   async send(sessionId, req) {
+    if (isSessionStarting(sessionId)) return { delivery: "busy" };
     const live = sdkSessions.get(sessionId);
     if (live?.pluginSkillLoading) return { delivery: "busy" };
     if (req.onlyWhileRunning && (!isSDKQueryLive(live) || !live.running)) return { delivery: "busy" };
@@ -9822,10 +10666,10 @@ var claudeRuntime = {
       ...sdkResumeOptions(req)
     });
     watchSubagentsFor(state, req.filePath ?? null);
-    const completion = new Promise((resolve9) => {
+    const completion = new Promise((resolve10) => {
       state.onResult = (result) => {
         state.onResult = null;
-        resolve9(turnResultFrom(result));
+        resolve10(turnResultFrom(result));
       };
     });
     return { delivery: "started", completion };
@@ -9901,6 +10745,112 @@ var claudeRuntime = {
   }
 };
 
+// ../../server/lib/managedCommand.ts
+import { spawn as spawn4, execFile } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+async function runManagedCommand(options) {
+  options.signal.throwIfAborted();
+  const windows = process.platform === "win32";
+  const child2 = spawn4(options.file, options.args, {
+    cwd: options.cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: !windows,
+    windowsHide: true,
+    env: { ...process.env, CI: "1", GIT_TERMINAL_PROMPT: "0", ...options.env }
+  });
+  const killTree = () => {
+    if (!child2.pid) return;
+    if (windows) {
+      execFile("taskkill", ["/pid", String(child2.pid), "/T", "/F"], { windowsHide: true }, () => {
+      });
+    } else {
+      try {
+        process.kill(-child2.pid, "SIGKILL");
+      } catch {
+      }
+    }
+  };
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    killTree();
+  }, options.timeoutMs);
+  const abort = () => killTree();
+  options.signal.addEventListener("abort", abort, { once: true });
+  if (options.signal.aborted) killTree();
+  const stdout = new StringDecoder("utf8");
+  const stderr = new StringDecoder("utf8");
+  child2.stdout.on("data", (chunk) => options.output(stdout.write(chunk)));
+  child2.stderr.on("data", (chunk) => options.output(stderr.write(chunk)));
+  try {
+    const code = await new Promise((resolve10, reject) => {
+      child2.once("error", reject);
+      child2.once("close", resolve10);
+    });
+    options.output(stdout.end() + stderr.end());
+    options.signal.throwIfAborted();
+    if (timedOut) throw new Error("Command timed out");
+    return code;
+  } finally {
+    clearTimeout(timer);
+    options.signal.removeEventListener("abort", abort);
+    killTree();
+  }
+}
+
+// ../../server/agents/managedWorktree.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { mkdir as mkdir3 } from "node:fs/promises";
+import { join as join16 } from "node:path";
+
+// ../../server/worktreeSetup/project.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { realpath as realpath4, stat as stat9 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, resolve as resolve8 } from "node:path";
+var execute = promisify2(execFile2);
+async function gitOutput(cwd, args, signal) {
+  const result = await execute("git", args, { cwd, signal, encoding: "utf8", timeout: 15e3, maxBuffer: 1024 * 1024, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
+  return result.stdout.trim();
+}
+async function physicalDirectory(cwd) {
+  if (!isAbsolute2(cwd) || cwd.includes("\0")) throw new RouteError(400, ErrorCodes.INVALID_REQUEST, "An absolute project directory is required");
+  const path = await realpath4(cwd);
+  if (!(await stat9(path)).isDirectory()) throw new RouteError(400, ErrorCodes.INVALID_REQUEST, "Project directory does not exist");
+  return path;
+}
+async function projectIdentity(cwd) {
+  const path = await physicalDirectory(cwd);
+  const common = await gitOutput(path, ["rev-parse", "--git-common-dir"]);
+  return realpath4(resolve8(path, common));
+}
+async function validateInitializedDirectory(projectCwd, cwd) {
+  const path = await physicalDirectory(cwd);
+  if (await projectIdentity(projectCwd) !== await projectIdentity(path)) {
+    throw new RouteError(403, ErrorCodes.FORBIDDEN, "Initialized worktree belongs to a different project");
+  }
+  return path;
+}
+
+// ../../server/agents/managedWorktree.ts
+async function prepareManagedWorktree(request) {
+  if (!request.worktreeName || !request.beforeFirstTurn) return request;
+  if (!/^[a-zA-Z0-9._-]{1,80}$/.test(request.worktreeName) || request.worktreeName === "." || request.worktreeName === "..") throw new AgentRuntimeError(400, "INVALID_REQUEST", "Invalid worktree name");
+  request.signal?.throwIfAborted();
+  const suffix = randomUUID6().slice(0, 8);
+  const name = `${request.worktreeName.slice(0, 28)}-${suffix}`;
+  const parent = join16(request.cwd, ".worktrees");
+  await mkdir3(parent, { recursive: true });
+  const cwd = join16(parent, name);
+  let output = "";
+  const code = await runManagedCommand({ cwd: request.cwd, file: "git", args: ["worktree", "add", "-b", `worktree-${name}`, cwd, "HEAD"], signal: request.signal ?? new AbortController().signal, timeoutMs: 12e4, output: (text2) => {
+    output = (output + text2).slice(-8e3);
+  } });
+  if (code !== 0) throw new AgentRuntimeError(500, "SPAWN_FAILED", output.trim() || "Could not initialize the managed worktree");
+  await validateInitializedDirectory(request.cwd, cwd);
+  return { ...request, worktreeName: void 0, cwd, dirName: descriptorFor("codex").dirName.encode(cwd) };
+}
+
 // ../../shared/session/contextWindowSettings.ts
 function isValidContextWindowTokens(value) {
   return value === void 0 || value === null || typeof value === "number" && Number.isSafeInteger(value) && value > 0;
@@ -15945,7 +16895,7 @@ import { createInterface as createInterface2 } from "node:readline";
 var package_default = {
   name: "cogpit",
   private: true,
-  version: "3.5.1",
+  version: "3.5.2",
   description: "Control center for Claude Code, OpenAI Codex, and GitHub Copilot CLI sessions",
   license: "MIT",
   author: {
@@ -16849,9 +17799,9 @@ var CodexAppServer = class {
     const completed = this.completedTurns.get(key);
     if (completed) return Promise.resolve(completed);
     if (!this.child) return Promise.reject(new CodexAppServerError("Codex disconnected before completion"));
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const waiting = this.completionWaiters.get(key) ?? [];
-      waiting.push({ resolve: resolve9, reject });
+      waiting.push({ resolve: resolve10, reject });
       this.completionWaiters.set(key, waiting);
     });
   }
@@ -17168,7 +18118,7 @@ var CodexAppServer = class {
       );
     }
     const id = this.nextRequestId++;
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const timer = timeoutMs > 0 ? this.setTimer(() => {
         const pending = this.pendingRequests.get(id);
         if (!pending) return;
@@ -17181,7 +18131,7 @@ var CodexAppServer = class {
       }, timeoutMs) : null;
       this.pendingRequests.set(id, {
         method,
-        resolve: (result) => resolve9(result),
+        resolve: (result) => resolve10(result),
         reject,
         timer
       });
@@ -17207,12 +18157,12 @@ var CodexAppServer = class {
         new CodexAppServerError("Codex app-server stdin is not writable")
       );
     }
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       try {
         child2.stdin.write(`${JSON.stringify(message)}
 `, (error2) => {
           if (error2) reject(error2);
-          else resolve9();
+          else resolve10();
         });
       } catch (error2) {
         reject(error2);
@@ -17259,13 +18209,13 @@ var CodexAppServer = class {
     }
   }
   waitForChildClose(closed, timeoutMs) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       let settled = false;
       const finish = (didClose) => {
         if (settled) return;
         settled = true;
         this.clearTimer(timer);
-        resolve9(didClose);
+        resolve10(didClose);
       };
       const timer = this.setTimer(() => finish(false), timeoutMs);
       void closed.then(() => finish(true));
@@ -17274,8 +18224,8 @@ var CodexAppServer = class {
   async terminateChild(child2, error2) {
     let didClose = false;
     let resolveClose = () => void 0;
-    const closed = new Promise((resolve9) => {
-      resolveClose = resolve9;
+    const closed = new Promise((resolve10) => {
+      resolveClose = resolve10;
     });
     child2.on("close", () => {
       didClose = true;
@@ -17395,7 +18345,7 @@ function friendlySpawnError(err, kind2 = "claude") {
 // ../../server/agents/tempImages.ts
 import { writeFile as writeFile3, unlink as unlink3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 var IMAGE_EXT = {
   "image/jpeg": "jpg",
   "image/gif": "gif",
@@ -17406,7 +18356,7 @@ async function writeTempImageFiles(images) {
   const files = [];
   for (const [index, image] of images.entries()) {
     const ext = IMAGE_EXT[image.mediaType] ?? "png";
-    const filePath = join16(tmpdir(), `cogpit-codex-image-${Date.now()}-${index}.${ext}`);
+    const filePath = join17(tmpdir(), `cogpit-codex-image-${Date.now()}-${index}.${ext}`);
     await writeFile3(filePath, Buffer.from(image.data, "base64"));
     files.push(filePath);
   }
@@ -17422,7 +18372,7 @@ async function cleanupTempFiles(paths) {
 }
 
 // ../../server/agents/codexExecution.ts
-import { isAbsolute as isAbsolute2, relative as relative4, resolve as resolve8, sep as sep5 } from "node:path";
+import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve9, sep as sep5 } from "node:path";
 
 // ../../server/agents/codexBrowser.ts
 async function codexBrowserConfig(client2, cwd, sessionId = NO_COGPIT_SESSION) {
@@ -17565,6 +18515,7 @@ async function startCodexExecution(client2, options, onThreadStarted) {
   const input = buildCodexUserInput(options.message, options.images);
   const response = await client2.startThread(await threadSettings(client2, options));
   onThreadStarted?.(response.thread.id);
+  await options.beforeFirstTurn?.({ sessionId: response.thread.id, cwd: typeof response.thread.cwd === "string" ? response.thread.cwd : options.cwd });
   const turn = await client2.startTurn({
     threadId: response.thread.id,
     input,
@@ -17614,11 +18565,11 @@ async function continueCodexExecution(client2, threadId, options) {
 }
 function getCodexThreadIdentity(thread, sessionsDir = storeFor("codex").sessionsRoot() ?? "") {
   const threadPath = typeof thread.path === "string" ? thread.path : "";
-  if (!thread.id || !threadPath || !isAbsolute2(threadPath)) return null;
-  const root = resolve8(sessionsDir);
-  const filePath = resolve8(threadPath);
+  if (!thread.id || !threadPath || !isAbsolute3(threadPath)) return null;
+  const root = resolve9(sessionsDir);
+  const filePath = resolve9(threadPath);
   const fileName = uncompressedTranscriptName(relative4(root, filePath));
-  if (!fileName || fileName === ".." || fileName.startsWith(`..${sep5}`) || isAbsolute2(fileName) || !fileName.endsWith(".jsonl")) {
+  if (!fileName || fileName === ".." || fileName.startsWith(`..${sep5}`) || isAbsolute3(fileName) || !fileName.endsWith(".jsonl")) {
     return null;
   }
   return {
@@ -17696,7 +18647,7 @@ async function waitForRollout(announcedId, scan, shouldStop) {
         if (Date.now() - eliminatedAt >= ANNOUNCEMENT_GRACE_MS) return match;
       }
     }
-    await new Promise((resolve9) => setTimeout(resolve9, SESSION_DISCOVERY_INTERVAL_MS));
+    await new Promise((resolve10) => setTimeout(resolve10, SESSION_DISCOVERY_INTERVAL_MS));
   }
   return null;
 }
@@ -17747,6 +18698,7 @@ async function resolveStartedIdentity(thread) {
   throw new Error(`Codex created thread ${thread.id} but did not provide a rollout path`);
 }
 async function startLegacy(req, knownPaths) {
+  await beforeFirstTurn(req, { cwd: req.cwd });
   const imagePaths = await writeTempImageFiles(req.images);
   const args = legacyArgs(req, imagePaths);
   const startedAt2 = Date.now();
@@ -17773,7 +18725,7 @@ async function startLegacy(req, knownPaths) {
   child2.stderr?.on("data", (data) => {
     stderr += data.toString();
   });
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let settled = false;
     let sessionId = null;
     let announcedId = null;
@@ -17803,9 +18755,14 @@ async function startLegacy(req, knownPaths) {
         }
       }
       const worktreeIdentity = req.worktreeName ? await storeFor("codex").readIdentity(identity.filePath).catch(() => null) : null;
-      resolve9({
+      if (req.worktreeName && !worktreeIdentity?.cwd) {
+        reject(new AgentRuntimeError(409, "SESSION_UNCONFIRMED", "The native worktree directory is not available yet. Inspect the retained session before retrying."));
+        return;
+      }
+      resolve10({
         sessionId: identity.sessionId,
         dirName: worktreeIdentity?.cwd ? descriptor3.dirName.encode(worktreeIdentity.cwd) : req.dirName,
+        cwd: worktreeIdentity?.cwd ?? req.cwd,
         fileName: identity.fileName,
         filePath: identity.filePath,
         initialContent: content
@@ -17887,10 +18844,10 @@ async function sendLegacy(sessionId, req) {
   child2.stderr?.on("data", (data) => {
     stderr += data.toString();
   });
-  const completion = new Promise((resolve9) => {
+  const completion = new Promise((resolve10) => {
     session.onResult = (result) => {
       session.onResult = null;
-      resolve9({
+      resolve10({
         isError: result.is_error === true,
         message: result.result
       });
@@ -18124,6 +19081,8 @@ var codexRuntime = {
   kind: "codex",
   descriptor: descriptor3,
   async start(req) {
+    req.signal?.throwIfAborted();
+    req = await prepareManagedWorktree(req);
     validateContextWindow(req.contextWindowTokens);
     const knownPaths = new Set(
       (await storeFor("codex").listSessionFiles()).map((file) => file.filePath)
@@ -18131,7 +19090,7 @@ var codexRuntime = {
     if (req.worktreeName) return startLegacy(req, knownPaths);
     let threadStarted = false;
     try {
-      const options = executionOptions(req);
+      const options = { ...executionOptions(req), beforeFirstTurn: (identity2) => beforeFirstTurn(req, identity2) };
       const started = await startCodexExecution(codexAppServer, options, (threadId) => {
         threadStarted = true;
         reportSessionId(req, threadId);
@@ -18143,14 +19102,17 @@ var codexRuntime = {
         initialContent = await readFile6(identity.filePath, "utf-8");
       } catch {
       }
+      const initializedCwd = typeof started.thread.cwd === "string" ? started.thread.cwd : req.cwd;
       return {
         sessionId: identity.sessionId,
-        dirName: req.dirName,
+        dirName: descriptor3.dirName.encode(initializedCwd),
+        cwd: initializedCwd,
         fileName: identity.fileName,
         filePath: identity.filePath,
         initialContent
       };
     } catch (error2) {
+      if (isStartupFailure(error2)) throw error2;
       if (threadStarted || !isCodexAppServerUnavailable(error2)) {
         throw new AgentRuntimeError(
           500,
@@ -18162,6 +19124,7 @@ var codexRuntime = {
     return startLegacy(req, knownPaths);
   },
   async send(sessionId, req) {
+    if (isSessionStarting(sessionId)) return { delivery: "busy" };
     validateContextWindow(req.contextWindowTokens);
     const legacy = persistentSessions.get(sessionId);
     if (legacy && !legacy.dead) {
@@ -18321,7 +19284,7 @@ var codexRuntime = {
 
 // ../../server/agents/copilotTransport.ts
 import { spawn as spawnChild2 } from "node:child_process";
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import {
   CancellationTokenSource,
   createMessageConnection,
@@ -18453,8 +19416,8 @@ var CopilotRuntime = class {
   }
   observeTurn(sessionId) {
     let observer;
-    const completion = new Promise((resolve9, reject) => {
-      observer = { resolve: resolve9, reject };
+    const completion = new Promise((resolve10, reject) => {
+      observer = { resolve: resolve10, reject };
     });
     const observers = this.turnObservers.get(sessionId) ?? /* @__PURE__ */ new Set();
     observers.add(observer);
@@ -18584,7 +19547,7 @@ var CopilotRuntime = class {
   }
   async createSession(options = {}) {
     options = await withPluginSkills(options);
-    const sessionId = options.sessionId ?? randomUUID6();
+    const sessionId = options.sessionId ?? randomUUID7();
     this.assertSessionAvailable(sessionId);
     this.openingSessions.add(sessionId);
     try {
@@ -19021,7 +19984,7 @@ var CopilotRuntime = class {
   }
   waitForRequest(request, method, timeoutMs = this.transportTimeoutMs, onTimeout) {
     if (timeoutMs <= 0) return request;
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const timer = setTimeout(() => {
         try {
           onTimeout?.();
@@ -19032,7 +19995,7 @@ var CopilotRuntime = class {
       request.then(
         (value) => {
           clearTimeout(timer);
-          resolve9(value);
+          resolve10(value);
         },
         (error2) => {
           clearTimeout(timer);
@@ -19149,7 +20112,7 @@ var CopilotRuntime = class {
       throw new CopilotRuntimeError(`Copilot session ${params.sessionId} is not active`);
     }
     const sessionId = params.sessionId;
-    const requestId = typeof params.requestId === "string" ? params.requestId : randomUUID6();
+    const requestId = typeof params.requestId === "string" ? params.requestId : randomUUID7();
     const choices = Array.isArray(params.choices) ? params.choices.filter((choice) => typeof choice === "string") : void 0;
     const value = {
       sessionId,
@@ -19159,10 +20122,10 @@ var CopilotRuntime = class {
       ...typeof params.allowFreeform === "boolean" ? { allowFreeform: params.allowFreeform } : {},
       askedAt: Date.now()
     };
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       this.pendingUserInputs.set(
         this.pendingInteractionKey(sessionId, requestId),
-        { value, resolve: resolve9, reject }
+        { value, resolve: resolve10, reject }
       );
     });
   }
@@ -19171,7 +20134,7 @@ var CopilotRuntime = class {
       throw new CopilotRuntimeError("Invalid Copilot exit-plan request");
     }
     const sessionId = params.sessionId;
-    const requestId = randomUUID6();
+    const requestId = randomUUID7();
     const actions = Array.isArray(params.actions) ? params.actions.filter((action) => typeof action === "string") : [];
     const value = {
       sessionId,
@@ -19182,10 +20145,10 @@ var CopilotRuntime = class {
       recommendedAction: typeof params.recommendedAction === "string" ? params.recommendedAction : actions[0] ?? "interactive",
       askedAt: Date.now()
     };
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       this.pendingExitPlans.set(
         this.pendingInteractionKey(sessionId, requestId),
-        { value, resolve: resolve9, reject }
+        { value, resolve: resolve10, reject }
       );
     });
   }
@@ -19470,8 +20433,8 @@ function rolloutNamedThroughMs(filePath) {
 var FORK_COPY_MAX_GAP_MS = 1e3;
 function isForkedSessionMeta(payload) {
   if (typeof payload.forked_from_id === "string") return true;
-  const spawn4 = asRecord(asRecord(asRecord(payload.source)?.subagent)?.thread_spawn);
-  return typeof spawn4?.parent_thread_id === "string";
+  const spawn5 = asRecord(asRecord(asRecord(payload.source)?.subagent)?.thread_spawn);
+  return typeof spawn5?.parent_thread_id === "string";
 }
 function parseCodexUsageLine(line, state) {
   const record3 = parseJsonRecord(line);
@@ -19846,6 +20809,7 @@ var copilotRuntime2 = {
   kind: "copilot",
   descriptor: descriptor4,
   async start(req) {
+    req.signal?.throwIfAborted();
     const sessionId = randomUUID3();
     reportSessionId(req, sessionId);
     let opened = false;
@@ -19862,6 +20826,7 @@ var copilotRuntime2 = {
       if (req.permissions?.mode) {
         await copilotRuntime.setPermissionMode(sessionId, allowAll(req.permissions.mode));
       }
+      await beforeFirstTurn(req, { sessionId, cwd: req.cwd });
       const attachments = buildAttachments(req.images);
       await copilotRuntime.send(sessionId, {
         prompt: req.message || IMAGE_ONLY_PROMPT,
@@ -19875,10 +20840,10 @@ var copilotRuntime2 = {
           initialContent = await readFile6(filePath, "utf-8");
           break;
         } catch {
-          await new Promise((resolve9) => setTimeout(resolve9, TRANSCRIPT_POLL_INTERVAL_MS));
+          await new Promise((resolve10) => setTimeout(resolve10, TRANSCRIPT_POLL_INTERVAL_MS));
         }
       }
-      return { sessionId, dirName: req.dirName, fileName, filePath, initialContent };
+      return { sessionId, dirName: req.dirName, cwd: req.cwd, fileName, filePath, initialContent };
     } catch (error2) {
       if (opened) {
         if (copilotRuntime.isSessionActive(sessionId)) {
@@ -19888,6 +20853,7 @@ var copilotRuntime2 = {
         await copilotRuntime.deleteSession(sessionId).catch(() => {
         });
       }
+      if (isStartupFailure(error2)) throw error2;
       throw new AgentRuntimeError(
         500,
         "SPAWN_FAILED",
@@ -19896,6 +20862,7 @@ var copilotRuntime2 = {
     }
   },
   async send(sessionId, req) {
+    if (isSessionStarting(sessionId)) return { delivery: "busy" };
     if (req.onlyWhileRunning && !copilotRuntime.isTurnActive(sessionId)) return { delivery: "busy" };
     if (!copilotRuntime.isSessionActive(sessionId)) {
       await copilotRuntime.resumeSession(sessionId, {
@@ -20115,14 +21082,14 @@ var copilotRuntime2 = {
 // ../../server/agents/instanceRuntime.ts
 import { fork } from "node:child_process";
 import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function providerInstanceEnvironment(instance, dataRoot2) {
   const descriptor5 = descriptorFor(instance.agent);
-  const userRoot = join17(instance.homeDir, "user");
-  for (const directory of [userRoot, join17(userRoot, ".config"), join17(userRoot, ".cache"), join17(userRoot, ".local/share"), join17(userRoot, "tmp")]) mkdirSync4(directory, { recursive: true, mode: 448 });
+  const userRoot = join18(instance.homeDir, "user");
+  for (const directory of [userRoot, join18(userRoot, ".config"), join18(userRoot, ".cache"), join18(userRoot, ".local/share"), join18(userRoot, "tmp")]) mkdirSync4(directory, { recursive: true, mode: 448 });
   const env = Object.fromEntries(["PATH", "SystemRoot", "SYSTEMROOT", "WINDIR", "COMSPEC", "PATHEXT", "LANG", "LC_ALL", "TZ", "COGPIT_PORT"].flatMap((key) => process.env[key] ? [[key, process.env[key]]] : []));
-  Object.assign(env, { HOME: userRoot, USERPROFILE: userRoot, XDG_CONFIG_HOME: join17(userRoot, ".config"), XDG_CACHE_HOME: join17(userRoot, ".cache"), XDG_DATA_HOME: join17(userRoot, ".local/share"), TMPDIR: join17(userRoot, "tmp"), TEMP: join17(userRoot, "tmp"), TMP: join17(userRoot, "tmp"), COGPIT_AGENT_WORKER: "1", COGPIT_AGENT_INSTANCE_ID: instance.id, COGPIT_WORKER_AGENT: instance.agent, COGPIT_WORKER_DATA_ROOT: join17(instance.homeDir, "cogpit"), COGPIT_WORKER_CONFIG_PATH: join17(instance.homeDir, "config.json"), COGPIT_ORCHESTRATION_ROOT: dataRoot2, ELECTRON_RUN_AS_NODE: "1" });
+  Object.assign(env, { HOME: userRoot, USERPROFILE: userRoot, XDG_CONFIG_HOME: join18(userRoot, ".config"), XDG_CACHE_HOME: join18(userRoot, ".cache"), XDG_DATA_HOME: join18(userRoot, ".local/share"), TMPDIR: join18(userRoot, "tmp"), TEMP: join18(userRoot, "tmp"), TMP: join18(userRoot, "tmp"), COGPIT_AGENT_WORKER: "1", COGPIT_AGENT_INSTANCE_ID: instance.id, COGPIT_WORKER_AGENT: instance.agent, COGPIT_WORKER_DATA_ROOT: join18(instance.homeDir, "cogpit"), COGPIT_WORKER_CONFIG_PATH: join18(instance.homeDir, "config.json"), COGPIT_ORCHESTRATION_ROOT: dataRoot2, ELECTRON_RUN_AS_NODE: "1" });
   if (descriptor5.cli.homeEnvVar) env[descriptor5.cli.homeEnvVar] = instance.homeDir;
   if (descriptor5.cli.bundledBySdk) env.CLAUDE_CONFIG_DIR = instance.homeDir;
   env.COGPIT_BROWSER_HOME = browserHome();
@@ -20204,6 +21171,22 @@ function createInstanceRuntime(instance, dataRoot2) {
       }
       if (typeof message.id !== "number") return;
       const id = message.id;
+      if (message.type === "startup-ready" && typeof message.cwd === "string") {
+        const call3 = pending.get(id);
+        const ready2 = call3?.beforeFirstTurn;
+        void Promise.resolve().then(async () => {
+          if (!ready2) throw new Error("Startup authorization is no longer available");
+          await ready2({ cwd: message.cwd, nativeWorktree: message.nativeWorktree === true, sessionId: typeof message.sessionId === "string" ? qualified(message.sessionId) : void 0 });
+        }).then(() => {
+          if (child2 === worker && worker.connected) worker.send({ type: "startup-ready-result", id }, () => {
+          });
+        }, (error2) => {
+          if (call3 && error2 instanceof Error) call3.startupError = error2;
+          if (child2 === worker && worker.connected) worker.send({ type: "startup-ready-result", id, error: error2 instanceof Error ? error2.message : "Startup refused" }, () => {
+          });
+        });
+        return;
+      }
       if (message.type === "identity" && typeof message.sessionId === "string") {
         watched2.add(message.sessionId);
         const sessionId = qualified(message.sessionId);
@@ -20228,26 +21211,42 @@ function createInstanceRuntime(instance, dataRoot2) {
       if (!call2) return;
       pending.delete(id);
       clearTimeout(call2.timer);
-      if (typeof message.error === "string") call2.reject(new AgentRuntimeError(Number(message.status) || 502, typeof message.code === "string" ? message.code : "INSTANCE_ERROR", message.error));
+      if (typeof message.error === "string") call2.reject(call2.startupError ?? new AgentRuntimeError(Number(message.status) || 502, typeof message.code === "string" ? message.code : "INSTANCE_ERROR", message.error));
       else call2.resolve(message.value);
     });
     return worker;
   }
-  async function call(method, args, identity, timeoutMs = 12e4) {
+  async function call(method, args, identity, timeoutMs = 12e4, beforeFirstTurn2, signal) {
+    signal?.throwIfAborted();
     if (pending.size >= 100) throw new AgentRuntimeError(429, "INSTANCE_BUSY", "Provider instance has too many pending operations");
     const worker = processFor();
     const id = ++nextId;
-    const value = await new Promise((resolve9, reject) => {
+    const value = await new Promise((resolve10, reject) => {
       const timer = setTimeout(() => {
+        const call2 = pending.get(id);
         pending.delete(id);
-        reject(new Error("Provider instance operation timed out; inspect session history before retrying"));
+        if (method === "start") abort();
+        call2?.reject(new Error("Provider instance operation timed out; inspect session history before retrying"));
       }, timeoutMs);
-      pending.set(id, { resolve: (value2) => resolve9(value2), reject, timer, identity });
+      const abort = () => {
+        if (worker.connected) worker.send({ type: "startup-abort", id }, () => {
+        });
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+      pending.set(id, { resolve: (value2) => {
+        signal?.removeEventListener("abort", abort);
+        resolve10(value2);
+      }, reject: (error2) => {
+        signal?.removeEventListener("abort", abort);
+        reject(error2);
+      }, timer, identity, beforeFirstTurn: beforeFirstTurn2 });
       worker.send({ id, method, args }, (error2) => {
         if (error2) {
           clearTimeout(timer);
+          const call2 = pending.get(id);
           pending.delete(id);
-          reject(error2);
+          call2?.reject(error2);
         }
       });
     });
@@ -20260,22 +21259,31 @@ function createInstanceRuntime(instance, dataRoot2) {
     descriptor: descriptor5,
     isBusy: () => pending.size > 0 || completions.size > 0 || active.length > 0,
     async start(request) {
-      const { value } = await call("start", [{ ...request, onSessionId: void 0, dirName: splitInstanceDirName(request.dirName).nativeDirName }], (id) => reportSessionId(request, id));
-      return { ...value, sessionId: qualified(value.sessionId), dirName: instanceDirName(instance.id, value.dirName) };
+      let announced;
+      try {
+        const { value } = await call("start", [{ ...request, signal: void 0, beforeFirstTurn: Boolean(request.beforeFirstTurn), onSessionId: void 0, dirName: splitInstanceDirName(request.dirName).nativeDirName }], (id) => {
+          announced = id;
+          reportSessionId(request, id);
+        }, request.beforeFirstTurn ? 24 * 60 * 6e4 : 12e4, request.beforeFirstTurn ? (identity) => beforeFirstTurn(request, identity) : void 0, request.signal);
+        return { ...value, sessionId: qualified(value.sessionId), dirName: instanceDirName(instance.id, value.dirName) };
+      } finally {
+        if (announced) finishSessionStartup(announced);
+      }
     },
     async send(sessionId, request) {
+      if (isSessionStarting(sessionId)) return { delivery: "busy" };
       watched2.add(native(sessionId));
       const { id, value } = await call("send", [native(sessionId), request]);
       if (!value.hasCompletion) return value;
-      const completion = new Promise((resolve9, reject) => {
+      const completion = new Promise((resolve10, reject) => {
         const early = earlyCompletions.get(id);
         if (early) {
           earlyCompletions.delete(id);
           if (early.error) reject(new Error(early.error));
-          else resolve9(early.value);
+          else resolve10(early.value);
           return;
         }
-        completions.set(id, { resolve: resolve9, reject });
+        completions.set(id, { resolve: resolve10, reject });
       });
       return { delivery: value.delivery, turnId: value.turnId, completion };
     },
@@ -20379,6 +21387,8 @@ await loadConfig();
 refreshDirs();
 installBundledSkills([kind]);
 var runtime = runtimeFor(kind);
+var startups = /* @__PURE__ */ new Map();
+var readiness = /* @__PURE__ */ new Map();
 var answers = /* @__PURE__ */ new Map();
 var methods = /* @__PURE__ */ new Set(["start", "send", "interrupt", "stop", "stopAll", "deleteSession", "respondToApproval", "respondToAllApprovals", "respondToPlan", "answerQuestion", "describeRuntime", "listModels", "liveUsageRecords", "fork", "shutdown", "snapshot", "commitAnswer"]);
 function send2(message) {
@@ -20386,18 +21396,18 @@ function send2(message) {
 }
 var skillRequestId = 0;
 var skillRequests = /* @__PURE__ */ new Map();
-var unregisterSkills = registerPluginSkills((cwd) => new Promise((resolve9) => {
+var unregisterSkills = registerPluginSkills((cwd) => new Promise((resolve10) => {
   if (skillRequests.size >= 64) {
-    resolve9("");
+    resolve10("");
     return;
   }
   const requestId = ++skillRequestId;
   const timer = setTimeout(() => {
     skillRequests.delete(requestId);
-    resolve9("");
+    resolve10("");
   }, 5e3);
   timer.unref();
-  skillRequests.set(requestId, { resolve: resolve9, timer });
+  skillRequests.set(requestId, { resolve: resolve10, timer });
   send2({ type: "plugin-skills", requestId, cwd });
 }));
 function snapshot() {
@@ -20423,6 +21433,19 @@ function publishSnapshot() {
 var poll = setInterval(publishSnapshot, 300);
 poll.unref();
 process.on("message", (message) => {
+  if (isRecord(message) && typeof message.id === "number" && message.type === "startup-abort") {
+    startups.get(message.id)?.abort(new Error("Session startup cancelled"));
+    readiness.get(message.id)?.reject(new Error("Session startup cancelled"));
+    readiness.delete(message.id);
+    return;
+  }
+  if (isRecord(message) && typeof message.id === "number" && message.type === "startup-ready-result") {
+    const pending = readiness.get(message.id);
+    readiness.delete(message.id);
+    if (typeof message.error === "string") pending?.reject(new Error(message.error));
+    else pending?.resolve();
+    return;
+  }
   if (isRecord(message) && message.type === "plugin-skills-result" && typeof message.requestId === "number") {
     const request = skillRequests.get(message.requestId);
     if (request) {
@@ -20445,10 +21468,20 @@ process.on("message", (message) => {
       args[0] = new Map(args[0].map(([id2, models]) => [id2, new Map(models)]));
       args[1] = Array.isArray(args[1]) ? new Set(args[1]) : void 0;
     }
-    if (method === "start" && isRecord(args[0])) args[0].onSessionId = (sessionId) => {
-      watch2(sessionId);
-      send2({ type: "identity", id, sessionId });
-    };
+    if (method === "start" && isRecord(args[0])) {
+      args[0].onSessionId = (sessionId) => {
+        watch2(sessionId);
+        send2({ type: "identity", id, sessionId });
+      };
+      const controller = new AbortController();
+      startups.set(id, controller);
+      args[0].signal = controller.signal;
+      if (args[0].beforeFirstTurn === true) args[0].beforeFirstTurn = (identity) => new Promise((resolve10, reject) => {
+        readiness.set(id, { resolve: resolve10, reject });
+        send2({ type: "startup-ready", id, ...identity });
+      });
+      else args[0].beforeFirstTurn = void 0;
+    }
     if (typeof args[0] === "string") watch2(args[0]);
     const operation = runtime[method];
     if (typeof operation !== "function") throw new Error("Unsupported runtime operation");
@@ -20474,7 +21507,10 @@ process.on("message", (message) => {
       return { ...result, completion: void 0, hasCompletion: Boolean(completion) };
     }
     return result;
-  })().then((value) => send2({ id, value }), (error2) => send2({ id, error: error2 instanceof Error ? error2.message : "Instance operation failed", status: isRecord(error2) ? error2.status : void 0, code: isRecord(error2) ? error2.code : void 0 }));
+  })().finally(() => {
+    startups.delete(id);
+    readiness.delete(id);
+  }).then((value) => send2({ id, value }), (error2) => send2({ id, error: error2 instanceof Error ? error2.message : "Instance operation failed", status: isRecord(error2) ? error2.status : void 0, code: isRecord(error2) ? error2.code : void 0 }));
 });
 async function close() {
   clearInterval(poll);