@posthog/wizard 2.62.0 → 2.63.0

package/dist/{agent-prompt-loader-CBj2DWAJ.js → agent-prompt-loader-DiM8xfSZ.js}

@@ -1,7 +1,7 @@
-import { s as logToFile } from "./debug-BTPYy9p7.js";
-import { n as analytics } from "./analytics-BdKBzz4M.js";
-import { f as isThinkingLevel } from "./queue-tools-zM8_mxx6.js";
-import { M as fetchWithRetry, S as WIZARD_TOOL_NAMES } from "./agent-interface-C90hyvs1.js";
+import { s as logToFile } from "./debug-BYIoy1Oz.js";
+import { n as analytics } from "./analytics-YLZKudpE.js";
+import { m as isThinkingLevel } from "./queue-tools-BtJ7_fEW.js";
+import { M as fetchWithRetry, S as WIZARD_TOOL_NAMES } from "./agent-interface-C4CV7p0L.js";
 //#region src/lib/agent/agent-prompt-loader.ts
 function projectContext(ctx) {
 	return `You have access to the PostHog MCP server and the wizard tools.
@@ -39,10 +39,17 @@ const SEED_BASICS = `You are the orchestrator. Plan the work and seed the queue
 * Tasks the wizard queued before the planner ran. It has to see them: they are
 * part of the run it is planning around, and the task that reports last has to
 * depend on them. Their ids are real, so it can wire the edge directly.
+*
+* The one-way rule matters as much as the sink edge. These tasks are deferred to
+* the end of the drain after planning (`seeded-deps.ts`) and may block on a
+* person, so a task the planner hangs off one would wait on the user too — which
+* is the interruption deferring them removed. The resolver drops such a task
+* from the seeded task's own dependencies to stay acyclic, so the damage is
+* silent; saying so here is what prevents it.
 */
 function preQueuedTasks(tasks) {
 	if (tasks.length === 0) return null;
-	return `The queue already holds these tasks, placed by the wizard from what it found in this project. Do not queue them again — plan around them, and make sure the reporting task ends up depending on each one:\n${tasks.map((t) => `- ${t.type} (id: ${t.id})`).join("\n")}`;
+	return `The queue already holds these tasks, placed by the wizard from what it found in this project. Do not queue them again. They run late — after every task you queue — and one may stop to ask the user for input, so make the reporting task depend on each one and hang nothing else off them: any other task you made depend on one would end up waiting on a person.\n${tasks.map((t) => `- ${t.type} (id: ${t.id})`).join("\n")}`;
 }
 /**
 * Points the agent at its installed task instructions (the HOW). They live under
@@ -299,4 +306,4 @@ const EMPTY_PROMPT = {};
 //#endregion
 export { assembleTaskPrompt as a, queueTools as c, taskModelSpec as d, assembleSeedPrompt as i, renderToolInventory as l, agentRunTools as n, loadAgentRegistry as o, allowsPostHogMcp as r, promptModelFor as s, ASK_TOOL as t, resolveTask as u };
 
-//# sourceMappingURL=agent-prompt-loader-CBj2DWAJ.js.map
+//# sourceMappingURL=agent-prompt-loader-DiM8xfSZ.js.map

package/dist/agent-prompt-loader-DiM8xfSZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-prompt-loader-DiM8xfSZ.js","names":[],"sources":["../src/lib/agent/agent-prompt-loader.ts"],"sourcesContent":["/**\n * Agent-prompt loader + registry.\n *\n * Agent prompts are the WHAT of a task: a markdown file per type, served from\n * context-mill as the `agents` content type (parallel to skills). The frontmatter\n * carries the artifacts the executor needs — model, the mini-skills to load (the\n * HOW), the tools the task may use, and its dependencies — and the body is the\n * instruction the agent reads.\n *\n * The registry is fetched once at startup and scoped to one flow — agents\n * declare `flow` and (for the planner) `seed: true` in frontmatter, so each\n * program (integration, audit, migration, ...) ships its own agent set and the\n * loader stays generic. Every prompt is downloaded and parsed up front, so\n * resolving a task to its run config is synchronous and adds no mid-drain\n * network latency. The registry's type list also drives `enqueue_task`\n * validation.\n */\nimport type {\n  QueueStore,\n  QueuedTask,\n} from './runner/sequence/orchestrator/queue';\nimport type { ResolvedTask } from './runner/sequence/orchestrator/executor';\nimport type { HostResolution } from '@lib/host-resolution';\nimport {\n  isThinkingLevel,\n  type ThinkingLevel,\n} from './runner/switchboard/models';\nimport { logToFile } from '@utils/debug';\nimport { analytics } from '@utils/analytics';\nimport { fetchWithRetry } from '@lib/fetch-retry';\nimport { WIZARD_TOOL_NAMES } from '@lib/wizard-tools/tools';\n\n/**\n * The basics the client injects around every agent-prompt body. The `/agents/`\n * files carry intent only (goal, success criteria); the wizard owns the I/O\n * contract — who the agent is, how it reports, how it surfaces progress — so the\n * authored prompts never restate it.\n */\nexport interface OrchestratorPromptContext {\n  projectId: number;\n  projectApiKey: string;\n  host: HostResolution;\n  /** Path to the framework's reference implementation (EXAMPLE.md), if available. */\n  examplePath?: string;\n  /** Path to the framework's rules (COMMANDMENTS.md), if available. */\n  commandmentsPath?: string;\n}\n\nfunction projectContext(ctx: OrchestratorPromptContext): string {\n  return `You have access to the PostHog MCP server and the wizard tools.\n\nProject context:\n- PostHog Project ID: ${ctx.projectId}\n- PostHog public token: ${ctx.projectApiKey}\n- PostHog Host: ${ctx.host.apiHost}`;\n}\n\n/** Points the agent at the framework's reference integration to learn patterns from. */\nfunction exampleReference(ctx: OrchestratorPromptContext): string | null {\n  if (!ctx.examplePath) return null;\n  return `A reference PostHog integration for this framework is at \\`${ctx.examplePath}\\`. It shows the target implementation pattern. Reference its patterns and conventions, adapting them to this codebase.`;\n}\n\n/** The framework's rules ship with the reference skill; every task follows them. */\nfunction commandmentsReference(ctx: OrchestratorPromptContext): string | null {\n  if (!ctx.commandmentsPath) return null;\n  return `Framework rules for this integration are at \\`${ctx.commandmentsPath}\\`. Read them before you edit and follow them.`;\n}\n\n/**\n * The task's own tool list, injected so an agent never has to discover a tool's\n * absence by trying it — and never reports that absence as a finding. Later\n * tasks hold tools this one does not, so work it cannot do is handed on rather\n * than attempted.\n */\n/** Renders the inventory from the tool names a harness actually registered for\n *  the run — the one complete list, in the vocabulary the agent will call. */\nexport function renderToolInventory(toolNames: readonly string[]): string {\n  if (toolNames.length === 0) return '';\n  return `Your tools for this task: ${toolNames.join(\n    ', ',\n  )}. Do not look for a tool that is not listed or treat its absence as a problem to report. Later tasks in this run hold tools you do not: when your task needs one, hand that work off in your handoff for the task that can do it, or note it for the final report.`;\n}\n\nconst TASK_BASICS = `You are one step in a larger PostHog workflow made of several tasks, run as a fresh agent with no memory of the other tasks beyond the context you are given. Other tasks — before and after you — own the rest of the work, so stay strictly on your own task: do not do a neighbouring step's job, redo what an upstream handoff already did, or reach beyond what you were asked. Do only your task, then report exactly once by calling complete_task with a structured handoff: what your goal was, what you did, and what the next agent should know. When you are given context from previous steps, trust it — those agents already did their work, so do not re-verify or re-read what their handoffs tell you. Build on it and move fast. Read a file before you edit it, so your own changes do not duplicate what is already there. Work only inside this project's own directory: never read, list, or search (find, ls, grep, glob) outside it — not the OS, not other projects, not global package caches. If your task seems to need something outside this directory, it does not — skip that part and say so in your handoff rather than hunting across the filesystem. If your task does not apply to this project — there is genuinely nothing for it to do — report it with status \\`not needed\\` and say why, rather than marking it done.`;\n\nconst SEED_BASICS = `You are the orchestrator. Plan the work and seed the queue with enqueue_task — each call returns an id you can pass as a dependency to a later task. Give each task a short label for the UI — the action in a few words, not file names, class names, or other specifics. The last task you queue, the one that reports on the run, must depend on every other task in the queue — directly, or through a task it already depends on. You are not a task yourself: do not call complete_task and do not edit the project.`;\n\n/**\n * Tasks the wizard queued before the planner ran. It has to see them: they are\n * part of the run it is planning around, and the task that reports last has to\n * depend on them. Their ids are real, so it can wire the edge directly.\n *\n * The one-way rule matters as much as the sink edge. These tasks are deferred to\n * the end of the drain after planning (`seeded-deps.ts`) and may block on a\n * person, so a task the planner hangs off one would wait on the user too — which\n * is the interruption deferring them removed. The resolver drops such a task\n * from the seeded task's own dependencies to stay acyclic, so the damage is\n * silent; saying so here is what prevents it.\n */\nfunction preQueuedTasks(\n  tasks: readonly { id: string; type: string }[],\n): string | null {\n  if (tasks.length === 0) return null;\n  const lines = tasks.map((t) => `- ${t.type} (id: ${t.id})`);\n  return `The queue already holds these tasks, placed by the wizard from what it found in this project. Do not queue them again. They run late — after every task you queue — and one may stop to ask the user for input, so make the reporting task depend on each one and hang nothing else off them: any other task you made depend on one would end up waiting on a person.\\n${lines.join(\n    '\\n',\n  )}`;\n}\n\n/**\n * Points the agent at its installed task instructions (the HOW). They live under\n * the wizard's run dir, not `.claude/skills/`, so the SDK does not auto-load\n * them — the prompt has to name them.\n */\nfunction skillReference(paths: readonly string[]): string | null {\n  if (paths.length === 0) return null;\n  const list = paths.map((p) => `\\`${p}\\``).join(', ');\n  return `Your task instructions are at ${list}. Read them before you start and follow them. They are wizard scaffolding, not part of the project.`;\n}\n\n/** A task agent's full prompt: injected basics, then the authored intent. */\nexport function assembleTaskPrompt(\n  ctx: OrchestratorPromptContext,\n  body: string,\n  skillPaths: readonly string[] = [],\n): string {\n  return [\n    projectContext(ctx),\n    exampleReference(ctx),\n    commandmentsReference(ctx),\n    skillReference(skillPaths),\n    TASK_BASICS,\n    body,\n  ]\n    .filter(Boolean)\n    .join('\\n\\n');\n}\n\n/** The seed agent's full prompt: injected basics, then the authored intent. */\nexport function assembleSeedPrompt(\n  ctx: OrchestratorPromptContext,\n  body: string,\n  preQueued: readonly { id: string; type: string }[] = [],\n): string {\n  return [projectContext(ctx), SEED_BASICS, preQueuedTasks(preQueued), body]\n    .filter(Boolean)\n    .join('\\n\\n');\n}\n\n/** Orchestrator tools are MCP tools under the `posthog-wizard` server. Frontmatter\n *  names them short (e.g. `enqueue_task`); the SDK gates on the full name. */\nconst ORCHESTRATOR_TOOL_PREFIX = 'mcp__posthog-wizard__';\nconst ORCHESTRATOR_TOOLS = new Set([\n  'enqueue_task',\n  'complete_task',\n  'read_handoffs',\n]);\n\n/** The one tool that stops a task until a person answers. Named short in frontmatter. */\nexport const ASK_TOOL = 'wizard_ask';\n\n/**\n * The PostHog MCP, as an agent asks for it in frontmatter. Every tool a task\n * gets is granted by its own prompt, this one included: a task that never names\n * it never has the server wired in, and one that does gets it under this name\n * on both harnesses.\n */\nexport const POSTHOG_MCP_TOOL = 'posthog_exec';\n/** The same tool as the anthropic SDK names it, on the hosted PostHog server. */\nconst POSTHOG_MCP_SDK_TOOL = 'mcp__posthog-wizard__exec';\n\n/** Whether a task asked for the PostHog MCP — accepts either spelling. */\nexport function allowsPostHogMcp(\n  allowedTools: readonly string[] | undefined,\n): boolean {\n  return (allowedTools ?? []).some(\n    (name) => name === POSTHOG_MCP_TOOL || name === POSTHOG_MCP_SDK_TOOL,\n  );\n}\n\n/** The queue tools a task holds — all of them minus its disallows. Short names.\n *  Single source for both the injected inventory and the harness's tool grant. */\nexport function queueTools(disallowedTools: readonly string[]): string[] {\n  const disallowed = new Set(\n    disallowedTools.map((n) => n.replace(ORCHESTRATOR_TOOL_PREFIX, '')),\n  );\n  return [...ORCHESTRATOR_TOOLS].filter((t) => !disallowed.has(t));\n}\n\n/** A parsed agent prompt. The frontmatter fields plus the markdown body. */\nexport interface AgentPrompt {\n  type: string;\n  /** Human-readable title for the TUI; falls back to `type` when absent. */\n  label?: string;\n  /** The flow this agent belongs to (the program id, e.g. \\`posthog-integration\\`). */\n  flow?: string;\n  /** Marks the flow's planner: it seeds the queue and is not an enqueueable task. */\n  seed: boolean;\n  /** Marks a task that runs last: it must depend on every other task in the queue. */\n  sink: boolean;\n  /**\n   * Marks a task only the wizard may queue. The planner never sees the type, so\n   * whether it runs is a decision the client makes from what it detected, not\n   * one an agent can reach — it can neither invent the task nor forget it.\n   */\n  runnerSeeded: boolean;\n  /** Per-profile model + effort. `pi` = the gpt/pi harness, `sdk` = the anthropic\n   * harness. The mapping is not 1:1 across providers, so each agent names both. */\n  modelPi?: string;\n  effortPi?: ThinkingLevel;\n  modelSdk?: string;\n  effortSdk?: ThinkingLevel;\n  skills: string[];\n  allowedTools: string[];\n  disallowedTools: string[];\n  /**\n   * Task types this one runs after. Read differently by the two kinds of task:\n   *\n   * - **Enqueueable types**: advisory. The planner authors the real graph with\n   *   `enqueue_task`, passing ids, and its seed prompt describes the shape it\n   *   should build. Nothing resolves this field for them.\n   * - **`runnerSeeded` types**: authoritative. Such a task is queued before the\n   *   planner runs, so it cannot name ids; the runner resolves these types to\n   *   the ids the planner produced and applies them (see `seeded-deps.ts`).\n   *   Empty means \"after everything that is not the sink\".\n   */\n  dependsOn: string[];\n  body: string;\n}\n\n/** The model + effort an agent runs on for a given harness — `pi` picks the gpt\n * column, anything else the sdk (anthropic) column. */\nexport function promptModelFor(\n  prompt: AgentPrompt,\n  harness: string,\n): { model?: string; effort?: ThinkingLevel } {\n  const pi = harness === 'pi';\n  return {\n    model: pi ? prompt.modelPi : prompt.modelSdk,\n    effort: pi ? prompt.effortPi : prompt.effortSdk,\n  };\n}\n\nexport interface AgentRegistry {\n  /** The flow's task types — every prompt except the seed. */\n  readonly types: string[];\n  /** The types an agent may enqueue: `types` minus the runner-seeded ones. */\n  readonly enqueueableTypes: string[];\n  /** The types that run last and must depend on the whole queue. */\n  readonly sinkTypes: string[];\n  /** The types only the wizard queues, from what it detected before the run. */\n  readonly runnerSeededTypes: string[];\n  /** The flow's planner, the one prompt marked `seed: true` in its frontmatter. */\n  readonly seed?: AgentPrompt;\n  get(type: string): AgentPrompt | undefined;\n}\n\n/** The registry for one flow's prompts. Pure; the loader feeds it the fetched set. */\nexport function buildRegistry(\n  prompts: readonly AgentPrompt[],\n  flow: string,\n  opts?: {\n    exclude?: readonly string[];\n    /** Per-stage pi model/effort overlays, keyed by task type ('seed' for the planner). Applied here — the one place prompts enter the wizard — so every downstream read sees the effective spec. */\n    overrides?: Record<\n      string,\n      { model?: string; effort?: ThinkingLevel } | undefined\n    >;\n  },\n): AgentRegistry {\n  // The harness can exclude task types (CI excludes dashboards). An excluded\n  // type does not exist for the run: the seed cannot enqueue it and no agent\n  // is ever spun up for it.\n  const excluded = new Set(opts?.exclude ?? []);\n  const inFlow = prompts\n    .filter((p) => p.flow === flow && !excluded.has(p.type))\n    .map((p) => {\n      const o = opts?.overrides?.[p.seed ? 'seed' : p.type];\n      if (!o) return p;\n      return {\n        ...p,\n        modelPi: o.model ?? p.modelPi,\n        effortPi: o.effort ?? p.effortPi,\n      };\n    });\n  const byType = new Map(inFlow.map((p) => [p.type, p]));\n  const tasks = inFlow.filter((p) => !p.seed);\n  return {\n    types: tasks.map((p) => p.type),\n    enqueueableTypes: tasks.filter((p) => !p.runnerSeeded).map((p) => p.type),\n    sinkTypes: tasks.filter((p) => p.sink).map((p) => p.type),\n    runnerSeededTypes: tasks.filter((p) => p.runnerSeeded).map((p) => p.type),\n    seed: inFlow.find((p) => p.seed),\n    get: (type) => byType.get(type),\n  };\n}\n\ninterface AgentMenu {\n  /** `flow` arrived with context-mill's flow-scoped agents folder; older menus omit it. */\n  agents: { id: string; flow?: string; downloadUrl: string }[];\n}\n\n/** A native tool passes through; an MCP tool gets its fully-qualified name. */\nfunction expandToolName(name: string): string {\n  if (name === ASK_TOOL) return WIZARD_TOOL_NAMES.wizardAsk;\n  if (name === POSTHOG_MCP_TOOL) return POSTHOG_MCP_SDK_TOOL;\n  return ORCHESTRATOR_TOOLS.has(name)\n    ? `${ORCHESTRATOR_TOOL_PREFIX}${name}`\n    : name;\n}\n\n/** A prompt's allow/disallow lists with orchestrator tool names MCP-qualified. */\nexport function agentRunTools(prompt: AgentPrompt): {\n  allowedTools: string[];\n  disallowedTools: string[];\n} {\n  return {\n    allowedTools: prompt.allowedTools.map(expandToolName),\n    disallowedTools: prompt.disallowedTools.map(expandToolName),\n  };\n}\n\nfunction toStringArray(value: unknown): string[] {\n  if (!Array.isArray(value)) return [];\n  return value.filter((v): v is string => typeof v === 'string');\n}\n\n/**\n * Parse the leading `---` frontmatter block and the markdown body. The\n * frontmatter is a small, known schema (scalars and inline `[a, b]` arrays), so\n * a tiny parser covers it without a YAML dependency. Inline `# comments` after a\n * value are stripped. `fallbackType` (the menu id) and `fallbackFlow` (the\n * menu entry's flow) apply when the frontmatter omits `type:`/`flow:`.\n */\nexport function parseAgentPrompt(\n  text: string,\n  fallbackType: string,\n  fallbackFlow?: string,\n): AgentPrompt {\n  const match = text.match(/^---\\r?\\n([\\s\\S]*?)\\r?\\n---\\r?\\n?([\\s\\S]*)$/);\n  const frontmatter = match ? match[1] : '';\n  const body = (match ? match[2] : text).trim();\n\n  const fields: Record<string, unknown> = {};\n  for (const rawLine of frontmatter.split(/\\r?\\n/)) {\n    const line = rawLine.replace(/\\s+#.*$/, '').trim();\n    if (!line || line.startsWith('#')) continue;\n    const kv = line.match(/^([\\w-]+):\\s*(.*)$/);\n    if (!kv) continue;\n    const [, key, raw] = kv;\n    if (raw.startsWith('[') && raw.endsWith(']')) {\n      fields[key] = raw\n        .slice(1, -1)\n        .split(',')\n        .map((s) => s.trim().replace(/^['\"]|['\"]$/g, ''))\n        .filter(Boolean);\n    } else {\n      fields[key] = raw.replace(/^['\"]|['\"]$/g, '');\n    }\n  }\n\n  const str = (v: unknown) => (typeof v === 'string' ? v : undefined);\n  // Effort is remote data — reject typos here so downstream carries ThinkingLevel.\n  const effort = (v: unknown, key: string): ThinkingLevel | undefined => {\n    if (v === undefined) return undefined;\n    if (isThinkingLevel(v)) return v;\n    logToFile(\n      `[agent-prompt] ${fallbackType}: ignoring invalid ${key} \"${String(v)}\"`,\n    );\n    analytics.wizardCapture('agent prompt invalid effort', {\n      task_type: fallbackType,\n      key,\n      value: String(v),\n    });\n    return undefined;\n  };\n  return {\n    type: typeof fields.type === 'string' ? fields.type : fallbackType,\n    label: typeof fields.label === 'string' ? fields.label : undefined,\n    flow: typeof fields.flow === 'string' ? fields.flow : fallbackFlow,\n    seed: fields.seed === 'true',\n    sink: fields.sink === 'true',\n    runnerSeeded: fields.runnerSeeded === 'true',\n    modelPi: str(fields.model_pi),\n    effortPi: effort(fields.effort_pi, 'effort_pi'),\n    modelSdk: str(fields.model_sdk),\n    effortSdk: effort(fields.effort_sdk, 'effort_sdk'),\n    skills: toStringArray(fields.skills),\n    allowedTools: toStringArray(fields.allowedTools),\n    disallowedTools: toStringArray(fields.disallowedTools),\n    dependsOn: toStringArray(fields.dependsOn),\n    body,\n  };\n}\n\nasync function fetchText(url: string): Promise<string> {\n  const res = await fetchWithRetry(url);\n  return res.text();\n}\n\n/**\n * Fetch the agent menu and every agent prompt it lists, parse them, and build\n * the registry for one flow. Throws if the menu cannot be fetched — the\n * orchestrator cannot run without its prompts.\n */\nexport async function loadAgentRegistry(\n  skillsBaseUrl: string,\n  flow: string,\n  opts?: Parameters<typeof buildRegistry>[2],\n): Promise<AgentRegistry> {\n  const menuRaw = await fetchText(`${skillsBaseUrl}/agent-menu.json`);\n  const menu = JSON.parse(menuRaw) as AgentMenu;\n\n  // Menus that carry a flow per entry let us skip other flows' prompts before\n  // fetching them; entries without one are fetched and filtered by their\n  // frontmatter in buildRegistry, as before.\n  const entries = (menu.agents ?? []).filter(\n    (entry) => !entry.flow || entry.flow === flow,\n  );\n  const prompts = await Promise.all(\n    entries.map(async (entry) => {\n      const text = await fetchText(entry.downloadUrl);\n      return parseAgentPrompt(text, entry.id, entry.flow);\n    }),\n  );\n\n  return buildRegistry(prompts, flow, opts);\n}\n\n/**\n * Render a task's own inputs into a section, so a fanned-out task (e.g. one\n * `capture` per event) sees the specific thing it owns. Empty when there are none.\n */\nfunction renderInputs(task: QueuedTask): string {\n  const entries = Object.entries(task.inputs ?? {});\n  if (entries.length === 0) return '';\n  const lines = entries.map(([k, v]) => `- ${k}: ${formatInputValue(v)}`);\n  return `## Your task input\\n\\n${lines.join('\\n')}`;\n}\n\nfunction formatInputValue(value: unknown): string {\n  if (typeof value === 'string') return value;\n  return JSON.stringify(value);\n}\n\n/**\n * The ids of every task `task` transitively depends on — the full upstream\n * chain, not just direct dependencies — ordered roots-first, each once. A `seen`\n * set dedupes diamonds and guards against cycles.\n */\nfunction ancestorIds(task: QueuedTask, store: QueueStore): string[] {\n  const seen = new Set<string>();\n  const ordered: string[] = [];\n  const visit = (id: string): void => {\n    if (seen.has(id)) return;\n    seen.add(id);\n    const t = store.get(id);\n    if (!t) return;\n    for (const dep of t.dependsOn) visit(dep); // ancestors before dependents\n    ordered.push(id);\n  };\n  for (const dep of task.dependsOn) visit(dep);\n  return ordered;\n}\n\n/**\n * Render the handoffs of every step `task` transitively depends on into a context\n * section, so a fresh agent sees the whole upstream chain — not just its direct\n * dependencies. Reliability over token economy: a step must never have to\n * re-discover what any ancestor already established just because an intermediate\n * handoff happened to omit it. Empty when there are no completed ancestors.\n */\nfunction renderHandoffContext(task: QueuedTask, store: QueueStore): string {\n  const lines: string[] = [];\n  for (const id of ancestorIds(task, store)) {\n    const dep = store.get(id);\n    const handoff = store.readHandoff(id);\n    if (!dep || !handoff) continue;\n    lines.push(`### ${dep.type}`);\n    lines.push(`- did: ${handoff.did}`);\n    lines.push(`- for you: ${handoff.forNextAgent}`);\n    if (handoff.filesTouched?.length) {\n      lines.push(`- files: ${handoff.filesTouched.join(', ')}`);\n    }\n    if (handoff.evidence) {\n      lines.push(`- evidence: ${handoff.evidence}`);\n    }\n    if (handoff.assumptions) {\n      lines.push(`- assumed: ${handoff.assumptions}`);\n    }\n    if (handoff.reportSection) {\n      lines.push(`- report section:\\n${handoff.reportSection}`);\n    }\n    lines.push('');\n  }\n  if (lines.length === 0) return '';\n  return `## Context from previous steps\\n\\n${lines.join('\\n')}`.trim();\n}\n\n/**\n * Resolve a queued task to its run config: the prompt body (with upstream\n * handoffs appended), the model, and the tool lists with orchestrator tool names\n * MCP-qualified. The model precedence is enqueue override, then prompt, then\n * default. Throws if no prompt is registered for the task's type.\n */\nexport function resolveTask(\n  registry: AgentRegistry,\n  task: QueuedTask,\n  store: QueueStore,\n): ResolvedTask {\n  const prompt = registry.get(task.type);\n  if (!prompt) {\n    throw new Error(`No agent prompt registered for task type \"${task.type}\"`);\n  }\n\n  const body = [\n    renderInputs(task),\n    prompt.body,\n    renderHandoffContext(task, store),\n  ]\n    .filter(Boolean)\n    .join('\\n\\n');\n\n  return {\n    ...agentRunTools(prompt),\n    prompt: body,\n    skills: prompt.skills,\n  };\n}\n\n/** The model + effort a task runs on for a harness: enqueue override, then the\n * prompt's per-profile frontmatter; the caller's switchboard pick is the fallback. */\nexport function taskModelSpec(\n  registry: AgentRegistry,\n  task: QueuedTask,\n  harness: string,\n): { model?: string; effort?: ThinkingLevel } {\n  const picked = promptModelFor(\n    registry.get(task.type) ?? EMPTY_PROMPT,\n    harness,\n  );\n  return {\n    model: task.model ?? picked.model,\n    effort: picked.effort,\n  };\n}\n\nconst EMPTY_PROMPT = {} as AgentPrompt;\n"],"mappings":"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"}

package/dist/{agent-runner-DA5YfjOD.js → agent-runner-X3JWS2WK.js}

@@ -1,17 +1,17 @@
 import { t as __exportAll } from "./rolldown-runtime-B_-DWIq7.js";
-import { A as GPT5_6_LUNA_MODEL, D as DEFAULT_AGENT_MODEL, F as Harness, M as GPT5_6_TERRA_MODEL, _ as evaluateWizardReadiness, a as getLogFilePath, c as WIZARD_BENCHMARK_FILE, ct as WIZARD_ORCHESTRATOR_OVERRIDE_FLAG_KEY, et as SONNET_5_MODEL, f as getUI, ft as WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY, g as SIGNUP_WIZARD_READINESS_CONFIG, h as SERVICE_LABELS, i as enableDebugLogs, j as GPT5_6_SOL_MODEL, l as WIZARD_LOG_FILE, lt as WIZARD_ORCHESTRATOR_SEEDED_TASKS_FLAG_KEY, mt as getSkillsBaseUrl, o as initLogFile, rt as WIZARD_CONTACT_EMAIL, s as logToFile, st as WIZARD_ORCHESTRATOR_FLAG_KEY, t as configureLogFile, tt as Sequence, v as getBlockingServiceKeys, vt as RUN_SURFACE, xt as runtimeEnv } from "./debug-BTPYy9p7.js";
-import { a as ciExcludedTaskTypes, n as analytics, r as groupsFromUser } from "./analytics-BdKBzz4M.js";
-import { t as getOrAskForProjectData } from "./setup-utils-iINkc0xu.js";
+import { A as GPT5_6_LUNA_MODEL, D as DEFAULT_AGENT_MODEL, F as Harness, M as GPT5_6_TERRA_MODEL, _ as evaluateWizardReadiness, a as getLogFilePath, c as WIZARD_BENCHMARK_FILE, ct as WIZARD_ORCHESTRATOR_OVERRIDE_FLAG_KEY, et as SONNET_5_MODEL, f as getUI, ft as WIZARD_SELF_DRIVING_USE_PI_HARNESS_FLAG_KEY, g as SIGNUP_WIZARD_READINESS_CONFIG, h as SERVICE_LABELS, i as enableDebugLogs, j as GPT5_6_SOL_MODEL, l as WIZARD_LOG_FILE, lt as WIZARD_ORCHESTRATOR_SEEDED_TASKS_FLAG_KEY, mt as getSkillsBaseUrl, o as initLogFile, rt as WIZARD_CONTACT_EMAIL, s as logToFile, st as WIZARD_ORCHESTRATOR_FLAG_KEY, t as configureLogFile, tt as Sequence, v as getBlockingServiceKeys, vt as RUN_SURFACE, xt as runtimeEnv } from "./debug-BYIoy1Oz.js";
+import { a as ciExcludedTaskTypes, n as analytics, r as groupsFromUser } from "./analytics-YLZKudpE.js";
+import { t as getOrAskForProjectData } from "./setup-utils-e78zkZoW.js";
 import "./wizard-session-BUhlJ1b8.js";
-import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-CztG5WTv.js";
-import { n as isNonInteractiveEnvironment } from "./environment-lV2X1gS-.js";
-import { c as QueueStore, h as requireKnownModel, l as TaskStatus, o as uncoveredBySink, p as isValidModel, s as QUEUE_DIR_NAME } from "./queue-tools-zM8_mxx6.js";
-import { E as installSkillById, F as createTriageLLMProvider, N as createWizardAskBridge, T as fetchSkillMenu, c as classifySettingsConflicts, i as runAgent$1, n as buildRunTags, o as backupAndFixClaudeSettings, p as AgentSignals, r as initializeAgent, s as checkAllSettingsConflicts, u as restoreClaudeSettings } from "./agent-interface-C90hyvs1.js";
-import { a as flushScanReport, m as writeScanReport, o as formatScanReport, s as formatYaraAbortMessage } from "./yara-hooks-DeLjTIiJ.js";
-import { a as piBackend, s as createAioCapture } from "./pi-CVJB0Ban.js";
-import { r as detectNodePackageManagers } from "./package-manager-z33XHEWO.js";
-import { t as FRAMEWORK_REGISTRY } from "./registry-DF_aKyS0.js";
-import { a as assembleTaskPrompt, d as taskModelSpec, i as assembleSeedPrompt, n as agentRunTools, o as loadAgentRegistry, s as promptModelFor, t as ASK_TOOL, u as resolveTask } from "./agent-prompt-loader-CBj2DWAJ.js";
+import { i as wizardAbort, n as registerCleanup, t as WizardError } from "./wizard-abort-DRscjUOg.js";
+import { n as isNonInteractiveEnvironment } from "./environment-Br-oy8cq.js";
+import { _ as requireKnownModel, c as uncoveredBySink, d as TaskStatus, h as isValidModel, l as QUEUE_DIR_NAME, s as dependencyClosure, u as QueueStore } from "./queue-tools-BtJ7_fEW.js";
+import { E as installSkillById, F as createTriageLLMProvider, N as createWizardAskBridge, T as fetchSkillMenu, c as classifySettingsConflicts, i as runAgent$1, n as buildRunTags, o as backupAndFixClaudeSettings, p as AgentSignals, r as initializeAgent, s as checkAllSettingsConflicts, u as restoreClaudeSettings } from "./agent-interface-C4CV7p0L.js";
+import { a as flushScanReport, m as writeScanReport, o as formatScanReport, s as formatYaraAbortMessage } from "./yara-hooks-DKRsn0lN.js";
+import { a as piBackend, s as createAioCapture } from "./pi-DeF8mWlb.js";
+import { r as detectNodePackageManagers } from "./package-manager-FyJmIsqr.js";
+import { t as FRAMEWORK_REGISTRY } from "./registry-B-whj8SQ.js";
+import { a as assembleTaskPrompt, d as taskModelSpec, i as assembleSeedPrompt, n as agentRunTools, o as loadAgentRegistry, s as promptModelFor, t as ASK_TOOL, u as resolveTask } from "./agent-prompt-loader-DiM8xfSZ.js";
 import fs, { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
 import * as path$1 from "path";
 import path from "path";
@@ -21,7 +21,7 @@ import { randomUUID } from "crypto";
 async function authenticate(session, programId) {
 	if (session.credentials) return;
 	logToFile("[agent-runner] starting OAuth");
-	const { projectApiKey, host, accessToken, projectId, roleAtOrganization, user, project } = await getOrAskForProjectData({
+	const { projectApiKey, host, accessToken, projectId, roleAtOrganization, user, project, missingScopes } = await getOrAskForProjectData({
 		signup: session.signup,
 		ci: session.ci,
 		apiKey: session.apiKey,
@@ -36,7 +36,8 @@ async function authenticate(session, programId) {
 		accessToken,
 		projectApiKey,
 		host,
-		projectId
+		projectId,
+		missingScopes
 	};
 	session.apiProject = project;
 	session.roleAtOrganization = roleAtOrganization;
@@ -105,6 +106,7 @@ const anthropicBackend = {
 			additionalFeatureQueue: config.additionalFeatureQueue ?? [],
 			abortCases: config.abortCases,
 			emitStepEvents: config.trackStepProgress ?? false,
+			resolveStepKey: config.resolveStepKey,
 			triageProvider: boot.triageProvider
 		}, middleware);
 	},
@@ -1614,6 +1616,7 @@ var RunMetrics = class {
 	firstStartMs;
 	lastStartMs;
 	firstCompleteMs;
+	firstAskMs;
 	lastVisibleMs;
 	maxGapMs = 0;
 	constructor(runStartMs) {
@@ -1640,6 +1643,14 @@ var RunMetrics = class {
 		this.markVisible(nowMs);
 	}
 	/**
+	* A question was put to the user. Only the first matters here, and it is not a
+	* queue transition — waiting on a person is not the silence `max_gap_ms`
+	* measures, so this deliberately does not mark visible progress.
+	*/
+	recordAsk(nowMs) {
+		this.firstAskMs ??= nowMs;
+	}
+	/**
 	* The run-level responsiveness summary. Timings are `undefined` when the
 	* relevant transition never happened (e.g. a run that started no task), so a
 	* no-task run stays distinguishable from a genuine zero.
@@ -1648,7 +1659,8 @@ var RunMetrics = class {
 		return {
 			time_to_first_task_ms: this.firstStartMs === void 0 ? void 0 : this.firstStartMs - this.runStartMs,
 			time_to_first_completion_ms: this.firstCompleteMs === void 0 ? void 0 : this.firstCompleteMs - this.runStartMs,
-			max_gap_ms: this.lastVisibleMs === void 0 ? void 0 : this.maxGapMs
+			max_gap_ms: this.lastVisibleMs === void 0 ? void 0 : this.maxGapMs,
+			time_to_first_ask_ms: this.firstAskMs === void 0 ? void 0 : this.firstAskMs - this.runStartMs
 		};
 	}
 	/** requeue is not user-visible, so a retry stall counts as silence here. */
@@ -1658,6 +1670,72 @@ var RunMetrics = class {
 	}
 };
 //#endregion
+//#region src/lib/agent/runner/sequence/orchestrator/seeded-deps.ts
+/**
+* Resolve a runner-seeded task's dependencies against the planned queue.
+*
+* Two exclusions apply to both the declared and the default path:
+*
+* - **Sinks are never dependencies.** A sink runs last and must depend on the
+*   whole queue, this task included. Depending on it back would invert the edge
+*   and cost the report this task's `reportSection`. Leaving sinks out means a
+*   planner that forgot the sink→seeded edge is still caught by the sink
+*   invariant check rather than silently papered over here.
+* - **Anything already downstream of this task is never a dependency**, which is
+*   what makes the result cycle-free by construction rather than by the queue's
+*   per-edge refusal.
+*/
+function seededDependencies(store, seededTaskId, declaredTypes, sinkTypes) {
+	const eligible = store.list().filter((task) => {
+		if (task.id === seededTaskId) return false;
+		if (sinkTypes.includes(task.type)) return false;
+		return !dependencyClosure(store, [task.id]).has(seededTaskId);
+	});
+	if (declaredTypes.length === 0) return {
+		depIds: eligible.map((t) => t.id),
+		unresolvedTypes: [],
+		declared: false
+	};
+	const depIds = [];
+	const unresolvedTypes = [];
+	for (const type of declaredTypes) {
+		if (!store.list().some((t) => t.type === type)) {
+			unresolvedTypes.push(type);
+			continue;
+		}
+		for (const task of eligible) if (task.type === type && !depIds.includes(task.id)) depIds.push(task.id);
+	}
+	return {
+		depIds,
+		unresolvedTypes,
+		declared: true
+	};
+}
+/**
+* Give every runner-seeded task the dependencies it could not name at enqueue,
+* and report what happened per task.
+*
+* The runner calls this once, after the planner has seeded the queue and before
+* the sink invariant is checked. Kept here rather than inline in the runner so
+* the wiring — which prompt's types feed which task — is testable without
+* standing up a whole run.
+*/
+function deferSeededTasks(store, seededTasks, declaredTypesFor, sinkTypes) {
+	return seededTasks.map((seeded) => {
+		const declaredTypes = [...declaredTypesFor(seeded.type)];
+		const resolved = seededDependencies(store, seeded.id, declaredTypes, sinkTypes);
+		const { added, refused } = store.addDependencies(seeded.id, resolved.depIds);
+		return {
+			type: seeded.type,
+			declaredTypes,
+			declared: resolved.declared,
+			added,
+			refused,
+			unresolvedTypes: resolved.unresolvedTypes
+		};
+	});
+}
+//#endregion
 //#region src/lib/agent/runner/sequence/orchestrator/orchestrator-runner.ts
 /**
 * Experimental task-queue orchestrator runner.
@@ -1747,6 +1825,43 @@ function resolveReferenceSkillId(entries, framework) {
 * — the executor holds the task's promise — so the only real limit is this one.
 */
 const TASK_ASK_TIMEOUT_MS = 1200 * 1e3;
+/**
+* How long an optional step's notice waits for an answer.
+*
+* Much shorter than the ask timeout above, because it is asking for something
+* much smaller: one keypress to accept or decline, not "go mint a restricted
+* Stripe key". The notice is also the only interactive screen sitting in front
+* of the run's final steps, so an unanswered one holds the report — and with it
+* the notebook and the outro — behind a modal nobody is looking at.
+*/
+const TASK_NOTICE_TIMEOUT_MS = 300 * 1e3;
+/**
+* Offer an optional step, defaulting to declining it if nobody answers.
+*
+* Skip is the right default on a timeout: continuing would send the step on to
+* ask for credentials that the same absent user cannot supply either, burning
+* {@link TASK_ASK_TIMEOUT_MS} per question before falling back to the same
+* links declining gives immediately.
+*/
+async function offerSeededTask(notice, timeoutMs = TASK_NOTICE_TIMEOUT_MS) {
+	let timer;
+	let timedOut = false;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => {
+			timedOut = true;
+			getUI().cancelTaskNotice();
+			resolve(false);
+		}, timeoutMs);
+	});
+	try {
+		return {
+			keep: await Promise.race([getUI().showTaskNotice(notice), timeout]),
+			timedOut
+		};
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
 /** Whether a task's prompt lets it ask the user, and so needs the ask bridge. */
 function canAsk(prompt) {
 	return (prompt?.allowedTools ?? []).includes(ASK_TOOL);
@@ -1789,7 +1904,7 @@ function displayOrder(tasks, isOptional) {
 		index
 	})).sort((a, b) => a.depth - b.depth || a.optional - b.optional || a.index - b.index).map((entry) => entry.task);
 }
-async function runOrchestrator(session, programConfig, boot) {
+async function runOrchestrator(session, config, programConfig, boot) {
 	const runId = randomUUID();
 	const switchboardCtx = {
 		program: programConfig.id,
@@ -1927,27 +2042,19 @@ or integrate manually here:
 		store,
 		validTypes: registry.enqueueableTypes,
 		sinkTypes: registry.sinkTypes,
+		runnerSeededTypes: registry.runnerSeededTypes,
 		currentTaskId
 	});
 	const seedEntries = areSeededTasksEnabled(boot.wizardFlags) ? programConfig.seedTasks?.(session) ?? [] : [];
 	const seededTypes = [];
+	const seededTasks = [];
+	const seededNotices = /* @__PURE__ */ new Map();
 	for (const seeded of seedEntries) {
 		if (!registry.runnerSeededTypes.includes(seeded.type)) {
 			logToFile(`[orchestrator] skipping runner-seeded task "${seeded.type}": not a runner-seeded type in this flow`);
 			continue;
 		}
-		if (seeded.notice) {
-			const keep = await getUI().showTaskNotice(seeded.notice);
-			analytics.wizardCapture("orchestrator task notice answered", {
-				type: seeded.type,
-				kept: keep
-			});
-			if (!keep) {
-				logToFile(`[orchestrator] user declined runner-seeded ${seeded.type}`);
-				continue;
-			}
-		}
-		store.enqueue({
+		const task = store.enqueue({
 			type: seeded.type,
 			label: seeded.label,
 			inputs: seeded.inputs,
@@ -1955,6 +2062,8 @@ or integrate manually here:
 			optional: true
 		});
 		seededTypes.push(seeded.type);
+		seededTasks.push(task);
+		if (seeded.notice) seededNotices.set(task.id, seeded.notice);
 		logToFile(`[orchestrator] runner-seeded task ${seeded.type}`);
 	}
 	const askingTypes = seededTypes.filter((type) => canAsk(registry.get(type)));
@@ -1966,9 +2075,12 @@ or integrate manually here:
 	});
 	const askBridge = shouldDisableAsk(session) ? void 0 : createWizardAskBridge({
 		getSource: () => session.skillId ?? programConfig.id,
-		showQuestion: (q) => getUI().requestQuestion(q),
+		showQuestion: (q) => {
+			metrics.recordAsk(Date.now());
+			return getUI().requestQuestion(q);
+		},
 		cancelQuestion: () => getUI().cancelPendingQuestion(),
-		richLinks: false,
+		richLinks: config.richLinks ?? false,
 		timeoutMs: TASK_ASK_TIMEOUT_MS
 	});
 	const spinner = getUI().spinner();
@@ -1999,6 +2111,28 @@ or integrate manually here:
 		types: store.list().map((t) => t.type)
 	});
 	renderQueue();
+	const deferred = deferSeededTasks(store, seededTasks, (type) => registry.get(type)?.dependsOn ?? [], registry.sinkTypes);
+	for (const entry of deferred) {
+		logToFile(`[orchestrator] deferred runner-seeded ${entry.type}: ${entry.added.length} deps (${entry.declared ? `declared: ${entry.declaredTypes.join(", ")}` : "default"})${entry.refused.length > 0 ? `, ${entry.refused.length} refused` : ""}${entry.unresolvedTypes.length > 0 ? `, unresolved: ${entry.unresolvedTypes.join(", ")}` : ""}`);
+		analytics.wizardCapture("orchestrator seeded task deferred", {
+			type: entry.type,
+			dep_count: entry.added.length,
+			declared: entry.declared,
+			declared_types: entry.declaredTypes,
+			unresolved_types: entry.unresolvedTypes,
+			refused_count: entry.refused.length
+		});
+	}
+	if (deferred.length > 0) renderQueue();
+	for (const seeded of seededTasks) {
+		const dependants = store.list().filter((t) => !registry.sinkTypes.includes(t.type) && t.id !== seeded.id && dependencyClosure(store, [t.id]).has(seeded.id));
+		if (dependants.length === 0) continue;
+		logToFile(`[orchestrator] one-way rule broken: ${dependants.map((t) => t.type).join(", ")} depend on runner-seeded ${seeded.type}`);
+		analytics.wizardCapture("orchestrator seeded task depended on", {
+			type: seeded.type,
+			dependant_types: dependants.map((t) => t.type)
+		});
+	}
 	const unwaited = store.list().filter((t) => registry.sinkTypes.includes(t.type)).flatMap((sink) => uncoveredBySink({
 		store,
 		validTypes: registry.types,
@@ -2020,8 +2154,38 @@ or integrate manually here:
 	const taskSkillsRoot = path$1.join(QUEUE_DIR_NAME, "skills");
 	const claudeSkillsDir = path$1.join(session.installDir, ".claude", "skills");
 	const preexistingSkills = new Set(existsSync(claudeSkillsDir) ? readdirSync(claudeSkillsDir) : []);
+	let noticeGate = Promise.resolve();
 	const runTask = async (task) => {
 		renderQueue();
+		const notice = seededNotices.get(task.id);
+		if (notice) {
+			seededNotices.delete(task.id);
+			const offer = noticeGate.then(() => offerSeededTask(notice));
+			noticeGate = offer.catch(() => void 0);
+			const { keep, timedOut } = await offer.catch((err) => {
+				logToFile(`[orchestrator] notice failed for ${task.type}, declining: ${String(err)}`);
+				analytics.captureException(err instanceof Error ? err : new Error(String(err)), { step: "orchestrator_task_notice" });
+				return {
+					keep: false,
+					timedOut: false
+				};
+			});
+			analytics.wizardCapture("orchestrator task notice answered", {
+				type: task.type,
+				kept: keep,
+				timed_out: timedOut
+			});
+			if (!keep) {
+				logToFile(`[orchestrator] runner-seeded ${task.type} declined (${timedOut ? "timed out" : "by the user"})`);
+				store.skip(task.id, {
+					goals: notice.title,
+					did: timedOut ? "Nothing — the step was offered and the offer timed out with no answer." : "Nothing — the user chose to skip this step when offered it.",
+					forNextAgent: timedOut ? "This step was offered and nobody answered, so it did no work. Report it as not set up, and point the user at how to do it later." : "This step was offered and declined, so it did no work. Report it as skipped at the user’s request, not as failed."
+				});
+				renderQueue();
+				return;
+			}
+		}
 		try {
 			const resolved = resolveTask(registry, task, store);
 			const skillPaths = [];
@@ -2116,12 +2280,15 @@ or integrate manually here:
 	const blocked = verdict.blocked;
 	if (verdict.requiredFailedTypes.length > 0 || blocked > 0) {
 		const failedTypes = verdict.requiredFailedTypes.join(", ");
+		const whatFailed = failedTypes ? `the ${failedTypes} step failed` : `${blocked} steps never ran`;
+		const missingScopes = boot.credentials.missingScopes ?? [];
 		await wizardAbort({
-			message: `The wizard was unable to set up PostHog: ${failedTypes ? `the ${failedTypes} step failed` : `${blocked} steps never ran`}.\n\nPlease report this to: ${WIZARD_CONTACT_EMAIL}`,
+			message: missingScopes.length > 0 ? `The wizard could not finish setup: ${whatFailed}, and this run was authorized without the following permission${missingScopes.length === 1 ? "" : "s"}: ${missingScopes.join(", ")}.\n\nPlease try again, approving all permissions on the PostHog authorization screen. If it still fails, report it to: ${WIZARD_CONTACT_EMAIL}` : `The wizard was unable to set up PostHog: ${whatFailed}.\n\nPlease report this to: ${WIZARD_CONTACT_EMAIL}`,
 			error: new WizardError("orchestrator drain ended with failed tasks", {
 				tasks_failed: summary.failed,
 				tasks_blocked: blocked,
 				failed_types: failedTypes,
+				missing_oauth_scopes: missingScopes.join(" "),
 				queue_state: JSON.stringify(store.list())
 			})
 		});
@@ -2151,7 +2318,7 @@ const SEQUENCE_OPTIONS = {
 	},
 	["orchestrator"]: {
 		name: "orchestrator",
-		run: (session, _config, programConfig, boot, _composed) => runOrchestrator(session, programConfig, boot)
+		run: (session, config, programConfig, boot, _composed) => runOrchestrator(session, config, programConfig, boot)
 	}
 };
 function getSequence(name) {
@@ -2521,4 +2688,4 @@ var agent_runner_exports = /* @__PURE__ */ __exportAll({ runAgent: () => runAgen
 //#endregion
 export { formatCostUsd as a, computeTokenCostUsd as i, runAgent as n, formatTokenCount as o, shouldDisableAsk as r, authenticate as s, agent_runner_exports as t };
 
-//# sourceMappingURL=agent-runner-DA5YfjOD.js.map
+//# sourceMappingURL=agent-runner-X3JWS2WK.js.map