negotium 0.1.7 → 0.1.9

package/dist/chunk-2dgkah1z.js

@@ -0,0 +1,706 @@
+import {
+  parseJsonlText,
+  writeJsonlFile
+} from "./chunk-pkdmypdd.js";
+import {
+  CLAUDE_EFFORT_VALUES,
+  DM_WORKSPACE_DIR,
+  MODEL_FABLE,
+  MODEL_OPUS,
+  MODEL_SONNET,
+  TOPIC_WORKSPACE_DIR,
+  WORKSPACE_DIR,
+  logger
+} from "./chunk-k9z47mab.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-hwy3n31w.js";
+
+// ../../packages/core/src/platform/maestro-bootstrap-env.ts
+process.env.MAESTRO_SDK_SILENT_BOOTSTRAP ??= "1";
+
+// ../../packages/core/src/agents/claude-registry.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, renameSync, unlinkSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// ../../packages/core/src/agents/rollout/claude.ts
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// ../../packages/core/src/agents/rollout/shared.ts
+import { mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var FIXTURES_DIR = join(__dirname2, "..", "fixtures");
+function clone(obj) {
+  return structuredClone(obj);
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function assertUuidLike(label, value) {
+  if (!UUID_RE.test(value)) {
+    throw new Error(`rollout: ${label} is not a UUID-shaped string: ${value}`);
+  }
+}
+function assertCwdInWorkspace(cwd) {
+  const abs = resolve(cwd);
+  const roots = [WORKSPACE_DIR, DM_WORKSPACE_DIR, TOPIC_WORKSPACE_DIR];
+  const ok = roots.some((root) => abs === root || abs.startsWith(`${root}/`));
+  if (!ok) {
+    throw new Error(`rollout: cwd outside trusted workspace roots: ${cwd} (resolved=${abs})`);
+  }
+}
+function ensureCwdExists(cwd) {
+  assertCwdInWorkspace(cwd);
+  try {
+    mkdirSync(cwd, { recursive: true });
+  } catch (err) {
+    logger.warn({ err, cwd }, "rollout: ensureCwdExists failed \u2014 caller should pre-create cwd");
+  }
+}
+function truncate(text, n) {
+  const cps = Array.from(text);
+  return cps.length > n ? `${cps.slice(0, n).join("")}\u2026` : text;
+}
+function extractChatPairs(entries, opts = { includeToolAnnotations: true }) {
+  const pairs = [];
+  let pendingUser = null;
+  let pendingAssistantParts = [];
+  let toolBuffer = [];
+  const flushAssistant = () => {
+    if (pendingUser === null)
+      return;
+    const tools = opts.includeToolAnnotations && toolBuffer.length > 0 ? `
+
+${toolBuffer.join(`
+`)}` : "";
+    const assistantText = pendingAssistantParts.join("").trim() + tools;
+    if (assistantText.trim()) {
+      pairs.push({ userText: pendingUser, assistantText });
+    }
+    pendingUser = null;
+    pendingAssistantParts = [];
+    toolBuffer = [];
+  };
+  for (const entry of entries) {
+    const ev = entry.event;
+    switch (ev.type) {
+      case "user_message": {
+        flushAssistant();
+        pendingUser = ev.content;
+        break;
+      }
+      case "session":
+        if (pendingAssistantParts.length > 0 || toolBuffer.length > 0) {
+          flushAssistant();
+        }
+        break;
+      case "text": {
+        if (pendingUser === null) {
+          pendingUser = "(continued)";
+        }
+        pendingAssistantParts.push(ev.content);
+        break;
+      }
+      case "result": {
+        if (pendingUser === null) {
+          pendingUser = "(continued)";
+        }
+        pendingAssistantParts = [ev.content];
+        flushAssistant();
+        break;
+      }
+      case "text_delta":
+        break;
+      case "tool_use": {
+        const u = ev;
+        toolBuffer.push(`<!-- Tool: ${u.name} ${truncate(JSON.stringify(u.input), 200)} -->`);
+        break;
+      }
+      case "tool_result": {
+        const u = ev;
+        toolBuffer.push(`<!-- Tool result: ${truncate(u.content, 200)} -->`);
+        break;
+      }
+      case "error": {
+        const u = ev;
+        toolBuffer.push(`[Error: ${truncate(u.content, 200)}]`);
+        break;
+      }
+      case "tool_progress":
+      case "tool_use_summary":
+      case "file":
+      case "status":
+        break;
+    }
+  }
+  flushAssistant();
+  return pairs;
+}
+
+// ../../packages/core/src/agents/rollout/claude.ts
+var _attachmentsCache = null;
+function loadClaudeAttachments() {
+  if (_attachmentsCache)
+    return _attachmentsCache;
+  const raw = readFileSync(join2(FIXTURES_DIR, "claude-attachments.jsonl"), "utf8");
+  const lines = parseJsonlText(raw);
+  if (lines.length < 2) {
+    throw new Error(`loadClaudeAttachments: expected >=2 entries in claude-attachments.jsonl, got ${lines.length}`);
+  }
+  _attachmentsCache = {
+    deferredToolsDelta: lines[0],
+    skillListing: lines[1]
+  };
+  return _attachmentsCache;
+}
+var CLAUDE_SDK_VERSION = "2.1.126";
+var CLAUDE_DEFAULT_MODEL = "claude-sonnet-5";
+var CLAUDE_DEFAULT_GIT_BRANCH = "HEAD";
+function encodeClaudeCwd(cwd) {
+  const realCwd = cwd.startsWith("/tmp/") ? cwd.replace(/^\/tmp\//, "/private/tmp/") : cwd;
+  return `-${realCwd.replaceAll(/[^a-zA-Z0-9]/g, "-").replace(/^-/, "")}`;
+}
+function writeClaudeRollout(opts) {
+  const sessionId = opts.sessionId ?? randomUUID();
+  assertUuidLike("sessionId", sessionId);
+  ensureCwdExists(opts.cwd);
+  const pairs = opts.pairs ?? extractChatPairs(opts.entries ?? []);
+  const cwdReal = opts.cwd.startsWith("/tmp/") ? opts.cwd.replace(/^\/tmp\//, "/private/tmp/") : opts.cwd;
+  const lines = [];
+  const ts = () => new Date().toISOString();
+  let lastUuid = null;
+  lines.push({ type: "queue-operation", operation: "enqueue", timestamp: ts(), sessionId });
+  lines.push({ type: "queue-operation", operation: "dequeue", timestamp: ts(), sessionId });
+  const attachments = loadClaudeAttachments();
+  for (const pair of pairs) {
+    const userUuid = randomUUID();
+    lines.push({
+      parentUuid: lastUuid,
+      isSidechain: false,
+      promptId: randomUUID(),
+      type: "user",
+      message: { role: "user", content: [{ type: "text", text: pair.userText }] },
+      uuid: userUuid,
+      timestamp: ts(),
+      permissionMode: "bypassPermissions",
+      userType: "external",
+      entrypoint: "sdk-ts",
+      cwd: cwdReal,
+      sessionId,
+      version: CLAUDE_SDK_VERSION,
+      gitBranch: CLAUDE_DEFAULT_GIT_BRANCH
+    });
+    const att1Uuid = randomUUID();
+    const att1 = clone(attachments.deferredToolsDelta);
+    att1.parentUuid = userUuid;
+    att1.uuid = att1Uuid;
+    att1.timestamp = ts();
+    att1.sessionId = sessionId;
+    att1.cwd = cwdReal;
+    lines.push(att1);
+    const att2Uuid = randomUUID();
+    const att2 = clone(attachments.skillListing);
+    att2.parentUuid = att1Uuid;
+    att2.uuid = att2Uuid;
+    att2.timestamp = ts();
+    att2.sessionId = sessionId;
+    att2.cwd = cwdReal;
+    lines.push(att2);
+    const assistantUuid = randomUUID();
+    lines.push({
+      parentUuid: att2Uuid,
+      isSidechain: false,
+      message: {
+        model: opts.model ?? CLAUDE_DEFAULT_MODEL,
+        id: `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`,
+        type: "message",
+        role: "assistant",
+        content: [{ type: "text", text: pair.assistantText }],
+        stop_reason: "end_turn",
+        stop_sequence: null,
+        stop_details: null,
+        usage: {
+          input_tokens: 0,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+          output_tokens: 0,
+          server_tool_use: { web_search_requests: 0, web_fetch_requests: 0 },
+          service_tier: "standard",
+          cache_creation: { ephemeral_1h_input_tokens: 0, ephemeral_5m_input_tokens: 0 },
+          inference_geo: "",
+          iterations: [],
+          speed: "standard"
+        },
+        diagnostics: null
+      },
+      requestId: `req_${randomUUID().replace(/-/g, "").slice(0, 22)}`,
+      type: "assistant",
+      uuid: assistantUuid,
+      timestamp: ts(),
+      userType: "external",
+      entrypoint: "sdk-ts",
+      cwd: cwdReal,
+      sessionId,
+      version: CLAUDE_SDK_VERSION,
+      gitBranch: CLAUDE_DEFAULT_GIT_BRANCH
+    });
+    lastUuid = assistantUuid;
+  }
+  const projectsDir = join2(homedir(), ".claude", "projects", encodeClaudeCwd(opts.cwd));
+  const path = join2(projectsDir, `${sessionId}.jsonl`);
+  writeJsonlFile(path, lines);
+  logger.info({ sessionId, path, pairs: pairs.length }, "writeClaudeRollout: synthetic rollout placed");
+  return { sessionId, rolloutPath: path };
+}
+
+// ../../packages/core/src/agents/claude-registry.ts
+var ALIAS_MAP = {
+  sonnet: MODEL_SONNET,
+  opus: MODEL_OPUS,
+  fable: MODEL_FABLE
+};
+var VALID_ALIASES = new Set(Object.keys(ALIAS_MAP));
+var VALID_EFFORTS = new Set(CLAUDE_EFFORT_VALUES);
+var claudeRegistry = {
+  kind: "claude",
+  defaultModel: "sonnet",
+  defaultEffort: "high",
+  expandModelAlias(s) {
+    return ALIAS_MAP[s] ?? s;
+  },
+  validateModel(s) {
+    return VALID_ALIASES.has(s);
+  },
+  validEfforts: CLAUDE_EFFORT_VALUES,
+  validateEffort(s) {
+    return VALID_EFFORTS.has(s);
+  },
+  footerLabel(model, effort) {
+    return effort ? `${model} \xB7 ${effort}` : model;
+  },
+  writeRollout(opts) {
+    const { sessionId, rolloutPath } = writeClaudeRollout({
+      cwd: opts.cwd,
+      entries: opts.entries,
+      model: claudeRegistry.expandModelAlias(opts.model ?? claudeRegistry.defaultModel),
+      ...opts.reuseSessionId ? { sessionId: opts.reuseSessionId } : {}
+    });
+    return { sessionId, rolloutPath };
+  },
+  async forkSession({ parentSessionId, cwd, title }) {
+    const { forkSession } = await import("@anthropic-ai/claude-agent-sdk");
+    const result = await forkSession(parentSessionId, {
+      ...title ? { title } : {}
+    });
+    const projectsRoot = join3(homedir2(), ".claude", "projects");
+    const destDir = join3(projectsRoot, encodeClaudeCwd(cwd));
+    const destPath = join3(destDir, `${result.sessionId}.jsonl`);
+    if (!existsSync2(destPath)) {
+      const sourcePath = readdirSync(projectsRoot).map((d) => join3(projectsRoot, d, `${result.sessionId}.jsonl`)).find((p) => existsSync2(p));
+      if (!sourcePath) {
+        throw new Error(`claude forkSession: fork rollout ${result.sessionId}.jsonl not found under ${projectsRoot}`);
+      }
+      mkdirSync2(destDir, { recursive: true });
+      renameSync(sourcePath, destPath);
+    }
+    return {
+      forkId: result.sessionId,
+      rolloutPath: destPath
+    };
+  },
+  async cleanupRollouts({ cwd, sessionIds }) {
+    const projectsDir = join3(homedir2(), ".claude", "projects", encodeClaudeCwd(cwd));
+    const failures = [];
+    for (const sid of sessionIds) {
+      const path = join3(projectsDir, `${sid}.jsonl`);
+      try {
+        unlinkSync(path);
+      } catch (e) {
+        if (e?.code !== "ENOENT") {
+          logger.warn({ err: e, path }, "claude cleanupRollouts: unlink failed");
+          failures.push(e);
+        }
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "claude cleanupRollouts failed");
+    }
+  }
+};
+
+// ../../packages/core/src/agents/rollout/codex.ts
+import { randomBytes } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync, unlinkSync as unlinkSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+function codexSessionsDir() {
+  return join4(process.env.CODEX_HOME || join4(homedir3(), ".codex"), "sessions");
+}
+var _shellCache = null;
+function loadCodexShell() {
+  if (_shellCache)
+    return _shellCache;
+  const raw = readFileSync2(join4(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
+  const lines = parseJsonlText(raw);
+  if (lines.length < 5) {
+    throw new Error(`loadCodexShell: expected >=5 entries in codex-shell.jsonl, got ${lines.length}`);
+  }
+  _shellCache = {
+    sessionMeta: lines[0],
+    taskStarted: lines[1],
+    developerSetup: lines[2],
+    envContext: lines[3],
+    turnContext: lines[4]
+  };
+  return _shellCache;
+}
+function uuidv7() {
+  const ts = Date.now();
+  const tsHex = ts.toString(16).padStart(12, "0");
+  const rand = randomBytes(10);
+  rand[0] = rand[0] & 15 | 112;
+  rand[2] = rand[2] & 63 | 128;
+  return [
+    tsHex.slice(0, 8),
+    tsHex.slice(8, 12),
+    rand.slice(0, 2).toString("hex"),
+    rand.slice(2, 4).toString("hex"),
+    rand.slice(4, 10).toString("hex")
+  ].join("-");
+}
+function patchDeveloperSetup(developerSetup) {
+  const payload = developerSetup.payload;
+  if (!payload)
+    return;
+  payload.content = [
+    {
+      type: "input_text",
+      text: [
+        "<permissions instructions>",
+        "Filesystem sandboxing is disabled for this runtime turn (`danger-full-access`).",
+        "Approval policy is `never`.",
+        "</permissions instructions>"
+      ].join(`
+`)
+    }
+  ];
+}
+function patchEnvContext(envContext, cwd, currentDate, timezone) {
+  const payload = envContext.payload;
+  if (!payload)
+    return;
+  const content = payload.content;
+  if (!Array.isArray(content))
+    return;
+  for (const block of content) {
+    if (block.type === "input_text" && typeof block.text === "string") {
+      block.text = block.text.replace(/<cwd>[^<]*<\/cwd>/, `<cwd>${cwd}</cwd>`).replace(/<current_date>[^<]*<\/current_date>/, `<current_date>${currentDate}</current_date>`).replace(/<timezone>[^<]*<\/timezone>/, `<timezone>${timezone}</timezone>`);
+    }
+  }
+}
+function extractLatestCodexContextUsage(jsonl) {
+  const lines = jsonl.trimEnd().split(`
+`);
+  for (let index = lines.length - 1;index >= 0; index -= 1) {
+    try {
+      const entry = JSON.parse(lines[index] ?? "");
+      if (entry.type !== "event_msg" || entry.payload?.type !== "token_count")
+        continue;
+      const contextTokens = entry.payload.info?.last_token_usage?.total_tokens;
+      const contextWindow = entry.payload.info?.model_context_window;
+      if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens >= 0 && typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0) {
+        return { contextTokens, contextWindow };
+      }
+    } catch {}
+  }
+  return;
+}
+function readLatestCodexContextUsage(threadId) {
+  const sessionsDir = codexSessionsDir();
+  const candidates = [];
+  const buckets = candidateDateBuckets(threadId);
+  try {
+    if (buckets) {
+      for (const bucket of buckets) {
+        const dir = join4(sessionsDir, bucket);
+        if (!existsSync3(dir))
+          continue;
+        const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
+        for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
+          candidates.push(join4(dir, rel));
+        }
+      }
+    } else {
+      const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
+      for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
+        candidates.push(join4(sessionsDir, rel));
+      }
+    }
+    const path = candidates.sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)[0];
+    return path ? extractLatestCodexContextUsage(readFileSync2(path, "utf8")) : undefined;
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex context usage: rollout read failed");
+    return;
+  }
+}
+function migrateCodexRolloutNativeMultiAgentMetadata(threadId) {
+  const path = latestCodexRolloutPath(threadId);
+  if (!path)
+    return false;
+  try {
+    const entries = parseJsonlText(readFileSync2(path, "utf8"));
+    let changed = false;
+    for (const entry of entries) {
+      if (entry.type !== "session_meta" && entry.type !== "turn_context")
+        continue;
+      if (!entry.payload)
+        entry.payload = {};
+      if (entry.payload.multi_agent_version !== "disabled") {
+        entry.payload.multi_agent_version = "disabled";
+        changed = true;
+      }
+    }
+    if (changed) {
+      writeJsonlFile(path, entries);
+      logger.info({ threadId, path }, "codex rollout native multi-agent metadata disabled");
+    }
+    return changed;
+  } catch (error) {
+    logger.error({ error, threadId, path }, "codex rollout native multi-agent migration failed");
+    throw new Error(`Failed to migrate Codex rollout '${threadId}'`, { cause: error });
+  }
+}
+function latestCodexRolloutPath(threadId) {
+  const sessionsDir = codexSessionsDir();
+  const candidates = [];
+  const buckets = candidateDateBuckets(threadId);
+  try {
+    if (buckets) {
+      for (const bucket of buckets) {
+        const dir = join4(sessionsDir, bucket);
+        if (!existsSync3(dir))
+          continue;
+        const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
+        for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
+          candidates.push(join4(dir, rel));
+        }
+      }
+    }
+    if (candidates.length === 0) {
+      const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
+      for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
+        candidates.push(join4(sessionsDir, rel));
+      }
+    }
+    return candidates.sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)[0];
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex rollout lookup failed");
+    return;
+  }
+}
+function writeCodexRollout(opts) {
+  const threadId = opts.threadId ?? uuidv7();
+  assertUuidLike("threadId", threadId);
+  ensureCwdExists(opts.cwd);
+  const pairs = opts.pairs ?? extractChatPairs(opts.entries ?? []);
+  const now = new Date;
+  const tsIso = now.toISOString();
+  const currentDate = [
+    now.getFullYear(),
+    String(now.getMonth() + 1).padStart(2, "0"),
+    String(now.getDate()).padStart(2, "0")
+  ].join("-");
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || process.env.TZ || "UTC";
+  const shell = loadCodexShell();
+  const sessionMeta = clone(shell.sessionMeta);
+  sessionMeta.payload.id = threadId;
+  sessionMeta.payload.timestamp = tsIso;
+  sessionMeta.payload.cwd = opts.cwd;
+  sessionMeta.payload.multi_agent_version = "disabled";
+  sessionMeta.timestamp = tsIso;
+  const taskStarted = clone(shell.taskStarted);
+  taskStarted.timestamp = tsIso;
+  const developerSetup = clone(shell.developerSetup);
+  developerSetup.timestamp = tsIso;
+  patchDeveloperSetup(developerSetup);
+  const envContext = clone(shell.envContext);
+  envContext.timestamp = tsIso;
+  patchEnvContext(envContext, opts.cwd, currentDate, timezone);
+  const turnContext = clone(shell.turnContext);
+  turnContext.timestamp = tsIso;
+  const turnPayload = turnContext.payload;
+  turnPayload.cwd = opts.cwd;
+  turnPayload.current_date = currentDate;
+  turnPayload.timezone = timezone;
+  turnPayload.approval_policy = "never";
+  turnPayload.sandbox_policy = { type: "danger-full-access" };
+  turnPayload.multi_agent_version = "disabled";
+  delete turnPayload.permission_profile;
+  if (opts.model)
+    turnPayload.model = opts.model;
+  const collaborationMode = turnPayload.collaboration_mode;
+  const collaborationSettings = collaborationMode?.settings;
+  if (collaborationSettings) {
+    if (opts.model)
+      collaborationSettings.model = opts.model;
+    if (opts.effort !== undefined)
+      collaborationSettings.reasoning_effort = opts.effort;
+  }
+  const lines = [sessionMeta, taskStarted, developerSetup, envContext, turnContext];
+  for (const pair of pairs) {
+    lines.push({
+      timestamp: tsIso,
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: pair.userText }]
+      }
+    });
+    lines.push({
+      timestamp: tsIso,
+      type: "event_msg",
+      payload: {
+        type: "user_message",
+        message: pair.userText,
+        images: [],
+        local_images: [],
+        text_elements: []
+      }
+    });
+    lines.push({
+      timestamp: tsIso,
+      type: "event_msg",
+      payload: {
+        type: "agent_message",
+        message: pair.assistantText,
+        phase: "final_answer",
+        memory_citation: null
+      }
+    });
+    lines.push({
+      timestamp: tsIso,
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: pair.assistantText }],
+        phase: "final_answer"
+      }
+    });
+  }
+  lines.push({
+    timestamp: tsIso,
+    type: "event_msg",
+    payload: { type: "task_complete" }
+  });
+  const yyyy = now.getUTCFullYear();
+  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(now.getUTCDate()).padStart(2, "0");
+  const tsStr = tsIso.replace(/[:.]/g, "-").slice(0, 19);
+  const dir = join4(codexSessionsDir(), String(yyyy), mm, dd);
+  const path = join4(dir, `rollout-${tsStr}-${threadId}.jsonl`);
+  if (opts.threadId) {
+    sweepPriorRolloutsForThread(opts.threadId);
+  }
+  writeJsonlFile(path, lines);
+  logger.info({ threadId, path, pairs: pairs.length }, "writeCodexRollout: synthetic rollout placed");
+  return { threadId, rolloutPath: path };
+}
+function sweepPriorRolloutsForThread(threadId) {
+  const sessionsDir = codexSessionsDir();
+  const buckets = candidateDateBuckets(threadId);
+  if (!buckets) {
+    sweepPriorRolloutsFullTree(threadId, sessionsDir);
+    return;
+  }
+  for (const bucket of buckets) {
+    const dir = join4(sessionsDir, bucket);
+    if (!existsSync3(dir))
+      continue;
+    try {
+      const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
+      for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
+        const fullPath = join4(dir, rel);
+        try {
+          unlinkSync2(fullPath);
+        } catch (e) {
+          if (e?.code !== "ENOENT") {
+            logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
+          }
+        }
+      }
+    } catch (e) {
+      logger.warn({ err: e, threadId, bucket }, "writeCodexRollout: prior-rollout bucket scan failed (continuing)");
+    }
+  }
+}
+function sweepPriorRolloutsFullTree(threadId, sessionsDir) {
+  try {
+    const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
+    for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
+      const fullPath = join4(sessionsDir, rel);
+      try {
+        unlinkSync2(fullPath);
+      } catch (e) {
+        if (e?.code !== "ENOENT") {
+          logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
+        }
+      }
+    }
+  } catch (e) {
+    logger.warn({ err: e, threadId }, "writeCodexRollout: full-tree prior-rollout sweep failed (continuing)");
+  }
+}
+var MAX_DAY_SPAN = 30;
+var DAY_MS = 86400000;
+var LOCAL_DATE_SKEW_DAYS = 1;
+function candidateDateBuckets(threadId) {
+  const tidMs = decodeUuidV7Timestamp(threadId);
+  if (tidMs === null)
+    return null;
+  const nowMs = Date.now();
+  const tidDay = Math.floor(tidMs / DAY_MS);
+  const todayDay = Math.floor(nowMs / DAY_MS);
+  const minDay = Math.min(tidDay, todayDay);
+  const maxDay = Math.max(tidDay, todayDay);
+  const span = maxDay - minDay;
+  if (span > MAX_DAY_SPAN)
+    return null;
+  const buckets = new Set;
+  for (let d = minDay - LOCAL_DATE_SKEW_DAYS;d <= maxDay + LOCAL_DATE_SKEW_DAYS; d++) {
+    buckets.add(formatDateBucket(new Date(d * DAY_MS)));
+  }
+  return buckets;
+}
+function decodeUuidV7Timestamp(threadId) {
+  if (typeof threadId !== "string")
+    return null;
+  const m = /^([0-9a-fA-F]{8})-([0-9a-fA-F]{4})-7[0-9a-fA-F]{3}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.exec(threadId);
+  if (!m)
+    return null;
+  const hex = `${m[1]}${m[2]}`;
+  const ms = Number.parseInt(hex, 16);
+  if (!Number.isFinite(ms))
+    return null;
+  const MIN = 1577836800000;
+  const MAX = 4102444800000;
+  if (ms < MIN || ms > MAX)
+    return null;
+  return ms;
+}
+function formatDateBucket(d) {
+  const yyyy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  return `${yyyy}/${mm}/${dd}`;
+}
+
+export { encodeClaudeCwd, claudeRegistry, readLatestCodexContextUsage, migrateCodexRolloutNativeMultiAgentMetadata, writeCodexRollout };
+
+//# debugId=1D492EB711EDE86B64756E2164756E21