taskchef 8.7.1 → 9.0.0

package/src/delegation.js

@@ -1,277 +0,0 @@
-import { randomUUID } from "node:crypto";
-
-/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
-export const EXECUTOR_OWNERSHIP_PARAGRAPH = "This task owns the delegated assignment. Execute it in this task; do not re-dispatch it merely because it concerns TaskChef or a configured project. Explicit requests to delegate separate work remain valid.";
-/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
-export const EXECUTOR_LINK_PARAGRAPH = "Before any other work, read this executor's own durable Codex thread ID from the current task's CODEX_THREAD_ID environment value and call the TaskChef link_task MCP tool with that thread ID and the marked TaskChef task ID. Never use CODEX_SESSION_ID or the parent or delegator thread ID. If linking fails, CODEX_THREAD_ID is unavailable, or the tool is unavailable, report the failure visibly and retry on a later turn; do not guess an identity or continue substantive work while the task is link-pending.";
-/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
-export const EXECUTOR_WORKING_PARAGRAPH = "After a successful initial link, and at the start of every follow-up turn before substantive work, read this exact Codex thread natively to obtain the current turn ID and call TaskChef report_state with the marked task ID, the self-linked thread ID, that current turn ID, status working, summary omitted or null, and a concise requestSummary for this turn. link_task remains the first TaskChef action on the initial turn; do not report working before identity is linked. Never reuse a prior turn ID after a follow-up.";
-/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
-export const EXECUTOR_RESULT_PARAGRAPH = "Before ending, read this exact Codex thread again and call TaskChef report_state for the same current working turn with status completed, needs_input, or failed and a concise summary. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.";
-export const EXECUTOR_REPORTING_AUTHORIZATION = "Report this task and its follow-ups to my local TaskChef dashboard. Relevant private-repository links and concise work, test, and deployment results are authorized; exclude secrets.";
-export const EXECUTOR_SKILL_INVOCATION = "Use $taskchef-executor to execute and report this delegated TaskChef assignment.";
-const HISTORICAL_RESULT_WITH_TURN_PARAGRAPH = "Before ending, call the TaskChef report_result MCP tool with the marked task ID, this executor's self-linked thread ID, the current turn ID from an exact native read of that same thread, completed, needs_input, or failed, and a concise summary. Never reuse a prior turn ID after a follow-up. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.";
-const HISTORICAL_RESULT_PARAGRAPH = "Before ending, call the TaskChef report_result MCP tool with completed, needs_input, or failed and a concise summary. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.";
-const HISTORICAL_EXECUTOR_SCAFFOLD_LINES = new Set([
-  EXECUTOR_OWNERSHIP_PARAGRAPH,
-  EXECUTOR_LINK_PARAGRAPH,
-  EXECUTOR_WORKING_PARAGRAPH,
-  EXECUTOR_RESULT_PARAGRAPH,
-  HISTORICAL_RESULT_WITH_TURN_PARAGRAPH,
-  HISTORICAL_RESULT_PARAGRAPH,
-]);
-const HISTORICAL_INLINE_PROTOCOLS = [
-  [EXECUTOR_OWNERSHIP_PARAGRAPH, EXECUTOR_LINK_PARAGRAPH, EXECUTOR_WORKING_PARAGRAPH, EXECUTOR_RESULT_PARAGRAPH],
-  [EXECUTOR_OWNERSHIP_PARAGRAPH, EXECUTOR_LINK_PARAGRAPH, HISTORICAL_RESULT_WITH_TURN_PARAGRAPH],
-  [EXECUTOR_OWNERSHIP_PARAGRAPH, HISTORICAL_RESULT_PARAGRAPH],
-  [EXECUTOR_OWNERSHIP_PARAGRAPH],
-];
-
-function hasTaskSpecificContent(lines) {
-  return lines.some((line) => (
-    line.trim().length > 0 && line !== EXECUTOR_REPORTING_AUTHORIZATION && !HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line)
-  ));
-}
-
-const UUID_SOURCE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-const UUID_PATTERN = new RegExp(`^${UUID_SOURCE}$`);
-const CODEX_UUID_V7_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-const TASKCHEF_MARKER_PATTERN = new RegExp(`^<!-- taskchef_id=(${UUID_SOURCE}) -->$`);
-const LEGACY_TASKCHEF_MARKER_PATTERN = new RegExp(`^# taskchef_id=(${UUID_SOURCE})$`);
-
-function requireObject(value, name) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} must be an object`);
-  return value;
-}
-
-function requireString(value, name) {
-  if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${name} must be a non-empty string`);
-  return value;
-}
-
-function requireUuid(value, name = "taskId") {
-  requireString(value, name);
-  if (!UUID_PATTERN.test(value)) throw new Error(`${name} must be a lowercase full UUID`);
-  return value;
-}
-
-function parseToolResult(value, name) {
-  if (typeof value !== "string") return requireObject(value, name);
-  try {
-    return requireObject(JSON.parse(value), name);
-  } catch (error) {
-    if (error instanceof SyntaxError) throw new Error(`${name} must contain valid JSON`);
-    throw error;
-  }
-}
-
-function toolIdentifier(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-
-function attachCreationRecovery(error, taskId, turnRef, resultReporting) {
-  const creationError = error instanceof Error ? error : new Error(String(error));
-  try {
-    Object.defineProperties(creationError, {
-      taskChefTaskId: { value: taskId, enumerable: true },
-      taskChefTurnRef: { value: turnRef, enumerable: true },
-      taskChefResultReporting: { value: resultReporting, enumerable: true },
-    });
-    return creationError;
-  } catch {
-    const wrapped = new Error(`Executor creation failed for recorded TaskChef task ${taskId}.`, { cause: creationError });
-    wrapped.taskChefTaskId = taskId;
-    wrapped.taskChefTurnRef = turnRef;
-    wrapped.taskChefResultReporting = resultReporting;
-    return wrapped;
-  }
-}
-
-export function isProvisionalThreadId(value) {
-  const id = toolIdentifier(value);
-  return id !== null && id.startsWith("local:");
-}
-
-export function normalizeDurableThreadId(value, name = "threadId") {
-  const id = toolIdentifier(value);
-  if (id === null) throw new Error(`${name} must be a non-empty string`);
-  if (isProvisionalThreadId(id)) throw new Error(`${name} must be a durable thread ID, not a provisional local ID`);
-  return id;
-}
-
-export function normalizeCodexThreadId(value, name = "threadId") {
-  const id = normalizeDurableThreadId(value, name).toLowerCase();
-  if (!CODEX_UUID_V7_PATTERN.test(id)) {
-    throw new Error(`${name} must be a canonical Codex UUIDv7`);
-  }
-  return id;
-}
-
-export function taskChefMarker(taskId) {
-  return `<!-- taskchef_id=${requireUuid(taskId)} -->`;
-}
-
-export function parseTaskChefMarker(instruction) {
-  if (typeof instruction !== "string") return null;
-  const lines = instruction.split(/\r\n|\r|\n/);
-  const hasHistoricalAssignment = () => {
-    const rest = lines.slice(1);
-    const executorSkillInvocationIndices = rest.flatMap((line, index) => (
-      line === EXECUTOR_SKILL_INVOCATION ? [index] : []
-    ));
-    if (executorSkillInvocationIndices.length > 0) {
-      const bodyLines = rest.slice(0, -2);
-      return executorSkillInvocationIndices.length === 1
-        && executorSkillInvocationIndices[0] === rest.length - 1
-        && lines.at(-1) === EXECUTOR_SKILL_INVOCATION
-        && lines.at(-2) === ""
-        && bodyLines.length > 0
-        && bodyLines[0].trim().length > 0
-        && bodyLines.at(-1).trim().length > 0
-        && hasTaskSpecificContent(bodyLines)
-        && !bodyLines.some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line));
-    }
-
-    const containsInlineScaffold = rest.some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line));
-    if (!containsInlineScaffold) return hasTaskSpecificContent(rest);
-    return HISTORICAL_INLINE_PROTOCOLS.some((protocol) => {
-      const prefix = ["", ...protocol.flatMap((line) => [line, ""])];
-      if (!prefix.every((line, index) => rest[index] === line)) return false;
-      const bodyLines = rest.slice(prefix.length);
-      return hasTaskSpecificContent(bodyLines)
-        && !bodyLines.some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line));
-    });
-  };
-  const currentMatches = lines.flatMap((line, index) => {
-    const match = line.match(TASKCHEF_MARKER_PATTERN);
-    return match === null ? [] : [{ id: match[1], index }];
-  });
-  const legacyMatches = lines.flatMap((line, index) => {
-    const match = line.match(LEGACY_TASKCHEF_MARKER_PATTERN);
-    return match === null ? [] : [{ id: match[1], index }];
-  });
-  if (currentMatches.length + legacyMatches.length !== 1) return null;
-
-  if (legacyMatches.length === 1) {
-    const [{ id, index }] = legacyMatches;
-    if (index !== 0) return null;
-    return hasHistoricalAssignment() ? id : null;
-  }
-
-  const [{ id, index }] = currentMatches;
-  if (index === 0) {
-    return hasHistoricalAssignment() ? id : null;
-  }
-  const executorSkillReferences = instruction.match(/\$taskchef-executor\b/gi) ?? [];
-  const hasCurrentCompactBoundary = index >= 2
-    && lines.at(index - 2).trim().length > 0;
-  const hasCurrentBlankBoundary = index >= 3
-    && lines.at(index - 2) === ""
-    && lines.at(index - 3).trim().length > 0;
-  const currentAssignmentEnd = hasCurrentCompactBoundary ? index - 1 : index - 2;
-  const isFinalMarkerScaffold = index === lines.length - 1
-    && (hasCurrentCompactBoundary || hasCurrentBlankBoundary)
-    && lines[0].trim().length > 0
-    && lines.at(-2) === EXECUTOR_SKILL_INVOCATION
-    && hasTaskSpecificContent(lines.slice(0, currentAssignmentEnd))
-    && !lines.slice(0, currentAssignmentEnd).some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line))
-    && executorSkillReferences.length === 1;
-  if (isFinalMarkerScaffold) return id;
-
-  const hasCompactBoundary = index >= 1
-    && lines.at(index - 1).trim().length > 0;
-  const hasHistoricalBlankBoundary = index >= 2
-    && lines.at(index - 1) === ""
-    && lines.at(index - 2).trim().length > 0;
-  const assignmentEnd = hasCompactBoundary ? index : index - 1;
-  const isTrailingScaffold = index === lines.length - 2
-    && (hasCompactBoundary || hasHistoricalBlankBoundary)
-    && lines[0].trim().length > 0
-    && lines.at(-1) === EXECUTOR_SKILL_INVOCATION
-    && hasTaskSpecificContent(lines.slice(0, assignmentEnd))
-    && !lines.slice(0, assignmentEnd).some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line))
-    && executorSkillReferences.length === 1;
-  return isTrailingScaffold ? id : null;
-}
-
-export function prepareDelegation(instruction, { taskId = randomUUID() } = {}) {
-  const rawBody = requireString(instruction, "instruction");
-  if (/^[^\S\r\n]*(?:\r\n|\r|\n)/.test(rawBody)) {
-    throw new Error("instruction must begin with useful task content on its first line");
-  }
-  const body = rawBody.replace(/(?:(?:\r\n|\r|\n)[^\S\r\n]*)+$/, "");
-  if (body.split(/\r\n|\r|\n/).some((line) => (
-    TASKCHEF_MARKER_PATTERN.test(line) || LEGACY_TASKCHEF_MARKER_PATTERN.test(line)
-  ))) {
-    throw new Error("instruction already contains a TaskChef marker");
-  }
-  if (/\$taskchef-executor\b/i.test(body)) {
-    throw new Error("instruction contains a reserved TaskChef executor skill reference");
-  }
-  const bodyLines = body.split(/\r\n|\r|\n/);
-  if (!hasTaskSpecificContent(bodyLines)) {
-    throw new Error("instruction must contain task-specific content, not only TaskChef lifecycle scaffolding");
-  }
-  if (bodyLines.some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line))) {
-    throw new Error("instruction contains reserved historical TaskChef lifecycle scaffolding");
-  }
-  if (bodyLines.includes(EXECUTOR_REPORTING_AUTHORIZATION)) {
-    throw new Error("instruction contains reserved TaskChef reporting authorization");
-  }
-  const id = requireUuid(taskId);
-  return {
-    id,
-    instruction: `${body}\n\n${EXECUTOR_REPORTING_AUTHORIZATION}\n\n${EXECUTOR_SKILL_INVOCATION}\n${taskChefMarker(id)}`,
-  };
-}
-
-export async function createAndRecordDelegation(input) {
-  const { project, title, instruction, target, createThread, recordTask, reportRecordedResult = null, taskId = randomUUID() } = input ?? {};
-  requireString(project, "project");
-  requireString(title, "title");
-  requireObject(target, "target");
-  for (const [value, name] of [[createThread, "createThread"], [recordTask, "recordTask"]]) {
-    if (typeof value !== "function") throw new Error(`${name} must be a function`);
-  }
-  if (reportRecordedResult !== null && typeof reportRecordedResult !== "function") throw new Error("reportRecordedResult must be a function or null");
-
-  const prepared = prepareDelegation(instruction, { taskId });
-  await recordTask({ id: prepared.id, project, title, instruction: prepared.instruction, threadId: null });
-
-  let createResult;
-  try {
-    createResult = parseToolResult(await createThread({ prompt: prepared.instruction, title, target }), "create_thread result");
-  } catch (error) {
-    const creationFailureTurnRef = randomUUID();
-    let resultReporting = "unavailable";
-    if (reportRecordedResult !== null) {
-      try {
-        await reportRecordedResult({
-          taskId: prepared.id,
-          threadId: null,
-          turnRef: creationFailureTurnRef,
-          turnId: null,
-          status: "failed",
-          summary: "Executor creation failed before the executor started.",
-        });
-        resultReporting = "recorded";
-      } catch {
-        resultReporting = "failed";
-      }
-    }
-    throw attachCreationRecovery(
-      error,
-      prepared.id,
-      creationFailureTurnRef,
-      resultReporting,
-    );
-  }
-
-  const returnedThreadId = toolIdentifier(createResult.threadId);
-  const clientThreadId = toolIdentifier(createResult.clientThreadId);
-  const pendingWorktreeId = toolIdentifier(createResult.pendingWorktreeId);
-  const provisional = clientThreadId ?? pendingWorktreeId ?? (isProvisionalThreadId(returnedThreadId) ? returnedThreadId : null);
-  return { status: "recorded-link-pending", resolution: "executor-self-link", ...prepared, threadId: null, provisional, hostId: createResult.hostId ?? null };
-}

package/src/github.js

@@ -1,107 +0,0 @@
-function requireRepositoryString(value, name) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`${name} must be a non-empty string`);
-  }
-  return value.trim();
-}
-
-function parseGithubUrl(value, name, { allowIssueOrPull = false } = {}) {
-  let remote = requireRepositoryString(value, name);
-  const scpMatch = remote.match(/^git@github\.com:([^/]+)\/([^/]+)\/?$/i);
-  if (scpMatch) {
-    return {
-      owner: scpMatch[1],
-      repository: scpMatch[2].replace(/\.git$/i, ""),
-    };
-  }
-  if (/^(?:www\.)?github\.com\//i.test(remote)) remote = `https://${remote}`;
-  let url;
-  try {
-    url = new URL(remote);
-  } catch {
-    throw new Error(`${name} must be a GitHub repository URL`);
-  }
-  if (
-    !["https:", "http:", "ssh:", "git:"].includes(url.protocol)
-    || !["github.com", "www.github.com"].includes(url.hostname.toLowerCase())
-    || (url.username && !(url.protocol === "ssh:" && url.username === "git"))
-    || url.password
-    || url.port
-    || (!allowIssueOrPull && (url.search || url.hash))
-  ) {
-    throw new Error(`${name} must be a GitHub repository URL`);
-  }
-  const segments = url.pathname.split("/").filter(Boolean);
-  if (segments.length < 2) throw new Error(`${name} must identify one GitHub repository`);
-  const suffix = segments.slice(2);
-  if (
-    (!allowIssueOrPull && suffix.length > 0)
-    || (
-      allowIssueOrPull
-      && suffix.length > 0
-      && !(suffix.length >= 2 && ["issues", "pull"].includes(suffix[0]) && /^\d+$/.test(suffix[1]))
-    )
-  ) {
-    throw new Error(`${name} must identify one GitHub repository`);
-  }
-  return {
-    owner: segments[0],
-    repository: segments[1].replace(/\.git$/i, ""),
-  };
-}
-
-export function canonicalGithubRepository(value, name = "githubRepos") {
-  const { owner, repository } = parseGithubUrl(value, name);
-  if (repository.length === 0) throw new Error(`${name} must identify one GitHub repository`);
-  return `https://github.com/${owner}/${repository}`;
-}
-
-export function normalizeGithubRepositories(
-  value,
-  name = "githubRepos",
-) {
-  if (!Array.isArray(value)) throw new Error(`${name} must be an array of GitHub repository URLs`);
-  const repositories = [];
-  const seen = new Set();
-  for (const [index, repository] of value.entries()) {
-    const canonical = canonicalGithubRepository(repository, `${name}[${index}]`);
-    const key = canonical.toLowerCase();
-    if (!seen.has(key)) {
-      seen.add(key);
-      repositories.push(canonical);
-    }
-  }
-  return repositories;
-}
-
-export function matchProjectForGithubUrl(value, projects, routingHints = []) {
-  if (!Array.isArray(projects)) throw new Error("projects must be an array");
-  if (!Array.isArray(routingHints)) throw new Error("routingHints must be an array");
-  let parsed;
-  try {
-    parsed = parseGithubUrl(value, "GitHub URL", { allowIssueOrPull: true });
-  } catch {
-    return { status: "unmatched", repository: null, projects: [] };
-  }
-  const repository = `https://github.com/${parsed.owner}/${parsed.repository}`;
-  const key = repository.toLowerCase();
-  const matches = projects.filter((project) => {
-    const learned = routingHints.find((hint) => hint?.path === project?.path)?.githubRepos ?? [];
-    return [...(Array.isArray(project?.githubRepos) ? project.githubRepos : []), ...learned]
-      .some((candidate) => {
-      try {
-        return canonicalGithubRepository(candidate).toLowerCase() === key;
-      } catch {
-        return false;
-      }
-    });
-  });
-  if (matches.length === 1) {
-    return { status: "matched", repository, project: matches[0], projects: matches };
-  }
-  return {
-    status: matches.length > 1 ? "ambiguous" : "unmatched",
-    repository,
-    projects: matches,
-  };
-}

package/src/model-roles.js

@@ -1,70 +0,0 @@
-import { execFile as execFileCallback } from 'node:child_process';
-import { readdir } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-
-const execFile = promisify(execFileCallback);
-const resolver = fileURLToPath(new URL('../scripts/roles/resolve_roles.py', import.meta.url));
-
-async function hasAgentFiles(directory) {
-  try { return (await readdir(directory)).some((name) => name.endsWith('.toml')); }
-  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
-}
-
-function missingRoles() {
-  return {
-    roles: ['orchestrator', 'planner', 'implementer', 'reviewer'].map((role) => ({
-      role, source: null, effectiveSource: null, model: null, effort: null,
-      status: 'missing', availability: 'No role files', problems: [],
-      taskOverrides: {}, subagentOverrides: {},
-      fallback: role === 'orchestrator' ? 'native new-task default' : 'inherit parent settings',
-    })),
-    problems: [], catalogSource: null, modelOptions: [],
-    precedence: 'explicit user model (and its explicit effort) > personal role > native defaults; explicit effort alone overrides role effort',
-    scope: 'Model and effort only; agent instructions, tools, permissions, and other TOML keys are not applied by this adapter.',
-  };
-}
-
-export async function resolveModelRoles({ run = execFile, env = process.env, includeCatalog = false } = {}) {
-  try {
-    const home = env.HOME || os.homedir();
-    const codexHome = (env.CODEX_HOME || path.join(home, '.codex')).replace(/^~(?=\/|$)/, home);
-    const agentsDirectory = path.join(codexHome, 'agents');
-    if (!await hasAgentFiles(agentsDirectory) && !includeCatalog) return missingRoles();
-    const { stdout } = await run('python3', [resolver], {
-      env, timeout: 5000, maxBuffer: 128 * 1024,
-    });
-    const result = JSON.parse(stdout);
-    result.roles = result.roles.map((role) => ({
-      ...role,
-      displaySource: typeof role.source === 'string'
-        ? `~/.codex/agents/${path.basename(role.source)}`
-        : role.source,
-    }));
-    return result;
-  } catch {
-    return { roles: [], problems: ['Model role preview unavailable. Python 3.11+ and readable agent configuration are required when agent files exist; configured roles have not been honored.'], catalogSource: null };
-  }
-}
-
-export async function updateModelRole(role, model, effort, { run = execFile, env = process.env } = {}) {
-  const allowedRoles = new Set(['orchestrator', 'planner', 'implementer', 'reviewer']);
-  if (!allowedRoles.has(role) || typeof model !== 'string' || typeof effort !== 'string') {
-    const error = new Error('Invalid model role update.');
-    error.code = 'invalid_request';
-    throw error;
-  }
-  try {
-    await run('python3', [resolver, '--update', '--role', role, '--model', model, '--effort', effort], {
-      env, timeout: 5000, maxBuffer: 128 * 1024,
-    });
-    return resolveModelRoles({ run, env, includeCatalog: true });
-  } catch (error) {
-    if (error.code === 'invalid_request') throw error;
-    const failure = new Error('Model role could not be saved.');
-    failure.code = 'role_update_failed';
-    throw failure;
-  }
-}

package/src/recorded-usage-tracker.js

@@ -1,92 +0,0 @@
-import { CodexSessionScanner } from "./codex-session-scanner.js";
-import { acquireWorkspaceLock } from "./workspace.js";
-import { readUsageStore, writeUsageStore } from "./usage.js";
-import { TASKCHEF_VERSION } from "./version.js";
-
-function projection(value, provenance, now, sessionCount) {
-  return {
-    inputTokens: value.tokens.input_tokens, cachedInputTokens: value.tokens.cached_input_tokens,
-    outputTokens: value.tokens.output_tokens, reasoningOutputTokens: value.tokens.reasoning_output_tokens,
-    totalTokens: value.tokens.total_tokens, partial: value.partial, costPartial: value.costPartial,
-    estimatedCostUsd: value.samples && (!value.costPartial || value.costUsd > 0) ? value.costUsd : null,
-    costStatus: value.samples && (!value.costPartial || value.costUsd > 0) ? "estimated" : "unavailable",
-    models: {}, provenance: { ...provenance, sessionCount }, sampledAt: now, sourceUpdatedAt: now,
-  };
-}
-
-export function createRecordedUsageTracker({ workspace, maxConcurrentJobs = 2, scanner = new CodexSessionScanner() }) {
-  const pending = new Map(), queue = [];
-  let active = 0, closed = false;
-  function drain() {
-    while (!closed && active < maxConcurrentJobs && queue.length) {
-      const job = queue.shift(); active++;
-      job.run().then(job.resolve, job.reject).finally(() => { active--; drain(); });
-    }
-  }
-  async function calculate(task) {
-    const ref = task.latestTurn?.turnRef;
-    const now = new Date().toISOString();
-    let result, failure;
-    try { result = await scanner.recordedUsage(task.threadId, task.latestTurn?.turnId ?? ref); }
-    catch { failure = "Saved Codex usage is unavailable. Usage requires Node.js 22.18+ and readable Codex records."; }
-    if (closed) return null;
-    const release = await acquireWorkspaceLock(workspace);
-    try {
-      const store = await readUsageStore(workspace);
-      const previous = store.tasks[task.id]?.threadId === task.threadId ? store.tasks[task.id] : null;
-      if (previous?.generationTurnCount > task.turns.length) return previous;
-      const provenance = { provider: "taskchef", version: TASKCHEF_VERSION, pricingMode: "standard" };
-      let total = result?.total.samples ? projection(result.total, provenance, now, result.subagents + 1)
-        : previous?.task ? { ...previous.task, partial: true, costPartial: true } : null;
-      // A partial scan cannot erase usage already known from older rollouts.
-      if (result?.total.partial && previous?.task && total.totalTokens < previous.task.totalTokens) {
-        total = { ...previous.task, partial: true, costPartial: true };
-      }
-      if (result?.total.costPartial && previous?.task?.estimatedCostUsd != null
-        && (total.estimatedCostUsd == null || total.estimatedCostUsd < previous.task.estimatedCostUsd)) {
-        total = { ...total, estimatedCostUsd: previous.task.estimatedCostUsd, costStatus: "estimated", costPartial: true };
-      }
-      const priorTurn = previous?.turns[ref];
-      let latest = result?.matchedTurn && result.latest.samples
-        ? { status: "available", ...projection(result.latest, provenance, now, result.subagents + 1), updatedAt: now }
-        : priorTurn?.status === "available" ? { ...priorTurn, partial: true, costPartial: true, updatedAt: now }
-        : { status: "unavailable", reason: failure || (result?.matchedTurn ? "No saved usage for this native turn." : "This dispatcher turn has no matching native Codex turn ID."), updatedAt: now };
-      if (latest.status === "available" && latest.partial && priorTurn?.status === "available" && latest.totalTokens < priorTurn.totalTokens) {
-        latest = { ...priorTurn, partial: true, costPartial: true, updatedAt: now };
-      }
-      if (latest.status === "available" && latest.costPartial && priorTurn?.estimatedCostUsd != null
-        && (latest.estimatedCostUsd == null || latest.estimatedCostUsd < priorTurn.estimatedCostUsd)) {
-        latest = { ...latest, estimatedCostUsd: priorTurn.estimatedCostUsd, costStatus: "estimated", costPartial: true };
-      }
-      const record = {
-        threadId: task.threadId, generationTurnRef: ref, generationTurnCount: task.turns.length,
-        generationTerminal: !!task.latestTurn?.result, zeroBaselineTurnRef: null,
-        status: total ? "available" : "unavailable", updatedAt: now, retryAfter: null,
-        ...(total ? {} : { reason: failure || "No saved usage records were found." }),
-        task: total, turns: { ...(previous?.turns ?? {}), [ref]: latest }, boundaries: {},
-      };
-      store.tasks[task.id] = record;
-      await writeUsageStore(workspace, store);
-      return record;
-    } finally { await release(); }
-  }
-  function get(task) {
-    if (closed) return Promise.resolve(null);
-    if (!task.threadId || !task.latestTurn) return Promise.resolve({ status: "unavailable", reason: "No linked Codex turn.", task: null, turns: {} });
-    if (task.latestTurn.provenance?.kind === "dashboard_manual") {
-      return readUsageStore(workspace).then(store => ({ ...(store.tasks[task.id] ?? { status: "unavailable", task: null }), turns: { ...(store.tasks[task.id]?.turns ?? {}), [task.latestTurn.turnRef]: { status: "unavailable", reason: "Administrative action; no Codex usage boundary." } } }));
-    }
-    const key = `${task.id}:${task.latestTurn.turnRef}`;
-    if (pending.has(key)) return pending.get(key);
-    const promise = new Promise((resolve, reject) => { queue.push({ run: () => calculate(task), resolve, reject }); drain(); });
-    pending.set(key, promise);
-    promise.finally(() => pending.delete(key)).catch(() => {});
-    return promise;
-  }
-  return {
-    get, observe: get,
-    // Historical tasks stay lazy; opening Details reads their saved logs.
-    preload: async () => {},
-    close() { closed = true; for (const job of queue.splice(0)) job.resolve(null); scanner.close(); },
-  };
-}