ur-agent 1.22.0 → 1.22.1

package/dist/cli.js

@@ -16939,7 +16939,7 @@ function formatAgentTrendReport(report = buildAgentTrendReport()) {
 function formatA2AAgentCard(options = {}, pretty = true) {
   return JSON.stringify(buildA2AAgentCard(options), null, pretty ? 2 : 0);
 }
-var urVersion = "1.22.0", coverage, priorityRoadmap;
+var urVersion = "1.22.1", coverage, priorityRoadmap;
 var init_trends = __esm(() => {
   coverage = [
     {
@@ -71247,7 +71247,7 @@ var init_auth = __esm(() => {
 
 // src/utils/userAgent.ts
 function getURCodeUserAgent() {
-  return `ur/${"1.22.0"}`;
+  return `ur/${"1.22.1"}`;
 }
 
 // src/utils/workloadContext.ts
@@ -71269,7 +71269,7 @@ function getUserAgent() {
   const clientApp = process.env.UR_AGENT_SDK_CLIENT_APP ? `, client-app/${process.env.UR_AGENT_SDK_CLIENT_APP}` : "";
   const workload = getWorkload();
   const workloadSuffix = workload ? `, workload/${workload}` : "";
-  return `ur-cli/${"1.22.0"} (${process.env.USER_TYPE}, ${process.env.UR_CODE_ENTRYPOINT ?? "cli"}${agentSdkVersion}${clientApp}${workloadSuffix})`;
+  return `ur-cli/${"1.22.1"} (${process.env.USER_TYPE}, ${process.env.UR_CODE_ENTRYPOINT ?? "cli"}${agentSdkVersion}${clientApp}${workloadSuffix})`;
 }
 function getMCPUserAgent() {
   const parts = [];
@@ -71283,7 +71283,7 @@ function getMCPUserAgent() {
     parts.push(`client-app/${process.env.UR_AGENT_SDK_CLIENT_APP}`);
   }
   const suffix = parts.length > 0 ? ` (${parts.join(", ")})` : "";
-  return `ur/${"1.22.0"}${suffix}`;
+  return `ur/${"1.22.1"}${suffix}`;
 }
 function getWebFetchUserAgent() {
   return `UR-User (${getURCodeUserAgent()})`;
@@ -71421,7 +71421,7 @@ var init_user = __esm(() => {
       deviceId,
       sessionId: getSessionId(),
       email: getEmail(),
-      appVersion: "1.22.0",
+      appVersion: "1.22.1",
       platform: getHostPlatformForAnalytics(),
       organizationUuid,
       accountUuid,
@@ -77198,7 +77198,7 @@ var init_metadata = __esm(() => {
   COMPOUND_OPERATOR_REGEX = /\s*(?:&&|\|\||[;|])\s*/;
   WHITESPACE_REGEX = /\s+/;
   getVersionBase = memoize_default(() => {
-    const match = "1.22.0".match(/^\d+\.\d+\.\d+(?:-[a-z]+)?/);
+    const match = "1.22.1".match(/^\d+\.\d+\.\d+(?:-[a-z]+)?/);
     return match ? match[0] : undefined;
   });
   buildEnvContext = memoize_default(async () => {
@@ -77238,7 +77238,7 @@ var init_metadata = __esm(() => {
       isGithubAction: isEnvTruthy(process.env.GITHUB_ACTIONS),
       isURCodeAction: isEnvTruthy(process.env.UR_CODE_ACTION),
       isURAiAuth: isURAISubscriber2(),
-      version: "1.22.0",
+      version: "1.22.1",
       versionBase: getVersionBase(),
       buildTime: "",
       deploymentEnvironment: env2.detectDeploymentEnvironment(),
@@ -77908,7 +77908,7 @@ function initialize1PEventLogging() {
   const platform2 = getPlatform();
   const attributes = {
     [import_semantic_conventions4.ATTR_SERVICE_NAME]: "ur",
-    [import_semantic_conventions4.ATTR_SERVICE_VERSION]: "1.22.0"
+    [import_semantic_conventions4.ATTR_SERVICE_VERSION]: "1.22.1"
   };
   if (platform2 === "wsl") {
     const wslVersion = getWslVersion();
@@ -77935,7 +77935,7 @@ function initialize1PEventLogging() {
       })
     ]
   });
-  firstPartyEventLogger = firstPartyEventLoggerProvider.getLogger("com.urhq.ur.events", "1.22.0");
+  firstPartyEventLogger = firstPartyEventLoggerProvider.getLogger("com.urhq.ur.events", "1.22.1");
 }
 async function reinitialize1PEventLoggingIfConfigChanged() {
   if (!is1PEventLoggingEnabled() || !firstPartyEventLoggerProvider) {
@@ -79803,7 +79803,7 @@ function getAttributionHeader(fingerprint) {
   if (!isAttributionHeaderEnabled()) {
     return "";
   }
-  const version2 = `${"1.22.0"}.${fingerprint}`;
+  const version2 = `${"1.22.1"}.${fingerprint}`;
   const entrypoint = process.env.UR_CODE_ENTRYPOINT ?? "unknown";
   const cch = "";
   const workload = getWorkload();
@@ -186485,7 +186485,7 @@ function getTelemetryAttributes() {
     attributes["session.id"] = sessionId;
   }
   if (shouldIncludeAttribute("OTEL_METRICS_INCLUDE_VERSION")) {
-    attributes["app.version"] = "1.22.0";
+    attributes["app.version"] = "1.22.1";
   }
   const oauthAccount = getOauthAccountInfo();
   if (oauthAccount) {
@@ -222539,7 +222539,7 @@ function getInstallationEnv() {
   return;
 }
 function getURCodeVersion() {
-  return "1.22.0";
+  return "1.22.1";
 }
 async function getInstalledVSCodeExtensionVersion(command) {
   const { stdout } = await execFileNoThrow(command, ["--list-extensions", "--show-versions"], {
@@ -225267,7 +225267,7 @@ async function setupSdkMcpClients(sdkMcpConfigs, sendMcpMessage) {
     const client2 = new Client({
       name: "ur",
       title: "UR",
-      version: "1.22.0",
+      version: "1.22.1",
       description: "URHQ's agentic coding tool",
       websiteUrl: PRODUCT_URL
     }, {
@@ -225621,7 +225621,7 @@ var init_client5 = __esm(() => {
       const client2 = new Client({
         name: "ur",
         title: "UR",
-        version: "1.22.0",
+        version: "1.22.1",
         description: "URHQ's agentic coding tool",
         websiteUrl: PRODUCT_URL
       }, {
@@ -235434,9 +235434,9 @@ async function assertMinVersion() {
   if (false) {}
   try {
     const versionConfig = await getDynamicConfig_BLOCKS_ON_INIT("tengu_version_config", { minVersion: "0.0.0" });
-    if (versionConfig.minVersion && lt("1.22.0", versionConfig.minVersion)) {
+    if (versionConfig.minVersion && lt("1.22.1", versionConfig.minVersion)) {
       console.error(`
-It looks like your version of UR (${"1.22.0"}) needs an update.
+It looks like your version of UR (${"1.22.1"}) needs an update.
 A newer version (${versionConfig.minVersion} or higher) is required to continue.
 
 To update, please run:
@@ -235652,7 +235652,7 @@ async function installGlobalPackage(specificVersion) {
     logError2(new AutoUpdaterError("Another process is currently installing an update"));
     logEvent("tengu_auto_updater_lock_contention", {
       pid: process.pid,
-      currentVersion: "1.22.0"
+      currentVersion: "1.22.1"
     });
     return "in_progress";
   }
@@ -235661,7 +235661,7 @@ async function installGlobalPackage(specificVersion) {
     if (!env2.isRunningWithBun() && env2.isNpmFromWindowsPath()) {
       logError2(new Error("Windows NPM detected in WSL environment"));
       logEvent("tengu_auto_updater_windows_npm_in_wsl", {
-        currentVersion: "1.22.0"
+        currentVersion: "1.22.1"
       });
       console.error(`
 Error: Windows NPM detected in WSL
@@ -236196,7 +236196,7 @@ function detectLinuxGlobPatternWarnings() {
 }
 async function getDoctorDiagnostic() {
   const installationType = await getCurrentInstallationType();
-  const version2 = typeof MACRO !== "undefined" ? "1.22.0" : "unknown";
+  const version2 = typeof MACRO !== "undefined" ? "1.22.1" : "unknown";
   const installationPath = await getInstallationPath();
   const invokedBinary = getInvokedBinary();
   const multipleInstallations = await detectMultipleInstallations();
@@ -237131,8 +237131,8 @@ async function updateLatest(channelOrVersion, forceReinstall = false) {
     const maxVersion = await getMaxVersion();
     if (maxVersion && gt(version2, maxVersion)) {
       logForDebugging(`Native installer: maxVersion ${maxVersion} is set, capping update from ${version2} to ${maxVersion}`);
-      if (gte("1.22.0", maxVersion)) {
-        logForDebugging(`Native installer: current version ${"1.22.0"} is already at or above maxVersion ${maxVersion}, skipping update`);
+      if (gte("1.22.1", maxVersion)) {
+        logForDebugging(`Native installer: current version ${"1.22.1"} is already at or above maxVersion ${maxVersion}, skipping update`);
         logEvent("tengu_native_update_skipped_max_version", {
           latency_ms: Date.now() - startTime,
           max_version: maxVersion,
@@ -237143,7 +237143,7 @@ async function updateLatest(channelOrVersion, forceReinstall = false) {
       version2 = maxVersion;
     }
   }
-  if (!forceReinstall && version2 === "1.22.0" && await versionIsAvailable(version2) && await isPossibleURBinary(executablePath)) {
+  if (!forceReinstall && version2 === "1.22.1" && await versionIsAvailable(version2) && await isPossibleURBinary(executablePath)) {
     logForDebugging(`Found ${version2} at ${executablePath}, skipping install`);
     logEvent("tengu_native_update_complete", {
       latency_ms: Date.now() - startTime,
@@ -332970,7 +332970,7 @@ function Feedback({
       platform: env2.platform,
       gitRepo: envInfo.isGit,
       terminal: env2.terminal,
-      version: "1.22.0",
+      version: "1.22.1",
       transcript: normalizeMessagesForAPI(messages),
       errors: sanitizedErrors,
       lastApiRequest: getLastAPIRequest(),
@@ -333162,7 +333162,7 @@ function Feedback({
                       ", ",
                       env2.terminal,
                       ", v",
-                      "1.22.0"
+                      "1.22.1"
                     ]
                   }, undefined, true, undefined, this)
                 ]
@@ -333268,7 +333268,7 @@ ${sanitizedDescription}
 ` + `**Environment Info**
 ` + `- Platform: ${env2.platform}
 ` + `- Terminal: ${env2.terminal}
-` + `- Version: ${"1.22.0"}
+` + `- Version: ${"1.22.1"}
 ` + `- Feedback ID: ${feedbackId}
 ` + `
 **Errors**
@@ -336378,7 +336378,7 @@ function buildPrimarySection() {
   }, undefined, false, undefined, this);
   return [{
     label: "Version",
-    value: "1.22.0"
+    value: "1.22.1"
   }, {
     label: "Session name",
     value: nameValue
@@ -339656,7 +339656,7 @@ function Config({
         }
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this) : showSubmenu === "ChannelDowngrade" ? /* @__PURE__ */ jsx_dev_runtime177.jsxDEV(ChannelDowngradeDialog, {
-      currentVersion: "1.22.0",
+      currentVersion: "1.22.1",
       onChoice: (choice) => {
         setShowSubmenu(null);
         setTabsHidden(false);
@@ -339668,7 +339668,7 @@ function Config({
           autoUpdatesChannel: "stable"
         };
         if (choice === "stay") {
-          newSettings.minimumVersion = "1.22.0";
+          newSettings.minimumVersion = "1.22.1";
         }
         updateSettingsForSource("userSettings", newSettings);
         setSettingsData((prev_27) => ({
@@ -347738,7 +347738,7 @@ function HelpV2(t0) {
   let t6;
   if ($3[31] !== tabs) {
     t6 = /* @__PURE__ */ jsx_dev_runtime204.jsxDEV(Tabs, {
-      title: `UR v${"1.22.0"}`,
+      title: `UR v${"1.22.1"}`,
       color: "professionalBlue",
       defaultTab: "general",
       children: tabs
@@ -367702,7 +367702,7 @@ function getAllReleaseNotes(changelogContent = getStoredChangelogFromMemory()) {
     return [];
   }
 }
-async function checkForReleaseNotes(lastSeenVersion, currentVersion = "1.22.0") {
+async function checkForReleaseNotes(lastSeenVersion, currentVersion = "1.22.1") {
   if (process.env.USER_TYPE === "ant") {
     const changelog = "";
     if (changelog) {
@@ -367729,7 +367729,7 @@ async function checkForReleaseNotes(lastSeenVersion, currentVersion = "1.22.0")
     releaseNotes
   };
 }
-function checkForReleaseNotesSync(lastSeenVersion, currentVersion = "1.22.0") {
+function checkForReleaseNotesSync(lastSeenVersion, currentVersion = "1.22.1") {
   if (process.env.USER_TYPE === "ant") {
     const changelog = "";
     if (changelog) {
@@ -368899,7 +368899,7 @@ function getRecentActivitySync() {
   return cachedActivity;
 }
 function getLogoDisplayData() {
-  const version2 = process.env.DEMO_VERSION ?? "1.22.0";
+  const version2 = process.env.DEMO_VERSION ?? "1.22.1";
   const serverUrl = getDirectConnectServerUrl();
   const displayPath = process.env.DEMO_VERSION ? "/code/ur" : getDisplayPath(getCwd());
   const cwd2 = serverUrl ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, "")}` : displayPath;
@@ -369688,7 +369688,7 @@ function LogoV2() {
   if ($3[2] === Symbol.for("react.memo_cache_sentinel")) {
     t2 = () => {
       const currentConfig = getGlobalConfig();
-      if (currentConfig.lastReleaseNotesSeen === "1.22.0") {
+      if (currentConfig.lastReleaseNotesSeen === "1.22.1") {
         return;
       }
       saveGlobalConfig(_temp326);
@@ -370373,12 +370373,12 @@ function LogoV2() {
   return t41;
 }
 function _temp326(current) {
-  if (current.lastReleaseNotesSeen === "1.22.0") {
+  if (current.lastReleaseNotesSeen === "1.22.1") {
     return current;
   }
   return {
     ...current,
-    lastReleaseNotesSeen: "1.22.0"
+    lastReleaseNotesSeen: "1.22.1"
   };
 }
 function _temp243(s_0) {
@@ -387331,7 +387331,7 @@ function buildToolUseContext(tools, readFileStateCache) {
 async function handleInitialize() {
   return {
     name: "ur-agent",
-    version: "1.22.0",
+    version: "1.22.1",
     protocolVersion: "0.1.0"
   };
 }
@@ -389494,6 +389494,76 @@ Specialist result:
         }
       ]
     },
+    {
+      id: "parallel",
+      name: "Parallel specialized subagents",
+      acronym: "PAR",
+      summary: "Run multiple specialist agents in parallel \u2014 bug finder, patch writer, test writer, security auditor, style reviewer \u2014 then synthesize their outputs into one coherent plan. Best for complex code changes that need independent expert scrutiny before integration.",
+      bestFor: [
+        "complex code changes needing independent expert review",
+        "tasks where bug-finding, patching, testing, security, and style can be separated",
+        "high-confidence patches that must survive multiple adversarial checks"
+      ],
+      reference: "https://openai.github.io/openai-agents-python/",
+      loop: null,
+      stages: [
+        {
+          id: "find-bugs",
+          role: "Bug finder",
+          agent: "reviewer",
+          goal: "Find concrete bugs in the code relevant to the task.",
+          prompt: "Find bugs in the code related to: {{task}}. List concrete issues with file paths and line numbers. Do not write fixes; only identify problems. End with VERDICT: PASS if no serious bugs were found, or VERDICT: FAIL with the bug list.",
+          dependsOn: [],
+          parallelizable: true
+        },
+        {
+          id: "write-patch",
+          role: "Patch writer",
+          agent: "worker",
+          goal: "Write the minimal correct patch for the task.",
+          prompt: "Write the minimal patch for: {{task}}. Return only the code changes and a VERDICT line. Do not write tests or prose; focus on the implementation.",
+          dependsOn: [],
+          parallelizable: true
+        },
+        {
+          id: "write-tests",
+          role: "Test writer",
+          agent: "test-runner",
+          goal: "Write tests that exercise the expected behavior.",
+          prompt: "Write tests for: {{task}}. Run them and report results. End with VERDICT: PASS if tests pass, or VERDICT: FAIL with failure output.",
+          dependsOn: [],
+          parallelizable: true
+        },
+        {
+          id: "security-review",
+          role: "Security auditor",
+          agent: "security-auditor",
+          goal: "Review the task for security vulnerabilities and unsafe patterns.",
+          prompt: "Security review for: {{task}}. Report any vulnerabilities, unsafe patterns, or trust-boundary issues. End with VERDICT: PASS if no serious issues, or VERDICT: FAIL with specifics.",
+          dependsOn: [],
+          parallelizable: true
+        },
+        {
+          id: "style-review",
+          role: "Style reviewer",
+          agent: "reviewer",
+          goal: "Review maintainability, style, and clarity.",
+          prompt: "Style/review for: {{task}}. Report maintainability, clarity, naming, and consistency issues. End with VERDICT: PASS if acceptable, or VERDICT: FAIL with a concise punch list.",
+          dependsOn: [],
+          parallelizable: true
+        },
+        {
+          id: "synthesize",
+          role: "Synthesizer",
+          agent: "general-purpose",
+          goal: "Merge parallel findings into one coherent, actionable plan.",
+          prompt: "Synthesize the parallel reviews and patch above into a single coherent plan for: {{task}}. Resolve conflicts between findings. Produce a unified patch/test/security/style recommendation. End with VERDICT: PASS if ready to apply, or VERDICT: FAIL if more work is needed.",
+          dependsOn: ["find-bugs", "write-patch", "write-tests", "security-review", "style-review"],
+          gate: "verification",
+          checkpoint: true
+        }
+      ]
+    },
     {
       id: "debate",
       name: "Debate (propose, critique, moderate)",
@@ -389936,6 +390006,7 @@ Known patterns: ${knownIds()}`
       workflow.name = `${pattern.id}-run`;
       const dryRun = tokens.includes("--dry-run");
       const maxTurnsValue = Number(optionValue(tokens, "--max-turns") ?? "30");
+      const parallelAgents = pattern.stages.filter((s) => s.parallelizable).length;
       const result = await saveAndRunWorkflow(workflow, {
         cwd: getCwd(),
         stateName: workflow.name,
@@ -389943,6 +390014,7 @@ Known patterns: ${knownIds()}`
         resume: tokens.includes("--resume"),
         skipPermissions: tokens.includes("--skip-permissions") || tokens.includes("--dangerously-skip-permissions"),
         maxTurns: Number.isFinite(maxTurnsValue) && maxTurnsValue > 0 ? maxTurnsValue : 30,
+        maxConcurrency: parallelAgents > 1 ? parallelAgents : undefined,
         loop: pattern.loop ? {
           from: pattern.loop.from,
           to: pattern.loop.to,
@@ -390006,8 +390078,8 @@ var init_pattern2 = __esm(() => {
     type: "local",
     name: "pattern",
     aliases: ["patterns"],
-    description: "Multi-agent collaboration patterns (PEER, DOE): list, show, run, or install",
-    argumentHint: "[list|show|run|install] [peer|doe] [task...] [--execute] [--dry-run] [--save] [--force] [--json]",
+    description: "Multi-agent collaboration patterns (PEER, DOE, concurrent, handoff, debate, parallel): list, show, run, or install",
+    argumentHint: "[list|show|run|install] [peer|doe|concurrent|handoff|debate|parallel] [task...] [--execute] [--dry-run] [--save] [--force] [--json]",
     supportsNonInteractive: true,
     load: () => Promise.resolve().then(() => (init_pattern(), exports_pattern))
   };
@@ -391817,9 +391889,40 @@ Complete only this subtask. End your reply with VERDICT: PASS if you finished it
     status: "todo"
   };
 }
+function makeTaskFromDecomposed(task, goal) {
+  const title = task.goal.length > 72 ? `${task.goal.slice(0, 69)}...` : task.goal;
+  const files = task.filesTouched.length ? `
+Files touched: ${task.filesTouched.join(", ")}` : "";
+  const risk = `
+Risk level: ${task.risk}`;
+  const tests = `
+Tests required: ${task.testsRequired.join(", ")}`;
+  const rollback = `
+Rollback point: ${task.rollbackPoint}`;
+  return {
+    id: task.id,
+    title,
+    prompt: `Overall goal: ${goal}
+
+Your subtask: ${task.goal}${files}${risk}${tests}${rollback}
+
+Complete only this subtask. End your reply with VERDICT: PASS if you finished it, or VERDICT: FAIL if you could not.`,
+    status: "todo",
+    filesTouched: task.filesTouched,
+    risk: task.risk,
+    testsRequired: task.testsRequired,
+    rollbackPoint: task.rollbackPoint
+  };
+}
 function createCrew(cwd2, name, goal, options2 = {}) {
   const now6 = new Date().toISOString();
-  const instructions = options2.tasks && options2.tasks.length > 0 ? options2.tasks : decomposeGoal(goal);
+  let tasks2;
+  if (options2.decomposed && options2.decomposed.length > 0) {
+    tasks2 = options2.decomposed.map((task) => makeTaskFromDecomposed(task, goal));
+  } else {
+    const instructions = options2.tasks && options2.tasks.length > 0 ? options2.tasks : decomposeGoal(goal);
+    tasks2 = instructions.map((instruction, index2) => makeTask(index2, instruction, goal));
+  }
   const spec = {
     version: 1,
     name: sanitizeCrewName(name),
@@ -391827,7 +391930,7 @@ function createCrew(cwd2, name, goal, options2 = {}) {
     lead: options2.lead ?? "general-purpose",
     createdAt: now6,
     updatedAt: now6,
-    tasks: instructions.map((instruction, index2) => makeTask(index2, instruction, goal))
+    tasks: tasks2
   };
   saveCrew(cwd2, spec);
   return spec;
@@ -392018,6 +392121,135 @@ var init_crew = __esm(() => {
   init_cliStepRunner();
 });
 
+// src/services/agents/decomposer.ts
+function riskLevelFromKeywords(goal, files = []) {
+  const text = `${goal} ${files.join(" ")}`.toLowerCase();
+  if (HIGH_RISK_KEYWORDS.test(text))
+    return "high";
+  if (MEDIUM_RISK_KEYWORDS.test(text))
+    return "medium";
+  if (LOW_RISK_KEYWORDS.test(text))
+    return "low";
+  return "medium";
+}
+async function currentRollbackPoint(cwd2) {
+  const result = await execFileNoThrowWithCwd("git", ["rev-parse", "HEAD"], { cwd: cwd2, preserveOutputOnError: true });
+  if (result.code === 0 && result.stdout.trim())
+    return result.stdout.trim();
+  return "untracked";
+}
+function deterministicDecomposition(goal, rollbackPoint) {
+  const items = decomposeGoal(goal);
+  return items.map((item, index2) => ({
+    id: `t${index2 + 1}`,
+    goal: item,
+    filesTouched: [],
+    risk: riskLevelFromKeywords(item),
+    testsRequired: inferTests(item),
+    rollbackPoint
+  }));
+}
+function inferTests(goal) {
+  const lower = goal.toLowerCase();
+  const tests = [];
+  if (/\b(test|spec|assert|coverage)\b/i.test(lower))
+    tests.push("unit test");
+  if (/\b(integration|e2e|end-to-end|api)\b/i.test(lower))
+    tests.push("integration test");
+  if (/\b(build|compile|typecheck|tsc)\b/i.test(lower))
+    tests.push("compile/typecheck");
+  if (/\b(lint|format|style)\b/i.test(lower))
+    tests.push("lint");
+  if (tests.length === 0)
+    tests.push("existing test suite");
+  return tests;
+}
+function decomposePrompt(goal) {
+  return [
+    "Decompose the following engineering goal into atomic subtasks.",
+    "Return a JSON object with exactly this shape (no markdown, no commentary):",
+    "",
+    "{",
+    '  "tasks": [',
+    "    {",
+    '      "id": "t1",',
+    '      "goal": "concise subtask goal",',
+    '      "filesTouched": ["src/example.ts"],',
+    '      "risk": "low|medium|high",',
+    '      "testsRequired": ["unit test"],',
+    '      "rollbackPoint": "HEAD"',
+    "    }",
+    "  ]",
+    "}",
+    "",
+    "Guidelines:",
+    "- Each subtask should be small enough to implement and verify independently.",
+    '- "filesTouched" should list the files likely to change.',
+    '- "risk" should be high for auth/security/concurrency/destructive changes, medium for refactor/API changes, low for docs/style.',
+    '- "testsRequired" should list the test categories that must pass.',
+    '- "rollbackPoint" should be "HEAD".',
+    "",
+    "Goal:",
+    goal
+  ].join(`
+`);
+}
+async function decomposeTask(goal, options2) {
+  const rollbackPoint = await currentRollbackPoint(options2.cwd);
+  if (options2.dryRun) {
+    return deterministicDecomposition(goal, rollbackPoint);
+  }
+  const runner2 = options2.runner ?? defaultHeadlessRunner();
+  const out = await runner2({
+    cwd: options2.cwd,
+    prompt: decomposePrompt(goal),
+    maxTurns: 10
+  });
+  const parsed = safeParseJSON(out.output, false);
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.tasks)) {
+    const tasks2 = parsed.tasks;
+    return tasks2.map((t) => ({
+      ...t,
+      rollbackPoint: t.rollbackPoint ?? rollbackPoint,
+      filesTouched: Array.isArray(t.filesTouched) ? t.filesTouched : [],
+      testsRequired: Array.isArray(t.testsRequired) ? t.testsRequired : inferTests(t.goal),
+      risk: ["low", "medium", "high"].includes(t.risk) ? t.risk : riskLevelFromKeywords(t.goal, t.filesTouched)
+    }));
+  }
+  return deterministicDecomposition(goal, rollbackPoint);
+}
+function formatDecomposition(result, json2) {
+  if (json2)
+    return JSON.stringify(result, null, 2);
+  const lines = [
+    `Decomposition: ${result.goal}`,
+    `Rollback point: ${result.rollbackPoint}`,
+    `Generated: ${result.generatedAt}`,
+    ""
+  ];
+  for (const task of result.tasks) {
+    lines.push(`- ${task.id} [${task.risk.toUpperCase()}] ${task.goal}`);
+    if (task.filesTouched.length)
+      lines.push(`  files: ${task.filesTouched.join(", ")}`);
+    if (task.testsRequired.length)
+      lines.push(`  tests: ${task.testsRequired.join(", ")}`);
+    lines.push(`  rollback: ${task.rollbackPoint}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+var HIGH_RISK_KEYWORDS, MEDIUM_RISK_KEYWORDS, LOW_RISK_KEYWORDS;
+var init_decomposer = __esm(() => {
+  init_execFileNoThrow();
+  init_json();
+  init_headlessAgent();
+  init_crew();
+  HIGH_RISK_KEYWORDS = /\b(auth|authoriz|credential|secret|token|password|encrypt|hash|ssl|tls|sandbox|shell|bash|rm\b|drop|delete|migrate|security|vulnerab|exploit|injection|race|deadlock|concurren|distributed)\b/i;
+  MEDIUM_RISK_KEYWORDS = /\b(refactor|rename|move|restructure|extract|interface|api|contract|dependency|config|schema)\b/i;
+  LOW_RISK_KEYWORDS = /\b(comment|doc|readme|changelog|typo|format|style|lint|naming|whitespace)\b/i;
+});
+
 // src/commands/crew/crew.ts
 var exports_crew = {};
 __export(exports_crew, {
@@ -392048,10 +392280,11 @@ function usage7() {
   return [
     "Usage:",
     "  ur crew list [--json]",
-    '  ur crew create <name> --goal "..." [--lead <agent>] [--json]',
+    '  ur crew create <name> --goal "..." [--lead <agent>] [--decompose] [--json]',
+    '  ur crew plan <name> --goal "..." [--decompose] [--json]',
     "  ur crew show <name> [--json]",
     '  ur crew add <name> --task "another subtask"',
-    "  ur crew run <name> [--workers N] [--worktrees] [--dry-run] [--resume] [--max-turns N] [--skip-permissions] [--json]",
+    "  ur crew run <name> [--workers N] [--worktrees] [--dry-run] [--resume] [--decompose] [--max-turns N] [--skip-permissions] [--json]",
     "  ur crew reset <name>",
     "  ur crew delete <name>",
     "",
@@ -392074,7 +392307,9 @@ var call69 = async (args) => {
     const goal = option8(tokens, "--goal");
     if (!name || !goal)
       return { type: "text", value: usage7() };
-    const spec = createCrew(cwd2, name, goal, { lead: option8(tokens, "--lead") });
+    const decompose = tokens.includes("--decompose");
+    const decomposed = decompose ? await decomposeTask(goal, { cwd: cwd2, dryRun: tokens.includes("--dry-run") }) : undefined;
+    const spec = createCrew(cwd2, name, goal, { lead: option8(tokens, "--lead"), decomposed });
     return {
       type: "text",
       value: json2 ? formatCrew(spec, true) : `Created crew ${spec.name} with ${spec.tasks.length} task(s).
@@ -392082,6 +392317,19 @@ var call69 = async (args) => {
 ${formatCrew(spec, false)}`
     };
   }
+  if (action3 === "plan") {
+    const goal = option8(tokens, "--goal");
+    if (!goal)
+      return { type: "text", value: usage7() };
+    const tasks2 = await decomposeTask(goal, { cwd: cwd2, dryRun: tokens.includes("--dry-run") });
+    const result = {
+      goal,
+      tasks: tasks2,
+      rollbackPoint: tasks2[0]?.rollbackPoint ?? "HEAD",
+      generatedAt: new Date().toISOString()
+    };
+    return { type: "text", value: formatDecomposition(result, json2) };
+  }
   if (!name)
     return { type: "text", value: usage7() };
   if (action3 === "show") {
@@ -392109,8 +392357,17 @@ ${formatCrew(spec, false)}`
     return { type: "text", value: deleteCrew(cwd2, name) ? `Deleted crew ${name}.` : `Crew not found: ${name}` };
   }
   if (action3 === "run") {
-    if (!loadCrew(cwd2, name))
-      return { type: "text", value: `Crew not found: ${name}` };
+    const spec = loadCrew(cwd2, name);
+    if (!spec) {
+      const goal = option8(tokens, "--goal");
+      if (!goal)
+        return { type: "text", value: `Crew not found: ${name}` };
+      const decomposed = await decomposeTask(goal, { cwd: cwd2, dryRun: tokens.includes("--dry-run") });
+      createCrew(cwd2, name, goal, { lead: option8(tokens, "--lead"), decomposed });
+    } else if (tokens.includes("--decompose") && spec.tasks.length === 0) {
+      const decomposed = await decomposeTask(spec.goal, { cwd: cwd2, dryRun: tokens.includes("--dry-run") });
+      createCrew(cwd2, name, spec.goal, { lead: spec.lead, decomposed });
+    }
     const workersRaw = option8(tokens, "--workers");
     const maxTurnsRaw = option8(tokens, "--max-turns");
     const events2 = [];
@@ -392140,6 +392397,7 @@ ${events2.join(`
 };
 var init_crew2 = __esm(() => {
   init_crew();
+  init_decomposer();
   init_argumentSubstitution();
   init_cwd2();
 });
@@ -392152,7 +392410,7 @@ var init_crew3 = __esm(() => {
     name: "crew",
     aliases: ["crews"],
     description: "Headless agent crew: a lead splits a goal into a shared task board that worker subagents claim and run",
-    argumentHint: "create|list|show|add|run|reset|delete [name] [--goal ...] [--task ...] [--workers N] [--worktrees] [--dry-run] [--json]",
+    argumentHint: "create|list|plan|show|add|run|reset|delete [name] [--goal ...] [--task ...] [--workers N] [--worktrees] [--dry-run] [--decompose] [--json]",
     supportsNonInteractive: true,
     load: () => Promise.resolve().then(() => (init_crew2(), exports_crew))
   };
@@ -392434,42 +392692,432 @@ var init_goal2 = __esm(() => {
   goal_default = goal;
 });
 
+// src/services/agents/kernel.ts
+import { existsSync as existsSync26, readFileSync as readFileSync34 } from "fs";
+import { join as join146 } from "path";
+function defaultGuard(skipPermissions) {
+  return {
+    canUseTool: (_toolName, _input) => ({
+      allowed: skipPermissions === true,
+      reason: skipPermissions ? "permissions skipped" : "interactive ask treated as deny in kernel"
+    })
+  };
+}
+function defaultRouter() {
+  return {
+    routeTask: (task) => routeIntent(task),
+    recommendModel: () => null
+  };
+}
+function defaultMemory(cwd2) {
+  return {
+    loadMemorySnippet: (scope, agentType) => {
+      const base2 = scope === "project" ? join146(cwd2, ".ur", "memory") : join146(cwd2, ".ur", "memory");
+      const path22 = join146(base2, `${agentType}.md`);
+      return existsSync26(path22) ? readFileSync34(path22, "utf-8") : null;
+    }
+  };
+}
+function defaultExecutor() {
+  return {
+    execute: async (stage, options2) => {
+      const runner2 = options2.runner ?? defaultHeadlessRunner();
+      const out = await runner2({
+        cwd: stage.context.cwd,
+        prompt: stage.instructions ?? stage.goal,
+        maxTurns: options2.maxTurns,
+        skipPermissions: options2.skipPermissions
+      });
+      return {
+        stage,
+        verdict: out.verdict ?? extractVerdict(out.output),
+        output: out.output,
+        isError: out.isError ?? false,
+        artifacts: []
+      };
+    }
+  };
+}
+function defaultVerifier() {
+  return {
+    verify: async (stage, options2) => {
+      const config3 = await loadVerifyConfig(stage.context.cwd);
+      const gateResults = [];
+      const emitGate = (command5, ok) => {
+        gateResults.push({ kind: "note", text: `${ok ? "PASS" : "FAIL"} gate: ${command5}` });
+      };
+      if (config3?.afterEdit && config3.afterEdit.length > 0) {
+        const gate = await runGateCommands(config3.afterEdit, stage.context.cwd, config3.timeoutMs);
+        if (!gate.ok) {
+          const failed = gate;
+          emitGate(failed.command, false);
+          return {
+            stage,
+            verdict: "FAIL",
+            output: failed.reminder,
+            isError: true,
+            artifacts: gateResults
+          };
+        }
+        for (const cmd of config3.afterEdit)
+          emitGate(cmd, true);
+      }
+      const runner2 = options2.runner ?? defaultHeadlessRunner();
+      const out = await runner2({
+        cwd: stage.context.cwd,
+        prompt: stage.instructions ?? stage.goal,
+        maxTurns: options2.maxTurns,
+        skipPermissions: options2.skipPermissions
+      });
+      return {
+        stage,
+        verdict: out.verdict ?? extractVerdict(out.output),
+        output: out.output,
+        isError: out.isError ?? false,
+        artifacts: gateResults
+      };
+    }
+  };
+}
+function defaultCritic() {
+  return {
+    review: async (stage, previousOutput, options2) => {
+      const runner2 = options2.runner ?? defaultHeadlessRunner();
+      const prompt = [
+        "You are a critic reviewing another agent's work.",
+        "Original task:",
+        stage.goal,
+        "",
+        "Agent output:",
+        previousOutput.slice(0, 4000),
+        "",
+        "Identify gaps, risks, or better approaches. End with VERDICT: PASS if satisfactory, VERDICT: FAIL if material issues remain, or VERDICT: PARTIAL if limited by environment."
+      ].join(`
+`);
+      const out = await runner2({ cwd: stage.context.cwd, prompt, maxTurns: options2.maxTurns });
+      return {
+        stage: { ...stage, name: `${stage.name}:critic`, role: "critic" },
+        verdict: out.verdict ?? extractVerdict(out.output),
+        output: out.output,
+        isError: out.isError ?? false,
+        artifacts: []
+      };
+    }
+  };
+}
+function createAgentKernel(options2) {
+  return {
+    guard: defaultGuard(options2.skipPermissions),
+    router: defaultRouter(),
+    memory: defaultMemory(options2.cwd),
+    planner: { planStages: () => [] },
+    executor: defaultExecutor(),
+    verifier: defaultVerifier(),
+    critic: defaultCritic()
+  };
+}
+async function runKernelStage(kernel, stage, options2) {
+  options2.onEvent?.({ kind: "stage-start", stage: stage.name, role: stage.role });
+  const runner2 = options2.runner ?? (options2.dryRun ? makeDryHeadlessRunner() : defaultHeadlessRunner());
+  const runOptions = {
+    runner: runner2,
+    maxTurns: options2.maxTurns,
+    skipPermissions: options2.skipPermissions
+  };
+  let result;
+  switch (stage.role) {
+    case "executor":
+      result = await kernel.executor.execute(stage, runOptions);
+      break;
+    case "verifier":
+      result = await kernel.verifier.verify(stage, runOptions);
+      break;
+    case "critic":
+      result = await kernel.critic.review(stage, stage.context.priorOutputs?.previous ?? "", runOptions);
+      break;
+    case "planner":
+      result = {
+        stage,
+        verdict: null,
+        output: "Planner role: stage list produced.",
+        isError: false,
+        artifacts: [],
+        nextStages: kernel.planner.planStages(stage.context)
+      };
+      break;
+    case "memory": {
+      const snippet = kernel.memory.loadMemorySnippet("project", stage.name);
+      result = {
+        stage,
+        verdict: null,
+        output: snippet ?? "(no memory snippet)",
+        isError: false,
+        artifacts: snippet ? [{ kind: "note", text: snippet }] : []
+      };
+      break;
+    }
+    case "router": {
+      const route2 = kernel.router.routeTask(stage.goal);
+      result = {
+        stage,
+        verdict: null,
+        output: `Routed to ${route2.agent} (${route2.category}) with pattern ${route2.pattern ?? "single"}.`,
+        isError: false,
+        artifacts: [{ kind: "note", text: JSON.stringify(route2) }]
+      };
+      break;
+    }
+    case "guard": {
+      const check3 = kernel.guard.canUseTool(stage.name, stage.goal);
+      result = {
+        stage,
+        verdict: check3.allowed ? "PASS" : "FAIL",
+        output: check3.reason ?? (check3.allowed ? "allowed" : "denied"),
+        isError: !check3.allowed,
+        artifacts: []
+      };
+      break;
+    }
+    default:
+      result = {
+        stage,
+        verdict: "PARTIAL",
+        output: `Unsupported kernel role: ${stage.role}`,
+        isError: true,
+        artifacts: []
+      };
+  }
+  options2.onEvent?.({ kind: "stage-done", stage: stage.name, verdict: result.verdict, isError: result.isError });
+  for (const artifact of result.artifacts) {
+    options2.onEvent?.({ kind: "artifact", stage: stage.name, artifact });
+  }
+  return result;
+}
+var init_kernel = __esm(() => {
+  init_intentRouter();
+  init_headlessAgent();
+  init_cliStepRunner();
+  init_projectGates();
+});
+
+// src/services/agents/kernelSpec.ts
+var exports_kernelSpec = {};
+__export(exports_kernelSpec, {
+  runSpecWithKernel: () => runSpecWithKernel,
+  runSpecVerifyWithKernel: () => runSpecVerifyWithKernel,
+  planSpecVerify: () => planSpecVerify,
+  planSpecRun: () => planSpecRun,
+  mapStageResultsToSpecRunResult: () => mapStageResultsToSpecRunResult,
+  mapKernelResultToSpecVerifyResult: () => mapKernelResultToSpecVerifyResult
+});
+function isSpecRunStage(stage) {
+  return stage.role === "executor" && "meta" in stage && typeof stage.meta === "object";
+}
+function asSpecRunStage(stage) {
+  return isSpecRunStage(stage) ? stage : null;
+}
+function planSpecRun(cwd2, name) {
+  const spec = loadSpec(cwd2, name);
+  if (!spec)
+    throw new Error(`Spec not found: ${name}`);
+  const requirements = readPhase(cwd2, name, "requirements") ?? "";
+  const design = readPhase(cwd2, name, "design") ?? "";
+  const tasks2 = parseTasks(readPhase(cwd2, name, "tasks") ?? "");
+  const context4 = {
+    cwd: cwd2,
+    specName: spec.name,
+    goal: spec.goal
+  };
+  const baseContext = `Requirements:
+${requirements}
+
+Design:
+${design}`.slice(0, 6000);
+  return tasks2.filter((t) => !t.done).map((task) => ({
+    name: `spec-${spec.name}-${task.id}`,
+    role: "executor",
+    goal: task.title,
+    context: context4,
+    instructions: `You are implementing one task of a specced feature.
+
+${baseContext}
+
+Your task ${task.id}: ${task.title}
+
+` + `Implement only this task, consistent with the requirements and design. End your reply with VERDICT: PASS if complete, or VERDICT: FAIL.`,
+    meta: { taskId: task.id, taskTitle: task.title }
+  }));
+}
+function mapStageResultsToSpecRunResult(spec, results) {
+  const pairs = results.map((r) => ({ result: r, stage: asSpecRunStage(r.stage) })).filter((p2) => p2.stage !== null);
+  const ran = pairs.map((p2) => ({
+    id: p2.stage.meta.taskId,
+    title: p2.stage.meta.taskTitle,
+    status: p2.result.verdict === "FAIL" || p2.result.isError ? "failed" : "done"
+  }));
+  const stoppedOnFailure = pairs.some((p2) => p2.result.verdict === "FAIL" || p2.result.isError);
+  return {
+    name: spec.name,
+    ran,
+    remaining: 0,
+    stoppedOnFailure
+  };
+}
+async function runSpecWithKernel(cwd2, name, kernel, options2) {
+  const spec = loadSpec(cwd2, name);
+  if (!spec)
+    throw new Error(`Spec not found: ${name}`);
+  const stages = planSpecRun(cwd2, name);
+  const results = [];
+  for (const stage of stages) {
+    const result = await runKernelStage(kernel, stage, {
+      cwd: cwd2,
+      dryRun: options2.dryRun,
+      maxTurns: options2.maxTurns,
+      skipPermissions: options2.skipPermissions,
+      runner: options2.runner
+    });
+    results.push(result);
+    if ((result.verdict === "FAIL" || result.isError) && stage.context.stopOnError !== false)
+      break;
+    if (!options2.all)
+      break;
+  }
+  return mapStageResultsToSpecRunResult(spec, results);
+}
+function planSpecVerify(cwd2, name) {
+  const spec = loadSpec(cwd2, name);
+  if (!spec)
+    throw new Error(`Spec not found: ${name}`);
+  const requirements = readPhase(cwd2, name, "requirements") ?? "";
+  const design = readPhase(cwd2, name, "design") ?? "";
+  const tasks2 = parseTasks(readPhase(cwd2, name, "tasks") ?? "");
+  return {
+    name: `spec-${spec.name}-verify`,
+    role: "verifier",
+    goal: `Verify spec ${spec.name}: ${spec.goal}`,
+    context: {
+      cwd: cwd2,
+      specName: spec.name,
+      goal: spec.goal
+    },
+    instructions: [
+      "You are verifying the implementation of a specced feature.",
+      "",
+      "=== CRITICAL ===",
+      "You are STRICTLY PROHIBITED from modifying the project. Read, run commands, and inspect only.",
+      "You must be stricter than the implementer. No proof = no PASS.",
+      "",
+      "=== REQUIRED PROOFS ===",
+      "Before PASS, confirm ALL of the following with command-run evidence:",
+      "1. Compile proof: the project builds.",
+      "2. Test proof: the relevant test suite passes.",
+      "3. Lint proof: configured linters/type-checkers pass.",
+      "4. Diff proof: changed files match the spec.",
+      "5. Runtime proof: the feature behaves as required.",
+      "",
+      "=== SPEC ===",
+      `Goal: ${spec.goal}`,
+      "",
+      "Requirements:",
+      requirements || "(none written)",
+      "",
+      "Design:",
+      design || "(none written)",
+      "",
+      "Tasks:",
+      tasks2.map((t) => `- [${t.done ? "x" : " "}] ${t.id}: ${t.title}`).join(`
+`),
+      "",
+      "=== OUTPUT FORMAT ===",
+      "Each check MUST include the exact command you ran and the observed output.",
+      "End with exactly one line: VERDICT: PASS, VERDICT: FAIL, or VERDICT: PARTIAL."
+    ].join(`
+`)
+  };
+}
+function mapKernelResultToSpecVerifyResult(result) {
+  return {
+    verdict: result.verdict ?? "PARTIAL",
+    summary: result.verdict === "PASS" ? "All required proofs (compile, test, lint, diff, runtime) were demonstrated by the verifier." : result.verdict === "FAIL" ? "The verifier found failing evidence. See subagent output for details." : "The verifier could not reach a definitive PASS/FAIL verdict.",
+    commandFailures: result.artifacts.filter((a2) => a2.kind === "note" && a2.text.startsWith("FAIL gate")).length,
+    gateResults: [],
+    subagentOutput: result.output,
+    generatedAt: new Date().toISOString()
+  };
+}
+async function runSpecVerifyWithKernel(cwd2, name, kernel, options2) {
+  const stage = planSpecVerify(cwd2, name);
+  const result = await runKernelStage(kernel, stage, {
+    cwd: cwd2,
+    dryRun: options2.dryRun,
+    maxTurns: options2.maxTurns,
+    skipPermissions: options2.skipPermissions,
+    runner: options2.runner
+  });
+  return mapKernelResultToSpecVerifyResult(result);
+}
+var init_kernelSpec = __esm(() => {
+  init_kernel();
+  init_spec();
+});
+
 // src/services/agents/spec.ts
+var exports_spec = {};
+__export(exports_spec, {
+  writePhase: () => writePhase,
+  specsDir: () => specsDir,
+  specDir: () => specDir,
+  slugifySpecName: () => slugifySpecName,
+  runSpec: () => runSpec2,
+  readPhase: () => readPhase,
+  phaseFile: () => phaseFile,
+  parseTasks: () => parseTasks,
+  markTaskDone: () => markTaskDone,
+  loadSpec: () => loadSpec,
+  listSpecs: () => listSpecs2,
+  generatePhase: () => generatePhase,
+  formatSpecStatus: () => formatSpecStatus,
+  formatSpecList: () => formatSpecList,
+  deleteSpec: () => deleteSpec,
+  createSpec: () => createSpec,
+  approvePhase: () => approvePhase
+});
 import {
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   mkdirSync as mkdirSync26,
   readdirSync as readdirSync13,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   rmSync as rmSync5,
   writeFileSync as writeFileSync24
 } from "fs";
-import { join as join146 } from "path";
+import { join as join147 } from "path";
 function specsDir(cwd2) {
-  return join146(cwd2, ".ur", "specs");
+  return join147(cwd2, ".ur", "specs");
 }
 function slugifySpecName(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "spec";
 }
 function specDir(cwd2, name) {
-  return join146(specsDir(cwd2), slugifySpecName(name));
+  return join147(specsDir(cwd2), slugifySpecName(name));
 }
 function metaPath(cwd2, name) {
-  return join146(specDir(cwd2, name), "spec.json");
+  return join147(specDir(cwd2, name), "spec.json");
 }
 function phaseFile(phase) {
   return `${phase}.md`;
 }
 function listSpecs2(cwd2) {
   const dir = specsDir(cwd2);
-  if (!existsSync26(dir))
+  if (!existsSync27(dir))
     return [];
-  return readdirSync13(dir).filter((entry) => existsSync26(join146(dir, entry, "spec.json"))).map((entry) => safeParseJSON(readFileSync34(join146(dir, entry, "spec.json"), "utf-8"), false)).filter((m) => !!m && typeof m === "object" && ("goal" in m));
+  return readdirSync13(dir).filter((entry) => existsSync27(join147(dir, entry, "spec.json"))).map((entry) => safeParseJSON(readFileSync35(join147(dir, entry, "spec.json"), "utf-8"), false)).filter((m) => !!m && typeof m === "object" && ("goal" in m));
 }
 function loadSpec(cwd2, name) {
   const path22 = metaPath(cwd2, name);
-  if (!existsSync26(path22))
+  if (!existsSync27(path22))
     return null;
-  const parsed = safeParseJSON(readFileSync34(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync35(path22, "utf-8"), false);
   return parsed && typeof parsed === "object" ? parsed : null;
 }
 function saveMeta(cwd2, meta) {
@@ -392478,12 +393126,12 @@ function saveMeta(cwd2, meta) {
 `);
 }
 function readPhase(cwd2, name, phase) {
-  const path22 = join146(specDir(cwd2, name), phaseFile(phase));
-  return existsSync26(path22) ? readFileSync34(path22, "utf-8") : null;
+  const path22 = join147(specDir(cwd2, name), phaseFile(phase));
+  return existsSync27(path22) ? readFileSync35(path22, "utf-8") : null;
 }
 function writePhase(cwd2, name, phase, body) {
   mkdirSync26(specDir(cwd2, name), { recursive: true });
-  writeFileSync24(join146(specDir(cwd2, name), phaseFile(phase)), body.endsWith(`
+  writeFileSync24(join147(specDir(cwd2, name), phaseFile(phase)), body.endsWith(`
 `) ? body : `${body}
 `);
 }
@@ -392558,7 +393206,7 @@ function createSpec(cwd2, name, goal2) {
 }
 function deleteSpec(cwd2, name) {
   const dir = specDir(cwd2, name);
-  if (!existsSync26(dir))
+  if (!existsSync27(dir))
     return false;
   rmSync5(dir, { recursive: true, force: true });
   return true;
@@ -392612,6 +393260,19 @@ async function runSpec2(cwd2, name, options2) {
   const meta = loadSpec(cwd2, name);
   if (!meta)
     throw new Error(`Spec not found: ${name}`);
+  if (options2.kernel) {
+    const { runSpecWithKernel: runSpecWithKernel2 } = await Promise.resolve().then(() => (init_kernelSpec(), exports_kernelSpec));
+    const kernelResult = await runSpecWithKernel2(cwd2, name, options2.kernel, {
+      dryRun: options2.dryRun,
+      maxTurns: options2.maxTurns,
+      skipPermissions: options2.skipPermissions,
+      all: options2.all,
+      runner: options2.runner
+    });
+    const tasksMd = readPhase(cwd2, name, "tasks") ?? "";
+    const remaining2 = parseTasks(tasksMd).filter((t) => !t.done).length;
+    return { ...kernelResult, remaining: remaining2 };
+  }
   const runner2 = options2.runner ?? (options2.dryRun ? makeDryHeadlessRunner() : defaultHeadlessRunner());
   const requirements = readPhase(cwd2, name, "requirements") ?? "";
   const design = readPhase(cwd2, name, "design") ?? "";
@@ -392701,12 +393362,15 @@ function formatSpecStatus(cwd2, meta, json2) {
     return JSON.stringify({ ...meta, tasks: { total: tasks2.length, done } }, null, 2);
   }
   const mark = (ok) => ok ? "\u2713" : "\u25CB";
+  const v = meta.verification;
+  const vMark = v ? v.verdict === "PASS" ? "\u2713" : v.verdict === "FAIL" ? "\u2717" : "\u25D0" : "\u25CB";
   const lines = [
     `Spec: ${meta.name}`,
     `Goal: ${meta.goal}`,
     `Phase: ${meta.phase}`,
     `Approvals: ${mark(meta.approvals.requirements)} requirements  ${mark(meta.approvals.design)} design  ${mark(meta.approvals.tasks)} tasks`,
     `Tasks: ${done}/${tasks2.length} done`,
+    `Verification: ${vMark} ${v ? `${v.verdict} (${v.generatedAt})` : "not run"}`,
     ""
   ];
   for (const task of tasks2) {
@@ -392723,9 +393387,259 @@ var init_spec = __esm(() => {
   TASK_RE = /^\s*-\s*\[( |x|X)\]\s*(?:(T\d+)\s*:?\s*)?(.*)$/;
 });
 
+// src/services/agents/specVerifier.ts
+import { existsSync as existsSync28, mkdirSync as mkdirSync27, readFileSync as readFileSync36, writeFileSync as writeFileSync25 } from "fs";
+import { join as join148 } from "path";
+function recordPath(cwd2, name) {
+  return join148(cwd2, ".ur", "specs", name, RECORD_FILE);
+}
+function reportPath(cwd2, name) {
+  return join148(cwd2, ".ur", "specs", name, REPORT_FILE);
+}
+function loadVerificationRecord(cwd2, name) {
+  const path22 = recordPath(cwd2, name);
+  if (!existsSync28(path22))
+    return null;
+  const parsed = safeParseJSON(readFileSync36(path22, "utf-8"), false);
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  return parsed;
+}
+function listVerificationRecords(cwd2, name) {
+  const records = [];
+  let current = loadVerificationRecord(cwd2, name);
+  if (current)
+    records.push(current);
+  return records;
+}
+function saveVerificationRecord(cwd2, name, record3) {
+  const path22 = recordPath(cwd2, name);
+  mkdirSync27(join148(cwd2, ".ur", "specs", name), { recursive: true });
+  writeFileSync25(path22, `${JSON.stringify(record3, null, 2)}
+`);
+}
+function writeVerificationReport(cwd2, name, result) {
+  const lines = [
+    `# Verification: ${name}`,
+    "",
+    `- Verdict: **${result.verdict}**`,
+    `- Generated: ${result.generatedAt}`,
+    `- Command failures: ${result.commandFailures}`,
+    "",
+    "## Summary",
+    "",
+    result.summary,
+    "",
+    "## Gate results",
+    "",
+    ...result.gateResults.map((g) => g.ok ? `- \u2713 \`${g.command}\` passed` : `- \u2717 \`${g.command}\` failed (exit ${g.exitCode ?? "killed"})`),
+    "",
+    "## Subagent output",
+    "",
+    "```",
+    result.subagentOutput,
+    "```",
+    ""
+  ];
+  writeFileSync25(reportPath(cwd2, name), lines.join(`
+`));
+}
+async function captureDiff(cwd2) {
+  const result = await execFileNoThrowWithCwd("git", ["diff", "HEAD", "--stat"], { cwd: cwd2, preserveOutputOnError: true });
+  const statLines = result.stdout.trim().split(`
+`).filter(Boolean);
+  const changedFiles = statLines.slice(0, -1).map((line) => line.split("|")[0]?.trim()).filter(Boolean);
+  const diffResult = await execFileNoThrowWithCwd("git", ["diff", "HEAD"], { cwd: cwd2, preserveOutputOnError: true });
+  const diff3 = diffResult.stdout.slice(0, MAX_DIFF_CHARS);
+  return { diff: diff3, changedFiles };
+}
+function buildVerifierPrompt(evidence2) {
+  const incompleteTasks = evidence2.tasks.filter((t) => !t.done).map((t) => `- ${t.id}: ${t.title}`).join(`
+`) || "None (all tasks marked done)";
+  const prior = evidence2.priorVerifications.map((r) => `- ${r.generatedAt}: ${r.verdict} \u2014 ${r.summary}`).join(`
+`) || "No prior verifications.";
+  return [
+    "You are verifying the implementation of a specced feature.",
+    "",
+    "=== CRITICAL ===",
+    "You are STRICTLY PROHIBITED from modifying the project. Read, run commands, and inspect only.",
+    "You must be stricter than the implementer. No proof = no PASS.",
+    "",
+    "=== REQUIRED PROOFS ===",
+    "Before PASS, confirm ALL of the following with command-run evidence:",
+    "1. Compile proof: the project builds (e.g., tsc --noEmit, build script).",
+    "2. Test proof: the relevant test suite passes.",
+    "3. Lint proof: configured linters/type-checkers pass.",
+    "4. Diff proof: the changed files match the spec and do not include unrelated edits.",
+    "5. Runtime proof: the feature behaves as required (run the code / hit the endpoint / exercise the CLI).",
+    "",
+    "=== SPEC ===",
+    `Goal: ${evidence2.spec.goal}`,
+    "",
+    "Requirements:",
+    evidence2.requirements || "(none written)",
+    "",
+    "Design:",
+    evidence2.design || "(none written)",
+    "",
+    "Tasks:",
+    evidence2.tasks.map((t) => `- [${t.done ? "x" : " "}] ${t.id}: ${t.title}`).join(`
+`),
+    "",
+    "Incomplete tasks at time of verification:",
+    incompleteTasks,
+    "",
+    "Changed files:",
+    evidence2.changedFiles.length ? evidence2.changedFiles.map((f) => `- ${f}`).join(`
+`) : "(none detected)",
+    "",
+    "Diff preview:",
+    "```diff",
+    evidence2.diff || "(no diff)",
+    "```",
+    "",
+    "Prior verifications:",
+    prior,
+    "",
+    "=== OUTPUT FORMAT ===",
+    "Each check MUST include the exact command you ran and the observed output.",
+    "End with exactly one line: VERDICT: PASS, VERDICT: FAIL, or VERDICT: PARTIAL.",
+    "Use PARTIAL only for missing tools or environment, never for uncertainty."
+  ].join(`
+`);
+}
+async function runDeterministicGates(cwd2) {
+  const config3 = await loadVerifyConfig(cwd2);
+  const results = [];
+  if (!config3)
+    return { results, failed: false };
+  const commands = config3.afterEdit?.length ? config3.afterEdit : [];
+  if (commands.length === 0)
+    return { results, failed: false };
+  const gate = await runGateCommands(commands, cwd2, config3.timeoutMs);
+  if (gate.ok) {
+    results.push({ ok: true, command: commands.join(" && "), ranCommands: gate.ranCommands });
+    return { results, failed: false };
+  }
+  const failed = gate;
+  results.push({
+    ok: false,
+    command: failed.command,
+    exitCode: failed.exitCode,
+    stdout: failed.stdout,
+    stderr: failed.stderr
+  });
+  return { results, failed: true };
+}
+function countCommandFailures(output) {
+  const markers = ["[ERROR]", "Command failed", "exit code 1", "Error:", "FAILED"];
+  let count4 = 0;
+  const lower = output.toLowerCase();
+  for (const marker of markers) {
+    const re = new RegExp(marker.replace(/\[/g, "\\[").replace(/\]/g, "\\]").toLowerCase(), "g");
+    const matches = lower.match(re);
+    if (matches)
+      count4 += matches.length;
+  }
+  return count4;
+}
+async function runSpecVerification(cwd2, name, options2 = {}) {
+  if (options2.kernel) {
+    const { runSpecVerifyWithKernel: runSpecVerifyWithKernel2 } = await Promise.resolve().then(() => (init_kernelSpec(), exports_kernelSpec));
+    return runSpecVerifyWithKernel2(cwd2, name, options2.kernel, {
+      dryRun: options2.dryRun,
+      maxTurns: options2.maxTurns,
+      skipPermissions: options2.skipPermissions,
+      runner: options2.runner
+    });
+  }
+  const runner2 = options2.runner ?? (options2.dryRun ? makeDryHeadlessRunner() : defaultHeadlessRunner());
+  const { readPhase: readPhase2, loadSpec: loadSpec2, parseTasks: parseTasks2 } = await Promise.resolve().then(() => (init_spec(), exports_spec));
+  const spec = loadSpec2(cwd2, name);
+  if (!spec)
+    throw new Error(`Spec not found: ${name}`);
+  const gateRun = await runDeterministicGates(cwd2);
+  if (gateRun.failed) {
+    const generatedAt2 = new Date().toISOString();
+    const summary2 = `Verification failed at project gates: ${gateRun.results.filter((r) => !r.ok).map((r) => r.command).join(", ")}`;
+    const result2 = {
+      verdict: "FAIL",
+      summary: summary2,
+      commandFailures: gateRun.results.filter((r) => !r.ok).length,
+      gateResults: gateRun.results,
+      subagentOutput: "",
+      generatedAt: generatedAt2
+    };
+    const record4 = {
+      version: 1,
+      verdict: "FAIL",
+      summary: summary2,
+      commandFailures: result2.commandFailures,
+      generatedAt: generatedAt2
+    };
+    saveVerificationRecord(cwd2, name, record4);
+    writeVerificationReport(cwd2, name, result2);
+    return result2;
+  }
+  const requirements = readPhase2(cwd2, name, "requirements") ?? "";
+  const design = readPhase2(cwd2, name, "design") ?? "";
+  const tasksMd = readPhase2(cwd2, name, "tasks") ?? "";
+  const tasks2 = parseTasks2(tasksMd);
+  const { diff: diff3, changedFiles } = await captureDiff(cwd2);
+  const priorVerifications = listVerificationRecords(cwd2, name);
+  const evidence2 = {
+    spec,
+    requirements,
+    design,
+    tasks: tasks2,
+    changedFiles,
+    diff: diff3,
+    priorVerifications
+  };
+  const prompt = buildVerifierPrompt(evidence2);
+  const out = await runner2({
+    cwd: cwd2,
+    prompt,
+    maxTurns: options2.maxTurns,
+    skipPermissions: options2.skipPermissions
+  });
+  const verdict = extractVerdict(out.output) ?? "PARTIAL";
+  const commandFailures = countCommandFailures(out.output);
+  const generatedAt = new Date().toISOString();
+  const summary = verdict === "PASS" ? "All required proofs (compile, test, lint, diff, runtime) were demonstrated by the verifier." : verdict === "FAIL" ? "The verifier found failing evidence. See subagent output for details." : "The verifier could not reach a definitive PASS/FAIL verdict.";
+  const result = {
+    verdict,
+    summary,
+    commandFailures,
+    gateResults: gateRun.results,
+    subagentOutput: out.output,
+    generatedAt
+  };
+  const record3 = {
+    version: 1,
+    verdict,
+    summary,
+    commandFailures,
+    generatedAt
+  };
+  if (!options2.dryRun) {
+    saveVerificationRecord(cwd2, name, record3);
+    writeVerificationReport(cwd2, name, result);
+  }
+  return result;
+}
+var RECORD_FILE = "verification.json", REPORT_FILE = "verification.md", MAX_DIFF_CHARS = 12000;
+var init_specVerifier = __esm(() => {
+  init_execFileNoThrow();
+  init_json();
+  init_cliStepRunner();
+  init_headlessAgent();
+  init_projectGates();
+});
+
 // src/commands/spec/spec.ts
-var exports_spec = {};
-__export(exports_spec, {
+var exports_spec2 = {};
+__export(exports_spec2, {
   call: () => call71
 });
 function usage9() {
@@ -392738,7 +393652,8 @@ function usage9() {
     "  ur spec approve <name> [requirements|design|tasks] [--json]",
     "  ur spec generate <name> [requirements|design|tasks] [--dry-run] [--max-turns N] [--json]",
     "  ur spec next <name> [--json]",
-    "  ur spec run <name> [--all] [--dry-run] [--max-turns N] [--skip-permissions] [--json]",
+    "  ur spec run <name> [--all] [--dry-run] [--max-turns N] [--skip-permissions] [--kernel] [--json]",
+    "  ur spec verify <name> [--dry-run] [--max-turns N] [--skip-permissions] [--kernel] [--json]",
     "  ur spec delete <name> [--json]"
   ].join(`
 `);
@@ -392846,6 +393761,7 @@ var PHASES, VALUE_FLAGS, call71 = async (args) => {
   if (action3 === "run") {
     const maxTurnsRaw = option10(tokens, "--max-turns");
     const events2 = [];
+    const useKernel = tokens.includes("--kernel");
     try {
       const result = await runSpec2(cwd2, name, {
         cwd: cwd2,
@@ -392853,6 +393769,7 @@ var PHASES, VALUE_FLAGS, call71 = async (args) => {
         dryRun: tokens.includes("--dry-run"),
         skipPermissions: tokens.includes("--skip-permissions"),
         maxTurns: maxTurnsRaw ? Number(maxTurnsRaw) : undefined,
+        kernel: useKernel ? createAgentKernel({ cwd: cwd2, dryRun: tokens.includes("--dry-run"), maxTurns: maxTurnsRaw ? Number(maxTurnsRaw) : undefined, skipPermissions: tokens.includes("--skip-permissions") }) : undefined,
         onEvent: (event) => {
           events2.push(`  ${event.id}: ${event.isError ? "error" : event.verdict ?? "no verdict"}`);
         }
@@ -392877,6 +393794,41 @@ ${ran}${trace4}`
       return { type: "text", value: error40 instanceof Error ? error40.message : String(error40) };
     }
   }
+  if (action3 === "verify") {
+    const meta = loadSpec(cwd2, name);
+    if (!meta)
+      return { type: "text", value: notFound2(name) };
+    const maxTurnsRaw = option10(tokens, "--max-turns");
+    const useKernel = tokens.includes("--kernel");
+    try {
+      const result = await runSpecVerification(cwd2, name, {
+        dryRun: tokens.includes("--dry-run"),
+        skipPermissions: tokens.includes("--skip-permissions"),
+        maxTurns: maxTurnsRaw ? Number(maxTurnsRaw) : undefined,
+        kernel: useKernel ? createAgentKernel({ cwd: cwd2, dryRun: tokens.includes("--dry-run"), maxTurns: maxTurnsRaw ? Number(maxTurnsRaw) : undefined, skipPermissions: tokens.includes("--skip-permissions") }) : undefined
+      });
+      if (json2)
+        return { type: "text", value: JSON.stringify(result, null, 2) };
+      const gateLines = result.gateResults.length ? result.gateResults.map((g) => `  ${g.ok ? "\u2713" : "\u2717"} ${g.command}`).join(`
+`) : "  (no project gates configured)";
+      return {
+        type: "text",
+        value: [
+          `Spec ${name}: verification ${result.verdict}`,
+          `Summary: ${result.summary}`,
+          `Command failures: ${result.commandFailures}`,
+          "",
+          "Gates:",
+          gateLines,
+          "",
+          "Report: .ur/specs/verification.md"
+        ].join(`
+`)
+      };
+    } catch (error40) {
+      return { type: "text", value: error40 instanceof Error ? error40.message : String(error40) };
+    }
+  }
   if (action3 === "delete" || action3 === "remove") {
     const deleted = deleteSpec(cwd2, name);
     return {
@@ -392888,6 +393840,8 @@ ${ran}${trace4}`
 };
 var init_spec2 = __esm(() => {
   init_spec();
+  init_kernel();
+  init_specVerifier();
   init_argumentSubstitution();
   init_cwd2();
   PHASES = ["requirements", "design", "tasks"];
@@ -392901,17 +393855,17 @@ var init_spec3 = __esm(() => {
     type: "local",
     name: "spec",
     aliases: ["specs"],
-    description: "Spec-driven development: scaffold requirements -> design -> tasks in .ur/specs and drive execution task-by-task",
-    argumentHint: "init|list|show|generate|approve|next|run|status|delete [name] [--goal ...] [--all] [--dry-run] [--json]",
+    description: "Spec-driven development: scaffold requirements -> design -> tasks in .ur/specs, execute task-by-task, and verify with strict proof gates",
+    argumentHint: "init|list|show|generate|approve|next|run|verify|status|delete [name] [--goal ...] [--all] [--dry-run] [--kernel] [--json]",
     supportsNonInteractive: true,
-    load: () => Promise.resolve().then(() => (init_spec2(), exports_spec))
+    load: () => Promise.resolve().then(() => (init_spec2(), exports_spec2))
   };
   spec_default = spec;
 });
 
 // src/services/agents/escalation.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync27, readFileSync as readFileSync35, writeFileSync as writeFileSync25 } from "fs";
-import { join as join147 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync28, readFileSync as readFileSync37, writeFileSync as writeFileSync26 } from "fs";
+import { join as join149 } from "path";
 function scoreOracle(model) {
   let score = (model.contextLength ?? 0) / 1000;
   if (model.likelyCode)
@@ -393081,18 +394035,18 @@ ${question}`,
   return { model: tiers.oracle, output: out.output, verdict: out.verdict ?? null };
 }
 function policyPath(cwd2) {
-  return join147(cwd2, ".ur", "escalation.json");
+  return join149(cwd2, ".ur", "escalation.json");
 }
 function loadPolicy(cwd2) {
   const path22 = policyPath(cwd2);
-  if (!existsSync27(path22))
+  if (!existsSync29(path22))
     return {};
-  const parsed = safeParseJSON(readFileSync35(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync37(path22, "utf-8"), false);
   return parsed && typeof parsed === "object" ? parsed : {};
 }
 function savePolicy(cwd2, policy) {
-  mkdirSync27(join147(cwd2, ".ur"), { recursive: true });
-  writeFileSync25(policyPath(cwd2), `${JSON.stringify(policy, null, 2)}
+  mkdirSync28(join149(cwd2, ".ur"), { recursive: true });
+  writeFileSync26(policyPath(cwd2), `${JSON.stringify(policy, null, 2)}
 `);
 }
 function formatPlan(plan, json2) {
@@ -393140,29 +394094,29 @@ var init_escalation = __esm(() => {
 
 // src/services/agents/artifacts.ts
 import {
-  existsSync as existsSync28,
-  mkdirSync as mkdirSync28,
-  readFileSync as readFileSync36,
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync29,
+  readFileSync as readFileSync38,
   rmSync as rmSync6,
-  writeFileSync as writeFileSync26
+  writeFileSync as writeFileSync27
 } from "fs";
-import { join as join148 } from "path";
+import { join as join150 } from "path";
 function artifactsDir(cwd2) {
-  return join148(cwd2, ".ur", "artifacts");
+  return join150(cwd2, ".ur", "artifacts");
 }
 function manifestPath4(cwd2) {
-  return join148(artifactsDir(cwd2), "manifest.json");
+  return join150(artifactsDir(cwd2), "manifest.json");
 }
 function loadManifest3(cwd2) {
   const path22 = manifestPath4(cwd2);
-  if (!existsSync28(path22))
+  if (!existsSync30(path22))
     return { version: 1, artifacts: [] };
-  const parsed = safeParseJSON(readFileSync36(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync38(path22, "utf-8"), false);
   return parsed && typeof parsed === "object" && Array.isArray(parsed.artifacts) ? parsed : { version: 1, artifacts: [] };
 }
 function saveManifest3(cwd2, manifest) {
-  mkdirSync28(artifactsDir(cwd2), { recursive: true });
-  writeFileSync26(manifestPath4(cwd2), `${JSON.stringify(manifest, null, 2)}
+  mkdirSync29(artifactsDir(cwd2), { recursive: true });
+  writeFileSync27(manifestPath4(cwd2), `${JSON.stringify(manifest, null, 2)}
 `);
 }
 function nextId2(manifest) {
@@ -393178,10 +394132,10 @@ function recordArtifact(cwd2, input) {
   const now6 = new Date().toISOString();
   let file2 = input.file;
   if (input.body !== undefined && !file2) {
-    const dir = join148(artifactsDir(cwd2), "files");
-    mkdirSync28(dir, { recursive: true });
-    const rel = join148("files", `${id}-${slug2(input.title)}.${EXT[input.kind]}`);
-    writeFileSync26(join148(artifactsDir(cwd2), rel), input.body);
+    const dir = join150(artifactsDir(cwd2), "files");
+    mkdirSync29(dir, { recursive: true });
+    const rel = join150("files", `${id}-${slug2(input.title)}.${EXT[input.kind]}`);
+    writeFileSync27(join150(artifactsDir(cwd2), rel), input.body);
     file2 = rel;
   }
   const artifact = {
@@ -393210,8 +394164,8 @@ function readArtifactBody(cwd2, id) {
   const artifact = getArtifact(cwd2, id);
   if (!artifact?.file)
     return null;
-  const path22 = join148(artifactsDir(cwd2), artifact.file);
-  return existsSync28(path22) ? readFileSync36(path22, "utf-8") : null;
+  const path22 = join150(artifactsDir(cwd2), artifact.file);
+  return existsSync30(path22) ? readFileSync38(path22, "utf-8") : null;
 }
 function mutate2(cwd2, id, fn) {
   const manifest = loadManifest3(cwd2);
@@ -393239,12 +394193,12 @@ function deleteArtifact(cwd2, id) {
   if (!artifact)
     return false;
   if (artifact.file)
-    rmSync6(join148(artifactsDir(cwd2), artifact.file), { force: true });
+    rmSync6(join150(artifactsDir(cwd2), artifact.file), { force: true });
   manifest.artifacts = manifest.artifacts.filter((a2) => a2.id !== id);
   saveManifest3(cwd2, manifest);
   return true;
 }
-async function captureDiff(cwd2, title = "Working tree diff", exec6 = defaultExec) {
+async function captureDiff2(cwd2, title = "Working tree diff", exec6 = defaultExec) {
   const diff3 = await exec6("git", ["diff", "HEAD"], cwd2);
   if (!diff3.stdout.trim())
     return null;
@@ -393330,8 +394284,8 @@ var init_artifacts = __esm(() => {
 });
 
 // src/services/agents/learning.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync29, readFileSync as readFileSync37, writeFileSync as writeFileSync27 } from "fs";
-import { join as join149 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync30, readFileSync as readFileSync39, writeFileSync as writeFileSync28 } from "fs";
+import { join as join151 } from "path";
 function emptyStats() {
   return {
     version: 1,
@@ -393440,23 +394394,23 @@ function difficultyBias(stats, category, minSamples = 3) {
   return 4;
 }
 function learningDir(cwd2) {
-  return join149(cwd2, ".ur", "learning");
+  return join151(cwd2, ".ur", "learning");
 }
 function statsPath(cwd2) {
-  return join149(learningDir(cwd2), "stats.json");
+  return join151(learningDir(cwd2), "stats.json");
 }
 function loadStats(cwd2) {
   const path22 = statsPath(cwd2);
-  if (!existsSync29(path22))
+  if (!existsSync31(path22))
     return emptyStats();
-  const parsed = safeParseJSON(readFileSync37(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync39(path22, "utf-8"), false);
   if (!parsed || typeof parsed !== "object")
     return emptyStats();
   return { ...emptyStats(), ...parsed };
 }
 function saveStats(cwd2, stats) {
-  mkdirSync29(learningDir(cwd2), { recursive: true });
-  writeFileSync27(statsPath(cwd2), `${JSON.stringify(stats, null, 2)}
+  mkdirSync30(learningDir(cwd2), { recursive: true });
+  writeFileSync28(statsPath(cwd2), `${JSON.stringify(stats, null, 2)}
 `);
 }
 async function reflectOnFailures(input) {
@@ -393784,7 +394738,7 @@ var exports_guardrails = {};
 __export(exports_guardrails, {
   call: () => call74
 });
-import { existsSync as existsSync30, readFileSync as readFileSync38 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync40 } from "fs";
 function optionValue4(tokens, flag) {
   const index2 = tokens.indexOf(flag);
   return index2 >= 0 ? tokens[index2 + 1] : undefined;
@@ -393850,10 +394804,10 @@ var call74 = async (args) => {
     const filePath = optionValue4(tokens, "--file");
     let text;
     if (filePath) {
-      if (!existsSync30(filePath)) {
+      if (!existsSync32(filePath)) {
         return { type: "text", value: `File not found: ${filePath}` };
       }
-      text = readFileSync38(filePath, "utf-8");
+      text = readFileSync40(filePath, "utf-8");
     } else {
       text = tokens.filter((token) => !token.startsWith("--") && token !== "check").join(" ");
     }
@@ -393891,8 +394845,8 @@ var init_guardrails3 = __esm(() => {
 });
 
 // src/services/agents/execTarget.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync30, readFileSync as readFileSync39, writeFileSync as writeFileSync28 } from "fs";
-import { join as join150 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync31, readFileSync as readFileSync41, writeFileSync as writeFileSync29 } from "fs";
+import { join as join152 } from "path";
 function isContainerized(config3) {
   return config3.kind !== "local";
 }
@@ -393916,13 +394870,13 @@ function wrapCommand(config3, command5, cwd2) {
   return { file: "docker", args: buildDockerArgs(config3, command5, cwd2) };
 }
 function configPath(cwd2) {
-  return join150(cwd2, ".ur", "devcontainer.json");
+  return join152(cwd2, ".ur", "devcontainer.json");
 }
 function readDevcontainerImage(cwd2) {
-  const path22 = join150(cwd2, ".devcontainer", "devcontainer.json");
-  if (!existsSync31(path22))
+  const path22 = join152(cwd2, ".devcontainer", "devcontainer.json");
+  if (!existsSync33(path22))
     return;
-  const parsed = safeParseJSON(readFileSync39(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync41(path22, "utf-8"), false);
   if (parsed && typeof parsed === "object" && typeof parsed.image === "string") {
     return parsed.image;
   }
@@ -393940,8 +394894,8 @@ function resolveExecTarget(cwd2, env4 = process.env) {
   if (envKind === "local")
     return { kind: "local" };
   const path22 = configPath(cwd2);
-  if (existsSync31(path22)) {
-    const parsed = safeParseJSON(readFileSync39(path22, "utf-8"), false);
+  if (existsSync33(path22)) {
+    const parsed = safeParseJSON(readFileSync41(path22, "utf-8"), false);
     if (parsed && typeof parsed === "object") {
       const config3 = parsed;
       if (config3.kind === "devcontainer" && !config3.image) {
@@ -393959,10 +394913,10 @@ function defaultExecTargetConfig(image = "node:22-bookworm") {
 }
 function scaffoldExecTarget(cwd2, options2 = {}) {
   const path22 = configPath(cwd2);
-  mkdirSync30(join150(cwd2, ".ur"), { recursive: true });
-  if (existsSync31(path22) && options2.force !== true)
+  mkdirSync31(join152(cwd2, ".ur"), { recursive: true });
+  if (existsSync33(path22) && options2.force !== true)
     return { path: path22, created: false };
-  writeFileSync28(path22, `${JSON.stringify(defaultExecTargetConfig(options2.image), null, 2)}
+  writeFileSync29(path22, `${JSON.stringify(defaultExecTargetConfig(options2.image), null, 2)}
 `);
   return { path: path22, created: true };
 }
@@ -394089,12 +395043,12 @@ var init_devcontainer2 = __esm(() => {
 
 // src/services/agents/arena.ts
 import {
-  existsSync as existsSync32,
-  mkdirSync as mkdirSync31,
+  existsSync as existsSync34,
+  mkdirSync as mkdirSync32,
   rmSync as rmSync7,
-  writeFileSync as writeFileSync29
+  writeFileSync as writeFileSync30
 } from "fs";
-import { join as join151 } from "path";
+import { join as join153 } from "path";
 function countChangedLines(diff3) {
   let count4 = 0;
   for (const line of diff3.split(`
@@ -394164,16 +395118,16 @@ async function git4(cwd2, args) {
   });
 }
 async function ensureWorktree2(cwd2, runId, id) {
-  const root2 = join151(cwd2, ".ur", "arena", ".worktrees");
-  const path22 = join151(root2, `${runId}-${id}`);
+  const root2 = join153(cwd2, ".ur", "arena", ".worktrees");
+  const path22 = join153(root2, `${runId}-${id}`);
   const branch = `ur/arena/${runId}/${id}`;
-  if (existsSync32(path22))
+  if (existsSync34(path22))
     return path22;
-  mkdirSync31(root2, { recursive: true });
+  mkdirSync32(root2, { recursive: true });
   const result = await git4(cwd2, ["worktree", "add", "-b", branch, path22]);
   return result.code === 0 ? path22 : null;
 }
-async function captureDiff2(worktree2) {
+async function captureDiff3(worktree2) {
   await git4(worktree2, ["add", "-A"]);
   const diff3 = await git4(worktree2, ["diff", "--cached"]);
   return diff3.code === 0 ? diff3.stdout : "";
@@ -394209,7 +395163,7 @@ Implement this fully and correctly. Make focused changes. End your reply with VE
       maxTurns: options2.maxTurns,
       skipPermissions: options2.skipPermissions
     });
-    const diff3 = worktree2 && !options2.dryRun ? await captureDiff2(worktree2) : "";
+    const diff3 = worktree2 && !options2.dryRun ? await captureDiff3(worktree2) : "";
     options2.onEvent?.({ kind: "done", id, verdict: out.verdict ?? null, isError: !!out.isError });
     return {
       id,
@@ -394224,9 +395178,9 @@ Implement this fully and correctly. Make focused changes. End your reply with VE
   const { ranked, winner } = judge(candidates2);
   let applied = false;
   if (options2.apply && winner && winner.diff.trim() && !options2.dryRun) {
-    const patch = join151(cwd2, ".ur", "arena", `${runId}-winner.patch`);
-    mkdirSync31(join151(cwd2, ".ur", "arena"), { recursive: true });
-    writeFileSync29(patch, winner.diff);
+    const patch = join153(cwd2, ".ur", "arena", `${runId}-winner.patch`);
+    mkdirSync32(join153(cwd2, ".ur", "arena"), { recursive: true });
+    writeFileSync30(patch, winner.diff);
     const result = await git4(cwd2, ["apply", "--3way", patch]);
     applied = result.code === 0;
     if (applied)
@@ -394475,7 +395429,7 @@ var exports_ci_loop = {};
 __export(exports_ci_loop, {
   call: () => call77
 });
-import { existsSync as existsSync33, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync42 } from "fs";
 function option13(tokens, name) {
   const index2 = tokens.indexOf(name);
   return index2 === -1 ? undefined : tokens[index2 + 1];
@@ -394489,10 +395443,10 @@ var call77 = async (args) => {
   const fromLog = option13(tokens, "--from-log");
   let seedError;
   if (fromLog) {
-    if (!existsSync33(fromLog)) {
+    if (!existsSync35(fromLog)) {
       return { type: "text", value: `Log file not found: ${fromLog}` };
     }
-    seedError = readFileSync40(fromLog, "utf-8");
+    seedError = readFileSync42(fromLog, "utf-8");
   }
   const cwd2 = getCwd();
   const target = resolveExecTarget(cwd2);
@@ -394533,11 +395487,11 @@ var init_ci_loop2 = __esm(() => {
 });
 
 // src/ur/projectDna.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync32, readFileSync as readFileSync41, writeFileSync as writeFileSync30 } from "fs";
-import { join as join152 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync33, readFileSync as readFileSync43, writeFileSync as writeFileSync31 } from "fs";
+import { join as join154 } from "path";
 function readGitignoreDirs(cwd2) {
   try {
-    return readFileSync41(join152(cwd2, ".gitignore"), "utf8").split(`
+    return readFileSync43(join154(cwd2, ".gitignore"), "utf8").split(`
 `).map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).map((l) => l.replace(/^\//, "").replace(/\/$/, "")).filter((l) => l && !l.includes("*") && !l.includes(".")).slice(0, 12);
   } catch {
     return [];
@@ -394545,13 +395499,13 @@ function readGitignoreDirs(cwd2) {
 }
 function findReadme(cwd2) {
   for (const n2 of ["README.md", "README.rst", "README.txt", "README"])
-    if (existsSync34(join152(cwd2, n2)))
+    if (existsSync36(join154(cwd2, n2)))
       return n2;
   return null;
 }
 function readJson(path22) {
   try {
-    return JSON.parse(readFileSync41(path22, "utf8"));
+    return JSON.parse(readFileSync43(path22, "utf8"));
   } catch {
     return null;
   }
@@ -394575,7 +395529,7 @@ function detectProjectDna(cwd2) {
       packageManagers.add("npm");
     if (packageManagers.size === 0)
       packageManagers.add("npm");
-    const pkg = readJson(join152(cwd2, "package.json"));
+    const pkg = readJson(join154(cwd2, "package.json"));
     const scripts = pkg?.scripts ?? {};
     const pm = [...packageManagers][0] ?? "npm";
     const run = (s) => pm === "npm" ? `npm run ${s}` : `${pm} run ${s}`;
@@ -394622,7 +395576,7 @@ function detectProjectDna(cwd2) {
     runCommands.add("python main.py");
   if (has(cwd2, "Makefile"))
     buildCommands.add("make");
-  const importantFolders = ["src", "lib", "tests", "test", "app", "packages"].filter((d) => existsSync34(join152(cwd2, d)));
+  const importantFolders = ["src", "lib", "tests", "test", "app", "packages"].filter((d) => existsSync36(join154(cwd2, d)));
   return {
     languages: [...languages],
     packageManagers: [...packageManagers],
@@ -394633,7 +395587,7 @@ function detectProjectDna(cwd2) {
     importantFolders,
     ignoredFolders: readGitignoreDirs(cwd2),
     readme: findReadme(cwd2),
-    hasGit: existsSync34(join152(cwd2, ".git"))
+    hasGit: existsSync36(join154(cwd2, ".git"))
   };
 }
 function formatDna(dna) {
@@ -394656,23 +395610,23 @@ function formatDna(dna) {
 function writeDna(cwd2) {
   const md = formatDna(detectProjectDna(cwd2));
   try {
-    mkdirSync32(join152(cwd2, ".ur"), { recursive: true });
-    writeFileSync30(join152(cwd2, ".ur", "project_dna.md"), md + `
+    mkdirSync33(join154(cwd2, ".ur"), { recursive: true });
+    writeFileSync31(join154(cwd2, ".ur", "project_dna.md"), md + `
 `);
   } catch {}
   return md;
 }
-var has = (cwd2, ...names) => names.some((n2) => existsSync34(join152(cwd2, n2)));
+var has = (cwd2, ...names) => names.some((n2) => existsSync36(join154(cwd2, n2)));
 var init_projectDna = () => {};
 
 // src/services/agents/testFirstLoop.ts
 import {
-  existsSync as existsSync35,
-  mkdirSync as mkdirSync33,
-  readFileSync as readFileSync42,
-  writeFileSync as writeFileSync31
+  existsSync as existsSync37,
+  mkdirSync as mkdirSync34,
+  readFileSync as readFileSync44,
+  writeFileSync as writeFileSync32
 } from "fs";
-import { dirname as dirname57, join as join153, relative as relative31 } from "path";
+import { dirname as dirname57, join as join155, relative as relative31 } from "path";
 function uniqueCommands(commands) {
   const seen = new Set;
   const out = [];
@@ -394687,7 +395641,7 @@ function uniqueCommands(commands) {
 }
 function readPackageScripts(cwd2) {
   try {
-    const parsed = JSON.parse(readFileSync42(join153(cwd2, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync44(join155(cwd2, "package.json"), "utf8"));
     if (!parsed.scripts || typeof parsed.scripts !== "object")
       return {};
     return parsed.scripts;
@@ -394726,7 +395680,7 @@ function detectTestFirstStack(cwd2) {
   for (const command5 of dna.lintCommands) {
     commands.push({ phase: "lint", command: command5, source: "project-dna lint" });
   }
-  if (existsSync35(join153(cwd2, "package.json"))) {
+  if (existsSync37(join155(cwd2, "package.json"))) {
     const scripts = readPackageScripts(cwd2);
     const pm = primaryNodePackageManager(dna.packageManagers);
     if (!commands.some((command5) => command5.phase === "compile")) {
@@ -394736,7 +395690,7 @@ function detectTestFirstStack(cwd2) {
           command: runScript(pm, "typecheck"),
           source: "package.json script:typecheck"
         });
-      } else if (existsSync35(join153(cwd2, "tsconfig.json"))) {
+      } else if (existsSync37(join155(cwd2, "tsconfig.json"))) {
         commands.push({
           phase: "compile",
           command: tscCommand(pm),
@@ -394778,15 +395732,15 @@ function detectTestFirstStack(cwd2) {
   };
 }
 function defaultTraceDir(cwd2) {
-  return join153(cwd2, ".ur", "test-first", "traces");
+  return join155(cwd2, ".ur", "test-first", "traces");
 }
 function slug3(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 72) || "command";
 }
 function writeFailureTrace(cwd2, traceDir, run, result, now6) {
-  mkdirSync33(traceDir, { recursive: true });
+  mkdirSync34(traceDir, { recursive: true });
   const stamp = now6.toISOString().replace(/[:.]/g, "-");
-  const file2 = join153(traceDir, `${stamp}-attempt-${run.attempt}-${run.phase}-${slug3(run.command)}.log`);
+  const file2 = join155(traceDir, `${stamp}-attempt-${run.attempt}-${run.phase}-${slug3(run.command)}.log`);
   const body = [
     "# UR test-first failure trace",
     "",
@@ -394805,12 +395759,12 @@ function writeFailureTrace(cwd2, traceDir, run, result, now6) {
     ""
   ].join(`
 `);
-  writeFileSync31(file2, body);
+  writeFileSync32(file2, body);
   return relative31(cwd2, file2);
 }
 function readExistingVerifyConfig(path22) {
   try {
-    const parsed = JSON.parse(readFileSync42(path22, "utf8"));
+    const parsed = JSON.parse(readFileSync44(path22, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -394828,8 +395782,8 @@ function mergeStringArray(existing, additions) {
   return [...out];
 }
 function installTestFirstGates(cwd2, stack = detectTestFirstStack(cwd2)) {
-  const path22 = join153(cwd2, ".ur", "verify.json");
-  mkdirSync33(dirname57(path22), { recursive: true });
+  const path22 = join155(cwd2, ".ur", "verify.json");
+  mkdirSync34(dirname57(path22), { recursive: true });
   const commands = stack.commands.map((command5) => command5.command);
   const existing = readExistingVerifyConfig(path22);
   const next = {
@@ -394837,7 +395791,7 @@ function installTestFirstGates(cwd2, stack = detectTestFirstStack(cwd2)) {
     afterEdit: mergeStringArray(existing.afterEdit, commands),
     timeoutMs: typeof existing.timeoutMs === "number" && existing.timeoutMs > 0 ? existing.timeoutMs : 600000
   };
-  writeFileSync31(path22, `${JSON.stringify(next, null, 2)}
+  writeFileSync32(path22, `${JSON.stringify(next, null, 2)}
 `);
   return { path: relative31(cwd2, path22), commands };
 }
@@ -395183,36 +396137,36 @@ var init_safety2 = __esm(() => {
 
 // src/services/context/projectContextManifest.ts
 import {
-  existsSync as existsSync36,
-  mkdirSync as mkdirSync34,
-  readFileSync as readFileSync43,
+  existsSync as existsSync38,
+  mkdirSync as mkdirSync35,
+  readFileSync as readFileSync45,
   readdirSync as readdirSync14,
-  writeFileSync as writeFileSync32
+  writeFileSync as writeFileSync33
 } from "fs";
-import { dirname as dirname58, join as join154, relative as relative32 } from "path";
+import { dirname as dirname58, join as join156, relative as relative32 } from "path";
 function contextDir(cwd2) {
-  return join154(cwd2, ".ur", "context");
+  return join156(cwd2, ".ur", "context");
 }
 function projectManifestPath(cwd2) {
-  return join154(cwd2, ".ur", "project-manifest.json");
+  return join156(cwd2, ".ur", "project-manifest.json");
 }
 function taskMemoryPath(cwd2) {
-  return join154(contextDir(cwd2), "task-memory.jsonl");
+  return join156(contextDir(cwd2), "task-memory.jsonl");
 }
 function compressedContextPath(cwd2) {
-  return join154(contextDir(cwd2), "compressed.md");
+  return join156(contextDir(cwd2), "compressed.md");
 }
 function architectureSummaryPath(cwd2) {
-  return join154(contextDir(cwd2), "architecture.md");
+  return join156(contextDir(cwd2), "architecture.md");
 }
 function readPackage(cwd2) {
-  const path22 = join154(cwd2, "package.json");
-  if (!existsSync36(path22))
+  const path22 = join156(cwd2, "package.json");
+  if (!existsSync38(path22))
     return null;
-  return safeParseJSON(readFileSync43(path22, "utf8"), false);
+  return safeParseJSON(readFileSync45(path22, "utf8"), false);
 }
 function existing(cwd2, names) {
-  return names.filter((name) => existsSync36(join154(cwd2, name)));
+  return names.filter((name) => existsSync38(join156(cwd2, name)));
 }
 function packageScripts(pkg, matcher) {
   const scripts = pkg?.scripts;
@@ -395261,19 +396215,19 @@ function buildProjectContextManifest(cwd2) {
       "Keep generated runtime state under .ur/ unless a command documents another path."
     ],
     constraints: [
-      existsSync36(safetyPolicyPath(cwd2)) ? "Project safety policy is configured." : "Default safety policy applies until .ur/safety-policy.json is written.",
-      existsSync36(join154(cwd2, ".ur", "verify.json")) ? "Project verify gates are configured." : "No project verify gate file detected.",
+      existsSync38(safetyPolicyPath(cwd2)) ? "Project safety policy is configured." : "Default safety policy applies until .ur/safety-policy.json is written.",
+      existsSync38(join156(cwd2, ".ur", "verify.json")) ? "Project verify gates are configured." : "No project verify gate file detected.",
       "Do not expose secret-like files or environment values in command output."
     ]
   };
 }
 function writeProjectContextManifest(cwd2) {
   const manifest = buildProjectContextManifest(cwd2);
-  mkdirSync34(dirname58(projectManifestPath(cwd2)), { recursive: true });
-  writeFileSync32(projectManifestPath(cwd2), `${JSON.stringify(manifest, null, 2)}
+  mkdirSync35(dirname58(projectManifestPath(cwd2)), { recursive: true });
+  writeFileSync33(projectManifestPath(cwd2), `${JSON.stringify(manifest, null, 2)}
 `);
-  mkdirSync34(contextDir(cwd2), { recursive: true });
-  writeFileSync32(architectureSummaryPath(cwd2), formatArchitectureSummary(manifest, cwd2));
+  mkdirSync35(contextDir(cwd2), { recursive: true });
+  writeFileSync33(architectureSummaryPath(cwd2), formatArchitectureSummary(manifest, cwd2));
   return manifest;
 }
 function formatArchitectureSummary(manifest, cwd2) {
@@ -395287,7 +396241,7 @@ function formatArchitectureSummary(manifest, cwd2) {
     importantFolders: manifest.project.importantFolders,
     ignoredFolders: [],
     readme: manifest.project.readme,
-    hasGit: existsSync36(join154(cwd2, ".git"))
+    hasGit: existsSync38(join156(cwd2, ".git"))
   });
   return [
     "# Project Architecture Context",
@@ -395316,16 +396270,16 @@ function appendTaskMemory(cwd2, kind, text) {
     kind,
     text
   };
-  mkdirSync34(dirname58(taskMemoryPath(cwd2)), { recursive: true });
-  writeFileSync32(taskMemoryPath(cwd2), `${JSON.stringify(entry)}
+  mkdirSync35(dirname58(taskMemoryPath(cwd2)), { recursive: true });
+  writeFileSync33(taskMemoryPath(cwd2), `${JSON.stringify(entry)}
 `, { flag: "a" });
   return entry;
 }
 function readTaskMemory(cwd2) {
   const path22 = taskMemoryPath(cwd2);
-  if (!existsSync36(path22))
+  if (!existsSync38(path22))
     return [];
-  return readFileSync43(path22, "utf8").split(`
+  return readFileSync45(path22, "utf8").split(`
 `).filter(Boolean).map((line) => safeParseJSON(line, false)).filter((entry) => Boolean(entry && typeof entry === "object" && typeof entry.kind === "string" && typeof entry.text === "string"));
 }
 function compressTaskMemory(cwd2) {
@@ -395354,8 +396308,8 @@ function compressTaskMemory(cwd2) {
   const body = `${lines.join(`
 `)}
 `;
-  mkdirSync34(dirname58(compressedContextPath(cwd2)), { recursive: true });
-  writeFileSync32(compressedContextPath(cwd2), body);
+  mkdirSync35(dirname58(compressedContextPath(cwd2)), { recursive: true });
+  writeFileSync33(compressedContextPath(cwd2), body);
   return body;
 }
 function contextStatus(cwd2) {
@@ -395365,10 +396319,10 @@ function contextStatus(cwd2) {
     taskMemoryPath(cwd2),
     compressedContextPath(cwd2)
   ];
-  const contextFiles = existsSync36(contextDir(cwd2)) ? readdirSync14(contextDir(cwd2)) : [];
+  const contextFiles = existsSync38(contextDir(cwd2)) ? readdirSync14(contextDir(cwd2)) : [];
   return [
     "Project context status:",
-    ...files.map((path22) => `  ${existsSync36(path22) ? "yes" : "no "} ${relative32(cwd2, path22)}`),
+    ...files.map((path22) => `  ${existsSync38(path22) ? "yes" : "no "} ${relative32(cwd2, path22)}`),
     `  context files: ${contextFiles.length}`
   ].join(`
 `);
@@ -395580,7 +396534,7 @@ var KINDS, call81 = async (args) => {
     };
   }
   if (action3 === "capture-diff") {
-    const artifact = await captureDiff(cwd2, option17(tokens, "--title") ?? "Working tree diff");
+    const artifact = await captureDiff2(cwd2, option17(tokens, "--title") ?? "Working tree diff");
     return {
       type: "text",
       value: artifact ? json2 ? JSON.stringify(artifact, null, 2) : `Captured diff as artifact ${artifact.id} (${artifact.summary}).` : "No working-tree changes to capture."
@@ -395797,7 +396751,7 @@ var exports_trigger = {};
 __export(exports_trigger, {
   call: () => call82
 });
-import { existsSync as existsSync37, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync46 } from "fs";
 function option18(tokens, name) {
   const index2 = tokens.indexOf(name);
   if (index2 === -1)
@@ -395833,10 +396787,10 @@ var call82 = async (args) => {
 
 ${usage17()}` };
   }
-  if (!existsSync37(file2)) {
+  if (!existsSync39(file2)) {
     return { type: "text", value: `Payload file not found: ${file2}` };
   }
-  const payload = safeParseJSON(readFileSync44(file2, "utf-8"), false);
+  const payload = safeParseJSON(readFileSync46(file2, "utf-8"), false);
   if (payload === null || typeof payload !== "object") {
     return { type: "text", value: `Payload is not valid JSON: ${file2}` };
   }
@@ -395895,8 +396849,8 @@ var exports_sdk = {};
 __export(exports_sdk, {
   call: () => call83
 });
-import { existsSync as existsSync38, mkdirSync as mkdirSync35, writeFileSync as writeFileSync33 } from "fs";
-import { join as join155 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync36, writeFileSync as writeFileSync34 } from "fs";
+import { join as join157 } from "path";
 function infoText() {
   return [
     "UR SDK \u2014 drive UR programmatically (headless).",
@@ -395976,8 +396930,8 @@ A2A server: \`ur a2a serve\`.
   const force = tokens.includes("--force");
   const action3 = tokens.find((token) => !token.startsWith("--")) ?? "info";
   if (action3 === "init") {
-    const root2 = join155(getCwd(), ".ur", "sdk");
-    mkdirSync35(root2, { recursive: true });
+    const root2 = join157(getCwd(), ".ur", "sdk");
+    mkdirSync36(root2, { recursive: true });
     const files = [
       ["example.ts", TS_EXAMPLE],
       ["example.py", PY_EXAMPLE],
@@ -395986,12 +396940,12 @@ A2A server: \`ur a2a serve\`.
     const created = [];
     const skipped = [];
     for (const [name, content] of files) {
-      const path22 = join155(root2, name);
-      if (!force && existsSync38(path22)) {
+      const path22 = join157(root2, name);
+      if (!force && existsSync40(path22)) {
         skipped.push(name);
         continue;
       }
-      writeFileSync33(path22, content);
+      writeFileSync34(path22, content);
       created.push(name);
     }
     return {
@@ -396060,14 +397014,14 @@ __export(exports_evals, {
   BENCHMARK_ADAPTERS: () => BENCHMARK_ADAPTERS
 });
 import {
-  existsSync as existsSync39,
-  mkdirSync as mkdirSync36,
-  readFileSync as readFileSync45,
+  existsSync as existsSync41,
+  mkdirSync as mkdirSync37,
+  readFileSync as readFileSync47,
   readdirSync as readdirSync15,
   rmSync as rmSync8,
-  writeFileSync as writeFileSync34
+  writeFileSync as writeFileSync35
 } from "fs";
-import { join as join156 } from "path";
+import { join as join158 } from "path";
 function hasAnyExpectation(expect) {
   return Boolean(expect.contains?.length || expect.notContains?.length || expect.regex?.length || expect.verdict || typeof expect.maxOutputChars === "number");
 }
@@ -396322,13 +397276,13 @@ async function runSuiteReliability(suite, runner2, options2) {
   };
 }
 function metricsFile() {
-  return join156(process.env.UR_EVAL_METRICS_DIR ?? process.cwd(), `.ur-eval-metrics-${process.pid}.json`);
+  return join158(process.env.UR_EVAL_METRICS_DIR ?? process.cwd(), `.ur-eval-metrics-${process.pid}.json`);
 }
 function readChildMetricsFile(path22) {
-  if (!existsSync39(path22))
+  if (!existsSync41(path22))
     return;
   try {
-    const parsed = safeParseJSON(readFileSync45(path22, "utf-8"), false);
+    const parsed = safeParseJSON(readFileSync47(path22, "utf-8"), false);
     if (parsed && typeof parsed === "object")
       return parsed;
   } catch {}
@@ -396379,7 +397333,7 @@ async function runTestCommand(cwd2, command5) {
     testStderr: result.stderr || result.error || ""
   };
 }
-function countCommandFailures(output) {
+function countCommandFailures2(output) {
   const markers = ["[ERROR]", "Command failed", "exit code 1", "Error:", "FAILED"];
   let count4 = 0;
   const lower = output.toLowerCase();
@@ -396453,7 +397407,7 @@ function makeCliEvalRunner(options2) {
       testCommand: testResult?.testCommand,
       testStdout: testResult?.testStdout,
       testStderr: testResult?.testStderr,
-      commandFailures: countCommandFailures(output),
+      commandFailures: countCommandFailures2(output),
       humanEditsNeeded: countHumanEdits(output)
     };
     return { output, isError: result.code !== 0, metrics };
@@ -396563,13 +397517,13 @@ ${body}</body></html>
 }
 function loadAllReports(cwd2) {
   const dir = resultsDir(cwd2);
-  if (!existsSync39(dir))
+  if (!existsSync41(dir))
     return [];
   const reports = [];
   for (const file2 of readdirSync15(dir)) {
     if (!file2.endsWith(".json") || file2.startsWith("reliability-"))
       continue;
-    const parsed = safeParseJSON(readFileSync45(join156(dir, file2), "utf-8"), false);
+    const parsed = safeParseJSON(readFileSync47(join158(dir, file2), "utf-8"), false);
     if (parsed && typeof parsed === "object")
       reports.push(parsed);
   }
@@ -396577,48 +397531,48 @@ function loadAllReports(cwd2) {
 }
 function loadAllReliability(cwd2) {
   const dir = resultsDir(cwd2);
-  if (!existsSync39(dir))
+  if (!existsSync41(dir))
     return [];
   const reports = [];
   for (const file2 of readdirSync15(dir)) {
     if (!file2.startsWith("reliability-") || !file2.endsWith(".json"))
       continue;
-    const parsed = safeParseJSON(readFileSync45(join156(dir, file2), "utf-8"), false);
+    const parsed = safeParseJSON(readFileSync47(join158(dir, file2), "utf-8"), false);
     if (parsed && typeof parsed === "object")
       reports.push(parsed);
   }
   return reports.sort((a2, b) => a2.name.localeCompare(b.name));
 }
 function saveReliabilityReport(cwd2, report) {
-  mkdirSync36(resultsDir(cwd2), { recursive: true });
-  const path22 = join156(resultsDir(cwd2), `reliability-${suiteSlug(report.name)}.json`);
-  writeFileSync34(path22, `${JSON.stringify(report, null, 2)}
+  mkdirSync37(resultsDir(cwd2), { recursive: true });
+  const path22 = join158(resultsDir(cwd2), `reliability-${suiteSlug(report.name)}.json`);
+  writeFileSync35(path22, `${JSON.stringify(report, null, 2)}
 `);
   return path22;
 }
 function writeDashboard(cwd2) {
   const html3 = buildDashboardHtml(loadAllReports(cwd2), loadAllReliability(cwd2));
-  mkdirSync36(evalsDir(cwd2), { recursive: true });
-  const path22 = join156(evalsDir(cwd2), "dashboard.html");
-  writeFileSync34(path22, html3);
+  mkdirSync37(evalsDir(cwd2), { recursive: true });
+  const path22 = join158(evalsDir(cwd2), "dashboard.html");
+  writeFileSync35(path22, html3);
   return path22;
 }
 function runsDir(cwd2, suiteName) {
-  return join156(evalsDir(cwd2), ".runs", suiteSlug(suiteName));
+  return join158(evalsDir(cwd2), ".runs", suiteSlug(suiteName));
 }
 function writeRunMetrics(cwd2, suiteName, caseId, metrics) {
   const dir = runsDir(cwd2, suiteName);
-  mkdirSync36(dir, { recursive: true });
-  const path22 = join156(dir, `${caseId}.json`);
-  writeFileSync34(path22, `${JSON.stringify(metrics, null, 2)}
+  mkdirSync37(dir, { recursive: true });
+  const path22 = join158(dir, `${caseId}.json`);
+  writeFileSync35(path22, `${JSON.stringify(metrics, null, 2)}
 `);
   return path22;
 }
 function loadRunMetrics(cwd2, suiteName, caseId) {
-  const path22 = join156(runsDir(cwd2, suiteName), `${caseId}.json`);
-  if (!existsSync39(path22))
+  const path22 = join158(runsDir(cwd2, suiteName), `${caseId}.json`);
+  if (!existsSync41(path22))
     return null;
-  const parsed = safeParseJSON(readFileSync45(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync47(path22, "utf-8"), false);
   if (!parsed || typeof parsed !== "object")
     return null;
   return parsed;
@@ -396640,10 +397594,10 @@ function formatReliabilityReport(report, json2) {
 `);
 }
 function evalsDir(cwd2) {
-  return join156(cwd2, ".ur", "evals");
+  return join158(cwd2, ".ur", "evals");
 }
 function resultsDir(cwd2) {
-  return join156(evalsDir(cwd2), ".results");
+  return join158(evalsDir(cwd2), ".results");
 }
 function suiteSlug(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9-_]+/g, "-").slice(0, 64);
@@ -396674,27 +397628,27 @@ function parseSuiteText(text) {
 }
 function listSuites(cwd2) {
   const dir = evalsDir(cwd2);
-  if (!existsSync39(dir))
+  if (!existsSync41(dir))
     return [];
   return readdirSync15(dir).filter((file2) => file2.endsWith(".json")).map((file2) => file2.replace(/\.json$/, "")).sort();
 }
 function loadSuite(cwd2, name) {
-  const path22 = join156(evalsDir(cwd2), `${suiteSlug(name)}.json`);
-  if (!existsSync39(path22))
+  const path22 = join158(evalsDir(cwd2), `${suiteSlug(name)}.json`);
+  if (!existsSync41(path22))
     return null;
   try {
-    return parseSuiteText(readFileSync45(path22, "utf-8"));
+    return parseSuiteText(readFileSync47(path22, "utf-8"));
   } catch {
     return null;
   }
 }
 function saveSuite(cwd2, suite, options2 = {}) {
-  const path22 = join156(evalsDir(cwd2), `${suiteSlug(suite.name)}.json`);
-  mkdirSync36(evalsDir(cwd2), { recursive: true });
-  if (existsSync39(path22) && options2.force !== true) {
+  const path22 = join158(evalsDir(cwd2), `${suiteSlug(suite.name)}.json`);
+  mkdirSync37(evalsDir(cwd2), { recursive: true });
+  if (existsSync41(path22) && options2.force !== true) {
     return { path: path22, created: false };
   }
-  writeFileSync34(path22, `${JSON.stringify(suite, null, 2)}
+  writeFileSync35(path22, `${JSON.stringify(suite, null, 2)}
 `);
   return { path: path22, created: true };
 }
@@ -396841,7 +397795,7 @@ function buildBenchmarkSuite(adapter2, records, options2 = {}) {
   };
 }
 function importBenchmarkSuite(cwd2, adapter2, file2, options2 = {}) {
-  const records = parseBenchmarkRecords(readFileSync45(file2, "utf-8"));
+  const records = parseBenchmarkRecords(readFileSync47(file2, "utf-8"));
   if (records.length === 0) {
     throw new Error(`No benchmark records found in ${file2}`);
   }
@@ -396850,17 +397804,17 @@ function importBenchmarkSuite(cwd2, adapter2, file2, options2 = {}) {
   return { suite, path: saved.path, created: saved.created, records: records.length };
 }
 function saveReport(cwd2, report) {
-  mkdirSync36(resultsDir(cwd2), { recursive: true });
-  const path22 = join156(resultsDir(cwd2), `${suiteSlug(report.name)}.json`);
-  writeFileSync34(path22, `${JSON.stringify(report, null, 2)}
+  mkdirSync37(resultsDir(cwd2), { recursive: true });
+  const path22 = join158(resultsDir(cwd2), `${suiteSlug(report.name)}.json`);
+  writeFileSync35(path22, `${JSON.stringify(report, null, 2)}
 `);
   return path22;
 }
 function loadReport(cwd2, name) {
-  const path22 = join156(resultsDir(cwd2), `${suiteSlug(name)}.json`);
-  if (!existsSync39(path22))
+  const path22 = join158(resultsDir(cwd2), `${suiteSlug(name)}.json`);
+  if (!existsSync41(path22))
     return null;
-  const parsed = safeParseJSON(readFileSync45(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync47(path22, "utf-8"), false);
   return parsed && typeof parsed === "object" ? parsed : null;
 }
 function defaultEvalSuite() {
@@ -396911,12 +397865,12 @@ function defaultEvalSuite() {
 function scaffoldEvals(cwd2, options2 = {}) {
   const root2 = evalsDir(cwd2);
   const result = { root: root2, created: [], skipped: [] };
-  mkdirSync36(root2, { recursive: true });
-  const readmePath = join156(root2, "README.md");
-  if (existsSync39(readmePath) && options2.force !== true) {
+  mkdirSync37(root2, { recursive: true });
+  const readmePath = join158(root2, "README.md");
+  if (existsSync41(readmePath) && options2.force !== true) {
     result.skipped.push("evals/README.md");
   } else {
-    writeFileSync34(readmePath, EVALS_README);
+    writeFileSync35(readmePath, EVALS_README);
     result.created.push("evals/README.md");
   }
   const saved = saveSuite(cwd2, defaultEvalSuite(), { force: options2.force });
@@ -397038,8 +397992,8 @@ var exports_eval = {};
 __export(exports_eval, {
   call: () => call84
 });
-import { mkdirSync as mkdirSync37, writeFileSync as writeFileSync35 } from "fs";
-import { join as join157 } from "path";
+import { mkdirSync as mkdirSync38, writeFileSync as writeFileSync36 } from "fs";
+import { join as join159 } from "path";
 function optionValue6(tokens, flag) {
   const index2 = tokens.indexOf(flag);
   return index2 >= 0 ? tokens[index2 + 1] : undefined;
@@ -397116,10 +398070,10 @@ Open it in a browser (local-first, no network).`
     if (tokens.includes("--dashboard")) {
       const { buildDashboardHtml: buildDashboardHtml2 } = await Promise.resolve().then(() => (init_evals(), exports_evals));
       const html3 = buildDashboardHtml2([report], []);
-      const dir = join157(evalsDir(cwd2), ".dashboards");
-      mkdirSync37(dir, { recursive: true });
-      const path22 = join157(dir, `${suiteSlug(report.name)}.html`);
-      writeFileSync35(path22, html3);
+      const dir = join159(evalsDir(cwd2), ".dashboards");
+      mkdirSync38(dir, { recursive: true });
+      const path22 = join159(dir, `${suiteSlug(report.name)}.html`);
+      writeFileSync36(path22, html3);
       return { type: "text", value: `Wrote single-suite dashboard to ${path22}` };
     }
     return { type: "text", value: formatEvalReport(report, json2) };
@@ -397284,9 +398238,9 @@ var init_dna2 = __esm(() => {
 
 // src/ur/sysinfo.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync40, readdirSync as readdirSync16 } from "fs";
+import { existsSync as existsSync42, readdirSync as readdirSync16 } from "fs";
 import { arch, homedir as homedir30, platform as platform5, release as release2 } from "os";
-import { join as join158 } from "path";
+import { join as join160 } from "path";
 function commandExists(bin) {
   try {
     const cmd = process.platform === "win32" ? "where" : "which";
@@ -397321,7 +398275,7 @@ function workspaceInfo(cwd2) {
   try {
     fileCount = readdirSync16(cwd2).length;
   } catch {}
-  const git5 = existsSync40(join158(cwd2, ".git")) ? "yes" : "no";
+  const git5 = existsSync42(join160(cwd2, ".git")) ? "yes" : "no";
   const dna2 = formatDna(detectProjectDna(cwd2));
   return [`workspace: ${cwd2}`, `entries:   ${fileCount}`, `git:       ${git5}`, "", dna2].join(`
 `);
@@ -397349,16 +398303,16 @@ async function urDoctor(cwd2) {
       lines.push(`  tip:      no coder model found \u2014 consider: ollama pull ${pull}`);
     }
   }
-  const urDir = join158(cwd2, ".ur");
-  if (existsSync40(urDir)) {
-    const have = ["actions.jsonl", "project_dna.md", "mode", "graph", "tools", "research", "memory", "index"].filter((n2) => existsSync40(join158(urDir, n2)));
+  const urDir = join160(cwd2, ".ur");
+  if (existsSync42(urDir)) {
+    const have = ["actions.jsonl", "project_dna.md", "mode", "graph", "tools", "research", "memory", "index"].filter((n2) => existsSync42(join160(urDir, n2)));
     lines.push(`.ur:        present \u2014 ${have.join(", ") || "(empty)"}`);
   } else {
     lines.push(".ur:        missing (run /ur-init)");
   }
-  const mcp2 = [join158(cwd2, ".ur", "mcp", "servers.toml"), join158(homedir30(), ".ur", "mcp", "servers.toml")].filter(existsSync40);
+  const mcp2 = [join160(cwd2, ".ur", "mcp", "servers.toml"), join160(homedir30(), ".ur", "mcp", "servers.toml")].filter(existsSync42);
   lines.push(`mcp cfg:    ${mcp2.length ? mcp2.join(", ") : "none (.ur/mcp/servers.toml)"}`);
-  lines.push(`playwright: ${existsSync40(join158(cwd2, "node_modules", "playwright")) ? "installed" : "not installed"}`);
+  lines.push(`playwright: ${existsSync42(join160(cwd2, "node_modules", "playwright")) ? "installed" : "not installed"}`);
   return lines.join(`
 `);
 }
@@ -397445,13 +398399,13 @@ var init_project2 = __esm(() => {
 });
 
 // src/ur/notes.ts
-import { appendFileSync as appendFileSync5, existsSync as existsSync41, mkdirSync as mkdirSync38, readFileSync as readFileSync46, writeFileSync as writeFileSync36 } from "fs";
-import { dirname as dirname59, join as join159 } from "path";
+import { appendFileSync as appendFileSync5, existsSync as existsSync43, mkdirSync as mkdirSync39, readFileSync as readFileSync48, writeFileSync as writeFileSync37 } from "fs";
+import { dirname as dirname59, join as join161 } from "path";
 function readJsonl(file2) {
-  if (!existsSync41(file2))
+  if (!existsSync43(file2))
     return [];
   const out = [];
-  for (const line of readFileSync46(file2, "utf8").split(`
+  for (const line of readFileSync48(file2, "utf8").split(`
 `).filter(Boolean)) {
     try {
       out.push(JSON.parse(line));
@@ -397461,7 +398415,7 @@ function readJsonl(file2) {
 }
 function append2(file2, rec) {
   try {
-    mkdirSync38(dirname59(file2), { recursive: true });
+    mkdirSync39(dirname59(file2), { recursive: true });
     appendFileSync5(file2, JSON.stringify(rec) + `
 `);
   } catch {}
@@ -397479,8 +398433,8 @@ function forget(cwd2, needle) {
   const removed = all4.length - kept.length;
   if (removed > 0) {
     try {
-      mkdirSync38(dirname59(file2), { recursive: true });
-      writeFileSync36(file2, kept.map((n2) => JSON.stringify(n2)).join(`
+      mkdirSync39(dirname59(file2), { recursive: true });
+      writeFileSync37(file2, kept.map((n2) => JSON.stringify(n2)).join(`
 `) + (kept.length ? `
 ` : ""));
     } catch {}
@@ -397493,7 +398447,7 @@ function addResearch(cwd2, kind, text) {
 function listResearch(cwd2, kind) {
   return readJsonl(researchFile(cwd2, kind));
 }
-var memFile = (cwd2) => join159(cwd2, ".ur", "memory", "notes.jsonl"), researchFile = (cwd2, kind) => join159(cwd2, ".ur", "research", `${kind}.jsonl`);
+var memFile = (cwd2) => join161(cwd2, ".ur", "memory", "notes.jsonl"), researchFile = (cwd2, kind) => join161(cwd2, ".ur", "research", `${kind}.jsonl`);
 var init_notes = () => {};
 
 // src/commands/remember/remember.ts
@@ -397532,27 +398486,27 @@ var init_remember2 = __esm(() => {
 
 // src/services/agents/memoryRetention.ts
 import {
-  existsSync as existsSync42,
-  mkdirSync as mkdirSync39,
-  readFileSync as readFileSync47,
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync40,
+  readFileSync as readFileSync49,
   readdirSync as readdirSync17,
-  writeFileSync as writeFileSync37
+  writeFileSync as writeFileSync38
 } from "fs";
-import { dirname as dirname60, join as join160 } from "path";
+import { dirname as dirname60, join as join162 } from "path";
 function memoryDir(cwd2) {
-  return join160(cwd2, ".ur", "memory");
+  return join162(cwd2, ".ur", "memory");
 }
 function policyPath2(cwd2) {
-  return join160(memoryDir(cwd2), "retention.json");
+  return join162(memoryDir(cwd2), "retention.json");
 }
 function defaultMemoryRetentionPolicy() {
   return { version: 1, maxEntries: 1000, updatedAt: new Date().toISOString() };
 }
 function loadMemoryRetentionPolicy(cwd2) {
   const path22 = policyPath2(cwd2);
-  if (!existsSync42(path22))
+  if (!existsSync44(path22))
     return defaultMemoryRetentionPolicy();
-  const parsed = safeParseJSON(readFileSync47(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync49(path22, "utf-8"), false);
   if (!parsed || typeof parsed !== "object")
     return defaultMemoryRetentionPolicy();
   const p2 = parsed;
@@ -397573,8 +398527,8 @@ function saveMemoryRetentionPolicy(cwd2, patch) {
     decayDays: patch.decayDays === undefined ? current.decayDays : validPositive(patch.decayDays),
     updatedAt: new Date().toISOString()
   };
-  mkdirSync39(dirname60(policyPath2(cwd2)), { recursive: true });
-  writeFileSync37(policyPath2(cwd2), `${JSON.stringify(next, null, 2)}
+  mkdirSync40(dirname60(policyPath2(cwd2)), { recursive: true });
+  writeFileSync38(policyPath2(cwd2), `${JSON.stringify(next, null, 2)}
 `);
   return next;
 }
@@ -397590,10 +398544,10 @@ function timestamp(record3) {
   return Number.isFinite(time3) ? time3 : 0;
 }
 function readJsonl2(file2) {
-  if (!existsSync42(file2))
+  if (!existsSync44(file2))
     return [];
   const records = [];
-  for (const line of readFileSync47(file2, "utf-8").split(`
+  for (const line of readFileSync49(file2, "utf-8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -397604,7 +398558,7 @@ function readJsonl2(file2) {
   return records;
 }
 function writeJsonl(file2, records) {
-  writeFileSync37(file2, records.map((r) => JSON.stringify(r)).join(`
+  writeFileSync38(file2, records.map((r) => JSON.stringify(r)).join(`
 `) + (records.length ? `
 ` : ""));
 }
@@ -397632,9 +398586,9 @@ function applyPolicy(records, policy, nowMs) {
 }
 function memoryJsonlFiles(cwd2) {
   const dir = memoryDir(cwd2);
-  if (!existsSync42(dir))
+  if (!existsSync44(dir))
     return [];
-  return readdirSync17(dir).filter((name) => name.endsWith(".jsonl")).map((name) => join160(dir, name));
+  return readdirSync17(dir).filter((name) => name.endsWith(".jsonl")).map((name) => join162(dir, name));
 }
 function pruneMemoryRetention(cwd2, policy = loadMemoryRetentionPolicy(cwd2), nowMs = Date.now()) {
   const files = memoryJsonlFiles(cwd2).map((file2) => {
@@ -397755,10 +398709,10 @@ var exports_semantic_memory = {};
 __export(exports_semantic_memory, {
   call: () => call91
 });
-import { existsSync as existsSync43, mkdirSync as mkdirSync40, readdirSync as readdirSync18, readFileSync as readFileSync48, statSync as statSync10, writeFileSync as writeFileSync38 } from "fs";
-import { basename as basename40, join as join161 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync41, readdirSync as readdirSync18, readFileSync as readFileSync50, statSync as statSync10, writeFileSync as writeFileSync39 } from "fs";
+import { basename as basename40, join as join163 } from "path";
 function indexPath3() {
-  return join161(getCwd(), ".ur", "semantic-memory", "index", "index.json");
+  return join163(getCwd(), ".ur", "semantic-memory", "index", "index.json");
 }
 function tokenize7(value) {
   return [...new Set(value.toLowerCase().match(/[a-z0-9_]{3,}/g) ?? [])];
@@ -397767,15 +398721,15 @@ function sourceFiles() {
   const cwd2 = getCwd();
   const files = [];
   for (const file2 of ["UR.md", "README.md"]) {
-    const path22 = join161(cwd2, file2);
-    if (existsSync43(path22))
+    const path22 = join163(cwd2, file2);
+    if (existsSync45(path22))
       files.push(path22);
   }
-  for (const dir of [join161(cwd2, ".ur", "memory"), join161(cwd2, ".ur", "docs")]) {
-    if (!existsSync43(dir))
+  for (const dir of [join163(cwd2, ".ur", "memory"), join163(cwd2, ".ur", "docs")]) {
+    if (!existsSync45(dir))
       continue;
     for (const file2 of readdirSync18(dir)) {
-      const path22 = join161(dir, file2);
+      const path22 = join163(dir, file2);
       if (statSync10(path22).isFile() && /\.(md|txt|jsonl)$/i.test(file2)) {
         files.push(path22);
       }
@@ -397792,22 +398746,22 @@ function chunkText2(source, text) {
   }));
 }
 function buildIndex2() {
-  const entries = sourceFiles().flatMap((file2) => chunkText2(file2, readFileSync48(file2, "utf-8")));
+  const entries = sourceFiles().flatMap((file2) => chunkText2(file2, readFileSync50(file2, "utf-8")));
   const index2 = {
     version: 1,
     mode: "lexical",
     builtAt: new Date().toISOString(),
     entries
   };
-  mkdirSync40(join161(getCwd(), ".ur", "semantic-memory", "index"), { recursive: true });
-  writeFileSync38(indexPath3(), `${JSON.stringify(index2, null, 2)}
+  mkdirSync41(join163(getCwd(), ".ur", "semantic-memory", "index"), { recursive: true });
+  writeFileSync39(indexPath3(), `${JSON.stringify(index2, null, 2)}
 `);
   return index2;
 }
 function loadIndex3() {
-  if (!existsSync43(indexPath3()))
+  if (!existsSync45(indexPath3()))
     return null;
-  const parsed = safeParseJSON(readFileSync48(indexPath3(), "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync50(indexPath3(), "utf-8"), false);
   return parsed && typeof parsed === "object" ? parsed : null;
 }
 function searchIndex(index2, query2) {
@@ -566988,17 +567942,17 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 // src/services/repoEditing/reliableRepoEdit.ts
 import { exec as exec6 } from "child_process";
 import {
-  existsSync as existsSync44,
-  mkdirSync as mkdirSync41,
-  readFileSync as readFileSync49,
+  existsSync as existsSync46,
+  mkdirSync as mkdirSync42,
+  readFileSync as readFileSync51,
   readdirSync as readdirSync19,
   statSync as statSync11,
-  writeFileSync as writeFileSync39
+  writeFileSync as writeFileSync40
 } from "fs";
-import { dirname as dirname61, extname as extname15, isAbsolute as isAbsolute26, join as join162, relative as relative34, resolve as resolve44 } from "path";
+import { dirname as dirname61, extname as extname15, isAbsolute as isAbsolute26, join as join164, relative as relative34, resolve as resolve44 } from "path";
 import { promisify as promisify4 } from "util";
 function repoEditIndexPath(root2) {
-  return join162(root2, ".ur", "repo-edit", "index.json");
+  return join164(root2, ".ur", "repo-edit", "index.json");
 }
 function isSkippedDir(pathFromRoot, name) {
   if (SKIP_DIRS.has(name))
@@ -567029,7 +567983,7 @@ function listRepoFiles(root2, maxFiles = 25000) {
     for (const entry of entries) {
       if (files.length >= maxFiles)
         return;
-      const full = join162(dir, entry.name);
+      const full = join164(dir, entry.name);
       const rel = normalizeRelPath(relative34(root2, full));
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") && entry.name !== ".ur")
@@ -567105,7 +568059,7 @@ function collectSymbols(file2, content) {
 }
 function buildRepoEditIndex(root2) {
   const files = listRepoFiles(root2).map((path22) => {
-    const abs = join162(root2, path22);
+    const abs = join164(root2, path22);
     const stat41 = statSync11(abs);
     const ext = extname15(path22).toLowerCase();
     const text = isTextPath(path22);
@@ -567113,7 +568067,7 @@ function buildRepoEditIndex(root2) {
     let content = "";
     if (text && stat41.size <= 1e6) {
       try {
-        content = readFileSync49(abs, "utf-8");
+        content = readFileSync51(abs, "utf-8");
       } catch {
         content = "";
       }
@@ -567135,16 +568089,16 @@ ${content}`),
     builtAt: new Date().toISOString(),
     files
   };
-  mkdirSync41(dirname61(repoEditIndexPath(root2)), { recursive: true });
-  writeFileSync39(repoEditIndexPath(root2), `${JSON.stringify(index2, null, 2)}
+  mkdirSync42(dirname61(repoEditIndexPath(root2)), { recursive: true });
+  writeFileSync40(repoEditIndexPath(root2), `${JSON.stringify(index2, null, 2)}
 `);
   return index2;
 }
 function loadRepoEditIndex(root2) {
   const path22 = repoEditIndexPath(root2);
-  if (!existsSync44(path22))
+  if (!existsSync46(path22))
     return null;
-  const parsed = safeParseJSON(readFileSync49(path22, "utf-8"), false);
+  const parsed = safeParseJSON(readFileSync51(path22, "utf-8"), false);
   return parsed && typeof parsed === "object" ? parsed : null;
 }
 function searchRepoEditIndex(root2, query2, index2 = loadRepoEditIndex(root2) ?? buildRepoEditIndex(root2)) {
@@ -567170,7 +568124,7 @@ function searchRepoEditIndex(root2, query2, index2 = loadRepoEditIndex(root2) ??
     const lines = [];
     if (file2.text && score > 0) {
       try {
-        const content = readFileSync49(join162(root2, file2.path), "utf-8");
+        const content = readFileSync51(join164(root2, file2.path), "utf-8");
         const split = content.split(`
 `);
         for (let i3 = 0;i3 < split.length && lines.length < 4; i3++) {
@@ -567224,10 +568178,10 @@ function planRename(root2, from, to) {
   if (from === to)
     throw new Error("from and to must be different identifiers");
   const files = listRepoFiles(root2).filter(isCodePath).flatMap((file2) => {
-    const abs = join162(root2, file2);
+    const abs = join164(root2, file2);
     let oldContent;
     try {
-      oldContent = readFileSync49(abs, "utf-8");
+      oldContent = readFileSync51(abs, "utf-8");
     } catch {
       return [];
     }
@@ -567284,7 +568238,7 @@ async function runCheck(command5, cwd2) {
 }
 function rollback(root2, snapshots) {
   for (const [file2, content] of snapshots) {
-    writeFileSync39(join162(root2, file2), content);
+    writeFileSync40(join164(root2, file2), content);
   }
 }
 async function applyRename(root2, from, to, options2 = {}) {
@@ -567297,7 +568251,7 @@ async function applyRename(root2, from, to, options2 = {}) {
   try {
     for (const file2 of plan.files) {
       snapshots.set(file2.file, file2.oldContent);
-      writeFileSync39(join162(root2, file2.file), file2.newContent);
+      writeFileSync40(join164(root2, file2.file), file2.newContent);
       writtenFiles.push(file2.file);
     }
     const syntax = plan.files.flatMap((file2) => syntaxErrors(file2.file, file2.newContent));
@@ -567741,11 +568695,11 @@ var init_cite2 = __esm(() => {
 });
 
 // src/ur/fileops.ts
-import { existsSync as existsSync45, mkdirSync as mkdirSync42, readdirSync as readdirSync20, readFileSync as readFileSync50, statSync as statSync12, writeFileSync as writeFileSync40 } from "fs";
-import { extname as extname16, isAbsolute as isAbsolute27, join as join163, relative as relative35, resolve as resolve45 } from "path";
+import { existsSync as existsSync47, mkdirSync as mkdirSync43, readdirSync as readdirSync20, readFileSync as readFileSync52, statSync as statSync12, writeFileSync as writeFileSync41 } from "fs";
+import { extname as extname16, isAbsolute as isAbsolute27, join as join165, relative as relative35, resolve as resolve45 } from "path";
 function readFileSafe2(cwd2, target, maxBytes = 64000) {
   const abs = isAbsolute27(target) ? target : resolve45(cwd2, target);
-  if (!existsSync45(abs))
+  if (!existsSync47(abs))
     return { ok: false, error: `not found: ${target}` };
   const st = statSync12(abs);
   if (st.isDirectory())
@@ -567753,7 +568707,7 @@ function readFileSafe2(cwd2, target, maxBytes = 64000) {
   if (!isTextLike(abs))
     return { ok: false, error: `not a text file (${extname16(abs) || "no ext"}). For images use /image, for video /video, for PDFs/docs ask UR to read it.` };
   try {
-    let content = readFileSync50(abs, "utf8");
+    let content = readFileSync52(abs, "utf8");
     if (content.length > maxBytes)
       content = content.slice(0, maxBytes) + `
 \u2026 [truncated at ${maxBytes} bytes]`;
@@ -567776,7 +568730,7 @@ function* walk(dir, root2, budget = { n: 0 }, max2 = 8000) {
       return;
     if (e.name.startsWith(".") && e.name !== ".ur")
       continue;
-    const full = join163(dir, e.name);
+    const full = join165(dir, e.name);
     if (e.isDirectory()) {
       if (SKIP_DIRS2.has(e.name))
         continue;
@@ -567795,7 +568749,7 @@ function searchFiles(cwd2, query2, maxResults = 60) {
       continue;
     let lines;
     try {
-      lines = readFileSync50(join163(cwd2, rel), "utf8").split(`
+      lines = readFileSync52(join165(cwd2, rel), "utf8").split(`
 `);
     } catch {
       continue;
@@ -567813,8 +568767,8 @@ function searchFiles(cwd2, query2, maxResults = 60) {
 function indexWorkspace(cwd2) {
   const files = [...walk(cwd2, cwd2)];
   try {
-    mkdirSync42(join163(cwd2, ".ur", "index"), { recursive: true });
-    writeFileSync40(join163(cwd2, ".ur", "index", "files.txt"), files.join(`
+    mkdirSync43(join165(cwd2, ".ur", "index"), { recursive: true });
+    writeFileSync41(join165(cwd2, ".ur", "index", "files.txt"), files.join(`
 `) + `
 `);
   } catch {}
@@ -568082,14 +569036,14 @@ var exports_image = {};
 __export(exports_image, {
   call: () => call104
 });
-import { existsSync as existsSync46, statSync as statSync13 } from "fs";
+import { existsSync as existsSync48, statSync as statSync13 } from "fs";
 import { extname as extname17, isAbsolute as isAbsolute28, resolve as resolve46 } from "path";
 var call104 = async (args) => {
   const f = (args ?? "").trim().split(/\s+/)[0] ?? "";
   if (!f)
     return { type: "text", value: "usage: /image <file> [task]" };
   const abs = isAbsolute28(f) ? f : resolve46(getCwd(), f);
-  if (!existsSync46(abs))
+  if (!existsSync48(abs))
     return { type: "text", value: `not found: ${f}` };
   const kb = Math.round(statSync13(abs).size / 1024);
   const lines = [`image ${f} \u2014 ${extname17(abs) || "?"}, ${kb} KB`];
@@ -568130,7 +569084,7 @@ var exports_video = {};
 __export(exports_video, {
   call: () => call105
 });
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { isAbsolute as isAbsolute29, resolve as resolve47 } from "path";
 var call105 = async (args) => {
   const target = (args ?? "").trim().split(/\s+/)[0] ?? "";
@@ -568143,7 +569097,7 @@ var call105 = async (args) => {
 ${yd}` };
   }
   const abs = isAbsolute29(target) ? target : resolve47(getCwd(), target);
-  if (!existsSync47(abs))
+  if (!existsSync49(abs))
     return { type: "text", value: `not found: ${target}` };
   if (!commandExists("ffprobe")) {
     return { type: "text", value: `local video: ${target}
@@ -568239,13 +569193,13 @@ var exports_mode = {};
 __export(exports_mode, {
   call: () => call107
 });
-import { existsSync as existsSync48, mkdirSync as mkdirSync43, readFileSync as readFileSync51, writeFileSync as writeFileSync41 } from "fs";
-import { join as join164 } from "path";
-var MODES, SECURITY_MODES2, file2 = (cwd2) => join164(cwd2, ".ur", "mode"), call107 = async (args) => {
+import { existsSync as existsSync50, mkdirSync as mkdirSync44, readFileSync as readFileSync53, writeFileSync as writeFileSync42 } from "fs";
+import { join as join166 } from "path";
+var MODES, SECURITY_MODES2, file2 = (cwd2) => join166(cwd2, ".ur", "mode"), call107 = async (args) => {
   const want = (args ?? "").trim().toLowerCase();
   const f = file2(getCwd());
   if (!want) {
-    const cur = existsSync48(f) ? readFileSync51(f, "utf8").trim() : "code";
+    const cur = existsSync50(f) ? readFileSync53(f, "utf8").trim() : "code";
     return { type: "text", value: `mode: ${cur}
 available: ${MODES.join(", ")}
 security: ${SECURITY_MODES2.join(", ")}` };
@@ -568259,8 +569213,8 @@ available: ${MODES.join(", ")}
 security: ${SECURITY_MODES2.join(", ")}` };
   }
   try {
-    mkdirSync43(join164(getCwd(), ".ur"), { recursive: true });
-    writeFileSync41(f, want + `
+    mkdirSync44(join166(getCwd(), ".ur"), { recursive: true });
+    writeFileSync42(f, want + `
 `);
   } catch {}
   return { type: "text", value: `mode \u2192 ${want} (UR will favor ${want}-oriented behavior; persisted to .ur/mode)` };
@@ -568382,8 +569336,8 @@ var exports_role_mode = {};
 __export(exports_role_mode, {
   call: () => call108
 });
-import { existsSync as existsSync49, mkdirSync as mkdirSync44, writeFileSync as writeFileSync42 } from "fs";
-import { join as join165 } from "path";
+import { existsSync as existsSync51, mkdirSync as mkdirSync45, writeFileSync as writeFileSync43 } from "fs";
+import { join as join167 } from "path";
 function formatList() {
   const lines = ["Built-in role modes:", ""];
   for (const mode2 of ROLE_MODES) {
@@ -568437,17 +569391,17 @@ var call108 = async (args) => {
         value: `Unknown role mode "${target}". Available: ${listModeNames().join(", ")}, or "all".`
       };
     }
-    const agentsDir = join165(getCwd(), ".ur", "agents");
-    mkdirSync44(agentsDir, { recursive: true });
+    const agentsDir = join167(getCwd(), ".ur", "agents");
+    mkdirSync45(agentsDir, { recursive: true });
     const created = [];
     const skipped = [];
     for (const mode2 of modes) {
-      const path22 = join165(agentsDir, `${mode2.name}.md`);
-      if (existsSync49(path22) && !force) {
+      const path22 = join167(agentsDir, `${mode2.name}.md`);
+      if (existsSync51(path22) && !force) {
         skipped.push(`${mode2.name} (exists; use --force to overwrite)`);
         continue;
       }
-      writeFileSync42(path22, renderModeAgent(mode2), { encoding: "utf-8" });
+      writeFileSync43(path22, renderModeAgent(mode2), { encoding: "utf-8" });
       created.push(path22);
     }
     if (json2) {
@@ -568493,25 +569447,25 @@ var init_role_mode2 = __esm(() => {
 });
 
 // src/ur/researchGraph.ts
-import { appendFileSync as appendFileSync6, existsSync as existsSync50, mkdirSync as mkdirSync45, readFileSync as readFileSync52 } from "fs";
-import { dirname as dirname62, join as join166 } from "path";
+import { appendFileSync as appendFileSync6, existsSync as existsSync52, mkdirSync as mkdirSync46, readFileSync as readFileSync54 } from "fs";
+import { dirname as dirname62, join as join168 } from "path";
 function isEntity(s) {
   return ENTITIES.includes(s);
 }
 function addEntity(cwd2, entity, text) {
   try {
     const f = file3(cwd2, entity);
-    mkdirSync45(dirname62(f), { recursive: true });
+    mkdirSync46(dirname62(f), { recursive: true });
     appendFileSync6(f, JSON.stringify({ ts: new Date().toISOString(), text }) + `
 `);
   } catch {}
 }
 function listEntity(cwd2, entity) {
   const f = file3(cwd2, entity);
-  if (!existsSync50(f))
+  if (!existsSync52(f))
     return [];
   const out = [];
-  for (const line of readFileSync52(f, "utf8").split(`
+  for (const line of readFileSync54(f, "utf8").split(`
 `).filter(Boolean)) {
     try {
       out.push(JSON.parse(line));
@@ -568525,7 +569479,7 @@ function graphSummary(cwd2) {
     out[e] = listEntity(cwd2, e).length;
   return out;
 }
-var ENTITIES, file3 = (cwd2, entity) => join166(cwd2, ".ur", "graph", `${entity}.jsonl`);
+var ENTITIES, file3 = (cwd2, entity) => join168(cwd2, ".ur", "graph", `${entity}.jsonl`);
 var init_researchGraph = __esm(() => {
   ENTITIES = [
     "sources",
@@ -568594,15 +569548,15 @@ var exports_toolsmith = {};
 __export(exports_toolsmith, {
   call: () => call110
 });
-import { existsSync as existsSync51, mkdirSync as mkdirSync46, readdirSync as readdirSync21, writeFileSync as writeFileSync43 } from "fs";
-import { join as join167 } from "path";
+import { existsSync as existsSync53, mkdirSync as mkdirSync47, readdirSync as readdirSync21, writeFileSync as writeFileSync44 } from "fs";
+import { join as join169 } from "path";
 var TEMPLATES, call110 = async (args) => {
   const [name, langArg] = (args ?? "").trim().split(/\s+/).filter(Boolean);
   const auto = [["python3", "python"], ["node", "node"], ["bash", "bash"], ["go", "go"], ["cargo", "rust"]].find(([bin]) => commandExists(bin))?.[1] ?? "python";
   const lang = langArg ?? auto;
-  const dir = join167(getCwd(), ".ur", "tools");
+  const dir = join169(getCwd(), ".ur", "tools");
   if (!name) {
-    const files = existsSync51(dir) ? readdirSync21(dir) : [];
+    const files = existsSync53(dir) ? readdirSync21(dir) : [];
     return { type: "text", value: files.length ? `tools:
 ` + files.map((f) => "  " + f).join(`
 `) : "no tools yet. usage: /toolsmith <name> <python|bash|node|go|rust>" };
@@ -568610,11 +569564,11 @@ var TEMPLATES, call110 = async (args) => {
   const tpl = TEMPLATES[lang];
   if (!tpl)
     return { type: "text", value: `unknown lang "${lang}". choose: ${Object.keys(TEMPLATES).join(", ")}` };
-  mkdirSync46(dir, { recursive: true });
-  const file4 = join167(dir, `${name}.${tpl.ext}`);
-  if (existsSync51(file4))
+  mkdirSync47(dir, { recursive: true });
+  const file4 = join169(dir, `${name}.${tpl.ext}`);
+  if (existsSync53(file4))
     return { type: "text", value: `already exists: .ur/tools/${name}.${tpl.ext}` };
-  writeFileSync43(file4, tpl.body);
+  writeFileSync44(file4, tpl.body);
   return { type: "text", value: `created .ur/tools/${name}.${tpl.ext}
 Ask UR to run it \u2014 it will request approval before executing, and you can keep it as a plugin if useful.` };
 };
@@ -568674,13 +569628,13 @@ var exports_browser = {};
 __export(exports_browser, {
   call: () => call111
 });
-import { existsSync as existsSync52 } from "fs";
-import { join as join168 } from "path";
+import { existsSync as existsSync54 } from "fs";
+import { join as join170 } from "path";
 var call111 = async (args) => {
   const task = (args ?? "").trim();
   if (!task)
     return { type: "text", value: "usage: /browser <url|task>" };
-  const hasPlaywright = existsSync52(join168(getCwd(), "node_modules", "playwright")) || existsSync52(join168(getCwd(), "node_modules", "playwright-core"));
+  const hasPlaywright = existsSync54(join170(getCwd(), "node_modules", "playwright")) || existsSync54(join170(getCwd(), "node_modules", "playwright-core"));
   if (hasPlaywright) {
     return { type: "text", value: `Playwright detected \u2014 ask UR to drive the browser for: ${task}
 Risky actions (form submit, downloads, login) require your approval.` };
@@ -568735,22 +569689,22 @@ var init_ur_doctor2 = __esm(() => {
 });
 
 // src/utils/urAssets.ts
-import { existsSync as existsSync53, mkdirSync as mkdirSync47, writeFileSync as writeFileSync44 } from "fs";
-import { join as join169 } from "path";
+import { existsSync as existsSync55, mkdirSync as mkdirSync48, writeFileSync as writeFileSync45 } from "fs";
+import { join as join171 } from "path";
 function scaffoldUrAssets(cwd2) {
-  const root2 = join169(cwd2, ".ur");
+  const root2 = join171(cwd2, ".ur");
   const created = [];
   const skipped = [];
-  mkdirSync47(root2, { recursive: true });
+  mkdirSync48(root2, { recursive: true });
   for (const d of DIRS)
-    mkdirSync47(join169(root2, d), { recursive: true });
+    mkdirSync48(join171(root2, d), { recursive: true });
   for (const file4 of SEED_FILES) {
-    const full = join169(root2, file4.path);
-    if (existsSync53(full)) {
+    const full = join171(root2, file4.path);
+    if (existsSync55(full)) {
       skipped.push(file4.path);
       continue;
     }
-    writeFileSync44(full, file4.content);
+    writeFileSync45(full, file4.content);
     created.push(file4.path);
   }
   return { root: root2, created, skipped };
@@ -569043,7 +569997,7 @@ __export(exports_thinkback, {
   call: () => call117
 });
 import { readFile as readFile45 } from "fs/promises";
-import { join as join170 } from "path";
+import { join as join172 } from "path";
 function getMarketplaceName() {
   return OFFICIAL_MARKETPLACE_NAME;
 }
@@ -569061,15 +570015,15 @@ async function getThinkbackSkillDir() {
   if (!thinkbackPlugin) {
     return null;
   }
-  const skillDir = join170(thinkbackPlugin.path, "skills", SKILL_NAME);
+  const skillDir = join172(thinkbackPlugin.path, "skills", SKILL_NAME);
   if (await pathExists(skillDir)) {
     return skillDir;
   }
   return null;
 }
 async function playAnimation(skillDir) {
-  const dataPath = join170(skillDir, "year_in_review.js");
-  const playerPath = join170(skillDir, "player.js");
+  const dataPath = join172(skillDir, "year_in_review.js");
+  const playerPath = join172(skillDir, "player.js");
   try {
     await readFile45(dataPath);
   } catch (e) {
@@ -569117,7 +570071,7 @@ async function playAnimation(skillDir) {
   } catch {} finally {
     inkInstance.exitAlternateScreen();
   }
-  const htmlPath = join170(skillDir, "year_in_review.html");
+  const htmlPath = join172(skillDir, "year_in_review.html");
   if (await pathExists(htmlPath)) {
     const platform6 = getPlatform();
     const openCmd = platform6 === "macos" ? "open" : platform6 === "windows" ? "start" : "xdg-open";
@@ -569453,7 +570407,7 @@ function ThinkbackFlow(t0) {
       if (!skillDir) {
         return;
       }
-      const dataPath = join170(skillDir, "year_in_review.js");
+      const dataPath = join172(skillDir, "year_in_review.js");
       pathExists(dataPath).then((exists) => {
         logForDebugging(`Checking for ${dataPath}: ${exists ? "found" : "not found"}`);
         setHasGenerated(exists);
@@ -569627,7 +570581,7 @@ var exports_thinkback_play = {};
 __export(exports_thinkback_play, {
   call: () => call118
 });
-import { join as join171 } from "path";
+import { join as join173 } from "path";
 function getPluginId2() {
   const marketplaceName = process.env.USER_TYPE === "ant" ? INTERNAL_MARKETPLACE_NAME : OFFICIAL_MARKETPLACE_NAME;
   return `thinkback@${marketplaceName}`;
@@ -569649,7 +570603,7 @@ async function call118() {
       value: "Thinkback plugin installation path not found."
     };
   }
-  const skillDir = join171(firstInstall.installPath, "skills", SKILL_NAME2);
+  const skillDir = join173(firstInstall.installPath, "skills", SKILL_NAME2);
   const result = await playAnimation(skillDir);
   return { type: "text", value: result.message };
 }
@@ -576044,7 +576998,7 @@ var init_types13 = __esm(() => {
 
 // src/components/agents/agentFileUtils.ts
 import { mkdir as mkdir35, open as open12, unlink as unlink19 } from "fs/promises";
-import { join as join172 } from "path";
+import { join as join174 } from "path";
 function formatAgentAsMarkdown(agentType, whenToUse, tools, systemPrompt, color3, model, memory2, effort) {
   const escapedWhenToUse = whenToUse.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\\\n");
   const isAllTools = tools === undefined || tools.length === 1 && tools[0] === "*";
@@ -576071,26 +577025,26 @@ function getAgentDirectoryPath(location2) {
     case "flagSettings":
       throw new Error(`Cannot get directory path for ${location2} agents`);
     case "userSettings":
-      return join172(getURConfigHomeDir(), AGENT_PATHS.AGENTS_DIR);
+      return join174(getURConfigHomeDir(), AGENT_PATHS.AGENTS_DIR);
     case "projectSettings":
-      return join172(getCwd(), AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
+      return join174(getCwd(), AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
     case "policySettings":
-      return join172(getManagedFilePath(), AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
+      return join174(getManagedFilePath(), AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
     case "localSettings":
-      return join172(getCwd(), AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
+      return join174(getCwd(), AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
   }
 }
 function getRelativeAgentDirectoryPath(location2) {
   switch (location2) {
     case "projectSettings":
-      return join172(".", AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
+      return join174(".", AGENT_PATHS.FOLDER_NAME, AGENT_PATHS.AGENTS_DIR);
     default:
       return getAgentDirectoryPath(location2);
   }
 }
 function getNewAgentFilePath(agent) {
   const dirPath = getAgentDirectoryPath(agent.source);
-  return join172(dirPath, `${agent.agentType}.md`);
+  return join174(dirPath, `${agent.agentType}.md`);
 }
 function getActualAgentFilePath(agent) {
   if (agent.source === "built-in") {
@@ -576101,14 +577055,14 @@ function getActualAgentFilePath(agent) {
   }
   const dirPath = getAgentDirectoryPath(agent.source);
   const filename = agent.filename || agent.agentType;
-  return join172(dirPath, `${filename}.md`);
+  return join174(dirPath, `${filename}.md`);
 }
 function getNewRelativeAgentFilePath(agent) {
   if (agent.source === "built-in") {
     return "Built-in";
   }
   const dirPath = getRelativeAgentDirectoryPath(agent.source);
-  return join172(dirPath, `${agent.agentType}.md`);
+  return join174(dirPath, `${agent.agentType}.md`);
 }
 function getActualRelativeAgentFilePath(agent) {
   if (isBuiltInAgent(agent)) {
@@ -576122,7 +577076,7 @@ function getActualRelativeAgentFilePath(agent) {
   }
   const dirPath = getRelativeAgentDirectoryPath(agent.source);
   const filename = agent.filename || agent.agentType;
-  return join172(dirPath, `${filename}.md`);
+  return join174(dirPath, `${filename}.md`);
 }
 async function ensureAgentDirectoryExists(source) {
   const dirPath = getAgentDirectoryPath(source);
@@ -582131,9 +583085,9 @@ var init_rewind = __esm(() => {
 });
 
 // src/utils/heapDumpService.ts
-import { createWriteStream as createWriteStream3, writeFileSync as writeFileSync45 } from "fs";
+import { createWriteStream as createWriteStream3, writeFileSync as writeFileSync46 } from "fs";
 import { readdir as readdir26, readFile as readFile47, writeFile as writeFile40 } from "fs/promises";
-import { join as join173 } from "path";
+import { join as join175 } from "path";
 import { pipeline as pipeline2 } from "stream/promises";
 import {
   getHeapSnapshot,
@@ -582223,7 +583177,7 @@ async function captureMemoryDiagnostics(trigger2, dumpNumber = 0) {
     smapsRollup,
     platform: process.platform,
     nodeVersion: process.version,
-    ccVersion: "1.22.0"
+    ccVersion: "1.22.1"
   };
 }
 async function performHeapDump(trigger2 = "manual", dumpNumber = 0) {
@@ -582241,8 +583195,8 @@ async function performHeapDump(trigger2 = "manual", dumpNumber = 0) {
     const suffix = dumpNumber > 0 ? `-dump${dumpNumber}` : "";
     const heapFilename = `${sessionId}${suffix}.heapsnapshot`;
     const diagFilename = `${sessionId}${suffix}-diagnostics.json`;
-    const heapPath = join173(dumpDir, heapFilename);
-    const diagPath = join173(dumpDir, diagFilename);
+    const heapPath = join175(dumpDir, heapFilename);
+    const diagPath = join175(dumpDir, diagFilename);
     await writeFile40(diagPath, jsonStringify(diagnostics, null, 2), {
       mode: 384
     });
@@ -582270,7 +583224,7 @@ async function performHeapDump(trigger2 = "manual", dumpNumber = 0) {
 }
 async function writeHeapSnapshot(filepath) {
   if (typeof Bun !== "undefined") {
-    writeFileSync45(filepath, Bun.generateHeapSnapshot("v8", "arraybuffer"), {
+    writeFileSync46(filepath, Bun.generateHeapSnapshot("v8", "arraybuffer"), {
       mode: 384
     });
     Bun.gc(true);
@@ -582809,7 +583763,7 @@ var init_bridge_kick = __esm(() => {
 var call133 = async () => {
   return {
     type: "text",
-    value: "1.22.0"
+    value: "1.22.1"
   };
 }, version2, version_default;
 var init_version = __esm(() => {
@@ -584081,7 +585035,7 @@ var init_sandbox_toggle2 = __esm(() => {
 
 // src/utils/urInChrome/setupPortable.ts
 import { readdir as readdir27 } from "fs/promises";
-import { join as join174 } from "path";
+import { join as join176 } from "path";
 function getExtensionIds() {
   return process.env.USER_TYPE === "ant" ? [PROD_EXTENSION_ID, DEV_EXTENSION_ID, ANT_EXTENSION_ID] : [PROD_EXTENSION_ID];
 }
@@ -584108,7 +585062,7 @@ async function detectExtensionInstallationPortable(browserPaths, log) {
     }
     for (const profile of profileDirs) {
       for (const extensionId of extensionIds) {
-        const extensionPath = join174(browserBasePath, profile, "Extensions", extensionId);
+        const extensionPath = join176(browserBasePath, profile, "Extensions", extensionId);
         try {
           await readdir27(extensionPath);
           log?.(`[UR in Chrome] Extension ${extensionId} found in ${browser2} ${profile}`);
@@ -584132,7 +585086,7 @@ var init_setupPortable = __esm(() => {
 // src/utils/urInChrome/setup.ts
 import { chmod as chmod10, mkdir as mkdir36, readFile as readFile48, writeFile as writeFile41 } from "fs/promises";
 import { homedir as homedir31 } from "os";
-import { join as join175 } from "path";
+import { join as join177 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function shouldEnableURInChrome(chromeFlag) {
   if (getIsNonInteractiveSession() && chromeFlag !== true) {
@@ -584189,8 +585143,8 @@ function setupURInChrome() {
     };
   } else {
     const __filename3 = fileURLToPath6(import.meta.url);
-    const __dirname3 = join175(__filename3, "..");
-    const cliPath = join175(__dirname3, "cli.js");
+    const __dirname3 = join177(__filename3, "..");
+    const cliPath = join177(__dirname3, "cli.js");
     createWrapperScript(`"${process.execPath}" "${cliPath}" --chrome-native-host`).then((manifestBinaryPath) => installChromeNativeHostManifest(manifestBinaryPath)).catch((e) => logForDebugging(`[UR in Chrome] Failed to install native host: ${e}`, { level: "error" }));
     const mcpConfig = {
       [UR_IN_CHROME_MCP_SERVER_NAME]: {
@@ -584212,8 +585166,8 @@ function getNativeMessagingHostsDirs() {
   const platform6 = getPlatform();
   if (platform6 === "windows") {
     const home = homedir31();
-    const appData = process.env.APPDATA || join175(home, "AppData", "Local");
-    return [join175(appData, "UR", "ChromeNativeHost")];
+    const appData = process.env.APPDATA || join177(home, "AppData", "Local");
+    return [join177(appData, "UR", "ChromeNativeHost")];
   }
   return getAllNativeMessagingHostsDirs().map(({ path: path22 }) => path22);
 }
@@ -584238,7 +585192,7 @@ async function installChromeNativeHostManifest(manifestBinaryPath) {
   const manifestContent = jsonStringify(manifest, null, 2);
   let anyManifestUpdated = false;
   for (const manifestDir of manifestDirs) {
-    const manifestPath5 = join175(manifestDir, NATIVE_HOST_MANIFEST_NAME);
+    const manifestPath5 = join177(manifestDir, NATIVE_HOST_MANIFEST_NAME);
     const existingContent = await readFile48(manifestPath5, "utf-8").catch(() => null);
     if (existingContent === manifestContent) {
       continue;
@@ -584253,7 +585207,7 @@ async function installChromeNativeHostManifest(manifestBinaryPath) {
     }
   }
   if (getPlatform() === "windows") {
-    const manifestPath5 = join175(manifestDirs[0], NATIVE_HOST_MANIFEST_NAME);
+    const manifestPath5 = join177(manifestDirs[0], NATIVE_HOST_MANIFEST_NAME);
     registerWindowsNativeHosts(manifestPath5);
   }
   if (anyManifestUpdated) {
@@ -584291,8 +585245,8 @@ function registerWindowsNativeHosts(manifestPath5) {
 }
 async function createWrapperScript(command7) {
   const platform6 = getPlatform();
-  const chromeDir = join175(getURConfigHomeDir(), "chrome");
-  const wrapperPath = platform6 === "windows" ? join175(chromeDir, "chrome-native-host.bat") : join175(chromeDir, "chrome-native-host");
+  const chromeDir = join177(getURConfigHomeDir(), "chrome");
+  const wrapperPath = platform6 === "windows" ? join177(chromeDir, "chrome-native-host.bat") : join177(chromeDir, "chrome-native-host");
   const scriptContent = platform6 === "windows" ? `@echo off
 REM Chrome native host wrapper script
 REM Generated by UR - do not edit manually
@@ -584864,7 +585818,7 @@ var init_advisor2 = __esm(() => {
 // src/skills/bundledSkills.ts
 import { constants as fsConstants5 } from "fs";
 import { mkdir as mkdir37, open as open13 } from "fs/promises";
-import { dirname as dirname63, isAbsolute as isAbsolute30, join as join176, normalize as normalize13, sep as pathSep2 } from "path";
+import { dirname as dirname63, isAbsolute as isAbsolute30, join as join178, normalize as normalize13, sep as pathSep2 } from "path";
 function registerBundledSkill(definition) {
   const { files: files2 } = definition;
   let skillRoot;
@@ -584912,7 +585866,7 @@ function getBundledSkills() {
   return [...bundledSkills];
 }
 function getBundledSkillExtractDir(skillName) {
-  return join176(getBundledSkillsRoot(), skillName);
+  return join178(getBundledSkillsRoot(), skillName);
 }
 async function extractBundledSkillFiles(skillName, files2) {
   const dir = getBundledSkillExtractDir(skillName);
@@ -584954,7 +585908,7 @@ function resolveSkillFilePath(baseDir, relPath) {
   if (isAbsolute30(normalized) || normalized.split(pathSep2).includes("..") || normalized.split("/").includes("..")) {
     throw new Error(`bundled skill file path escapes skill dir: ${relPath}`);
   }
-  return join176(baseDir, normalized);
+  return join178(baseDir, normalized);
 }
 function prependBaseDir(blocks, baseDir) {
   const prefix = `Base directory for this skill: ${baseDir}
@@ -585315,7 +586269,7 @@ var init_exit2 = __esm(() => {
 });
 
 // src/components/ExportDialog.tsx
-import { join as join177 } from "path";
+import { join as join179 } from "path";
 function ExportDialog({
   content,
   defaultFilename,
@@ -585348,7 +586302,7 @@ function ExportDialog({
   };
   const handleFilenameSubmit = () => {
     const finalFilename = filename.endsWith(".txt") ? filename : filename.replace(/\.[^.]+$/, "") + ".txt";
-    const filepath = join177(getCwd(), finalFilename);
+    const filepath = join179(getCwd(), finalFilename);
     try {
       writeFileSync_DEPRECATED(filepath, content, {
         encoding: "utf-8",
@@ -585571,7 +586525,7 @@ __export(exports_export, {
   extractFirstPrompt: () => extractFirstPrompt,
   call: () => call138
 });
-import { join as join178 } from "path";
+import { join as join180 } from "path";
 function formatTimestamp(date6) {
   const year = date6.getFullYear();
   const month = String(date6.getMonth() + 1).padStart(2, "0");
@@ -585615,7 +586569,7 @@ async function call138(onDone, context4, args) {
   const filename = args.trim();
   if (filename) {
     const finalFilename = filename.endsWith(".txt") ? filename : filename.replace(/\.[^.]+$/, "") + ".txt";
-    const filepath = join178(getCwd(), finalFilename);
+    const filepath = join180(getCwd(), finalFilename);
     try {
       writeFileSync_DEPRECATED(filepath, content, {
         encoding: "utf-8",
@@ -587463,7 +588417,7 @@ var require_asciichart = __commonJS((exports) => {
 // src/utils/statsCache.ts
 import { randomBytes as randomBytes17 } from "crypto";
 import { open as open14 } from "fs/promises";
-import { join as join179 } from "path";
+import { join as join181 } from "path";
 async function withStatsCacheLock(fn) {
   while (statsCacheLockPromise) {
     await statsCacheLockPromise;
@@ -587480,7 +588434,7 @@ async function withStatsCacheLock(fn) {
   }
 }
 function getStatsCachePath() {
-  return join179(getURConfigHomeDir(), STATS_CACHE_FILENAME);
+  return join181(getURConfigHomeDir(), STATS_CACHE_FILENAME);
 }
 function getEmptyCache() {
   return {
@@ -588148,12 +589102,12 @@ var init_ansiToPng = __esm(() => {
 // src/utils/screenshotClipboard.ts
 import { mkdir as mkdir38, unlink as unlink20, writeFile as writeFile42 } from "fs/promises";
 import { tmpdir as tmpdir9 } from "os";
-import { join as join180 } from "path";
+import { join as join182 } from "path";
 async function copyAnsiToClipboard(ansiText, options2) {
   try {
-    const tempDir = join180(tmpdir9(), "ur-screenshots");
+    const tempDir = join182(tmpdir9(), "ur-screenshots");
     await mkdir38(tempDir, { recursive: true });
-    const pngPath = join180(tempDir, `screenshot-${Date.now()}.png`);
+    const pngPath = join182(tempDir, `screenshot-${Date.now()}.png`);
     const pngBuffer = ansiToPng(ansiText, options2);
     await writeFile42(pngPath, pngBuffer);
     const result = await copyPngToClipboard(pngPath);
@@ -588224,7 +589178,7 @@ var init_screenshotClipboard = __esm(() => {
 
 // src/utils/stats.ts
 import { open as open15 } from "fs/promises";
-import { basename as basename41, join as join181, sep as sep33 } from "path";
+import { basename as basename41, join as join183, sep as sep33 } from "path";
 async function processSessionFiles(sessionFiles, options2 = {}) {
   const { fromDate, toDate } = options2;
   const fs12 = getFsImplementation();
@@ -588402,17 +589356,17 @@ async function getAllSessionFiles() {
       return [];
     throw e;
   }
-  const projectDirs = allEntries.filter((dirent) => dirent.isDirectory()).map((dirent) => join181(projectsDir, dirent.name));
+  const projectDirs = allEntries.filter((dirent) => dirent.isDirectory()).map((dirent) => join183(projectsDir, dirent.name));
   const projectResults = await Promise.all(projectDirs.map(async (projectDir) => {
     try {
       const entries = await fs12.readdir(projectDir);
-      const mainFiles = entries.filter((dirent) => dirent.isFile() && dirent.name.endsWith(".jsonl")).map((dirent) => join181(projectDir, dirent.name));
+      const mainFiles = entries.filter((dirent) => dirent.isFile() && dirent.name.endsWith(".jsonl")).map((dirent) => join183(projectDir, dirent.name));
       const sessionDirs = entries.filter((dirent) => dirent.isDirectory());
       const subagentResults = await Promise.all(sessionDirs.map(async (sessionDir) => {
-        const subagentsDir = join181(projectDir, sessionDir.name, "subagents");
+        const subagentsDir = join183(projectDir, sessionDir.name, "subagents");
         try {
           const subagentEntries = await fs12.readdir(subagentsDir);
-          return subagentEntries.filter((dirent) => dirent.isFile() && dirent.name.endsWith(".jsonl") && dirent.name.startsWith("agent-")).map((dirent) => join181(subagentsDir, dirent.name));
+          return subagentEntries.filter((dirent) => dirent.isFile() && dirent.name.endsWith(".jsonl") && dirent.name.startsWith("agent-")).map((dirent) => join183(subagentsDir, dirent.name));
         } catch {
           return [];
         }
@@ -590410,7 +591364,7 @@ import {
   writeFile as writeFile43
 } from "fs/promises";
 import { tmpdir as tmpdir10 } from "os";
-import { extname as extname18, join as join182 } from "path";
+import { extname as extname18, join as join184 } from "path";
 function getAnalysisModel() {
   return getDefaultmodelOModel();
 }
@@ -590418,13 +591372,13 @@ function getInsightsModel() {
   return getDefaultmodelOModel();
 }
 function getDataDir() {
-  return join182(getURConfigHomeDir(), "usage-data");
+  return join184(getURConfigHomeDir(), "usage-data");
 }
 function getFacetsDir() {
-  return join182(getDataDir(), "facets");
+  return join184(getDataDir(), "facets");
 }
 function getSessionMetaDir() {
-  return join182(getDataDir(), "session-meta");
+  return join184(getDataDir(), "session-meta");
 }
 function getLanguageFromPath(filePath) {
   const ext = extname18(filePath).toLowerCase();
@@ -590769,7 +591723,7 @@ async function formatTranscriptWithSummarization(log) {
 `);
 }
 async function loadCachedFacets(sessionId) {
-  const facetPath = join182(getFacetsDir(), `${sessionId}.json`);
+  const facetPath = join184(getFacetsDir(), `${sessionId}.json`);
   try {
     const content = await readFile49(facetPath, { encoding: "utf-8" });
     const parsed = jsonParse(content);
@@ -590788,14 +591742,14 @@ async function saveFacets(facets) {
   try {
     await mkdir39(getFacetsDir(), { recursive: true });
   } catch {}
-  const facetPath = join182(getFacetsDir(), `${facets.session_id}.json`);
+  const facetPath = join184(getFacetsDir(), `${facets.session_id}.json`);
   await writeFile43(facetPath, jsonStringify(facets, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
 }
 async function loadCachedSessionMeta(sessionId) {
-  const metaPath2 = join182(getSessionMetaDir(), `${sessionId}.json`);
+  const metaPath2 = join184(getSessionMetaDir(), `${sessionId}.json`);
   try {
     const content = await readFile49(metaPath2, { encoding: "utf-8" });
     return jsonParse(content);
@@ -590807,7 +591761,7 @@ async function saveSessionMeta(meta) {
   try {
     await mkdir39(getSessionMetaDir(), { recursive: true });
   } catch {}
-  const metaPath2 = join182(getSessionMetaDir(), `${meta.session_id}.json`);
+  const metaPath2 = join184(getSessionMetaDir(), `${meta.session_id}.json`);
   await writeFile43(metaPath2, jsonStringify(meta, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -591864,7 +592818,7 @@ function generateHtmlReport(data, insights) {
 </html>`;
 }
 function buildExportData(data, insights, facets, remoteStats) {
-  const version3 = typeof MACRO !== "undefined" ? "1.22.0" : "unknown";
+  const version3 = typeof MACRO !== "undefined" ? "1.22.1" : "unknown";
   const remote_hosts_collected = remoteStats?.hosts.filter((h2) => h2.sessionCount > 0).map((h2) => h2.name);
   const facets_summary = {
     total: facets.size,
@@ -591915,7 +592869,7 @@ async function scanAllSessions() {
   } catch {
     return [];
   }
-  const projectDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join182(projectsDir, dirent.name));
+  const projectDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join184(projectsDir, dirent.name));
   const allSessions = [];
   for (let i3 = 0;i3 < projectDirs.length; i3++) {
     const sessionFiles = await getSessionFilesWithMtime(projectDirs[i3]);
@@ -591937,7 +592891,7 @@ async function scanAllSessions() {
 async function generateUsageReport(options2) {
   let remoteStats;
   if (process.env.USER_TYPE === "ant" && options2?.collectRemote) {
-    const destDir = join182(getURConfigHomeDir(), "projects");
+    const destDir = join184(getURConfigHomeDir(), "projects");
     const { hosts, totalCopied } = await collectAllRemoteHostData(destDir);
     remoteStats = { hosts, totalCopied };
   }
@@ -592076,7 +593030,7 @@ async function generateUsageReport(options2) {
   try {
     await mkdir39(getDataDir(), { recursive: true });
   } catch {}
-  const htmlPath = join182(getDataDir(), "report.html");
+  const htmlPath = join184(getDataDir(), "report.html");
   await writeFile43(htmlPath, htmlReport, {
     encoding: "utf-8",
     mode: 384
@@ -592172,13 +593126,13 @@ var init_insights = __esm(() => {
   } : async () => 0;
   collectFromRemoteHost = process.env.USER_TYPE === "ant" ? async (homespace, destDir) => {
     const result = { copied: 0, skipped: 0 };
-    const tempDir = await mkdtemp(join182(tmpdir10(), "ur-hs-"));
+    const tempDir = await mkdtemp(join184(tmpdir10(), "ur-hs-"));
     try {
       const scpResult = await execFileNoThrow("scp", ["-rq", `${homespace}.coder:/root/.ur/projects/`, tempDir], { timeout: 300000 });
       if (scpResult.code !== 0) {
         return result;
       }
-      const projectsDir = join182(tempDir, "projects");
+      const projectsDir = join184(tempDir, "projects");
       let projectDirents;
       try {
         projectDirents = await readdir28(projectsDir, { withFileTypes: true });
@@ -592187,11 +593141,11 @@ var init_insights = __esm(() => {
       }
       await Promise.all(projectDirents.map(async (dirent) => {
         const projectName = dirent.name;
-        const projectPath = join182(projectsDir, projectName);
+        const projectPath = join184(projectsDir, projectName);
         if (!dirent.isDirectory())
           return;
         const destProjectName = `${projectName}__${homespace}`;
-        const destProjectPath = join182(destDir, destProjectName);
+        const destProjectPath = join184(destDir, destProjectName);
         try {
           await mkdir39(destProjectPath, { recursive: true });
         } catch {}
@@ -592205,8 +593159,8 @@ var init_insights = __esm(() => {
           const fileName = fileDirent.name;
           if (!fileName.endsWith(".jsonl"))
             return;
-          const srcFile = join182(projectPath, fileName);
-          const destFile = join182(destProjectPath, fileName);
+          const srcFile = join184(projectPath, fileName);
+          const destFile = join184(destProjectPath, fileName);
           try {
             await copyFile9(srcFile, destFile, fsConstants6.COPYFILE_EXCL);
             result.copied++;
@@ -593302,7 +594256,7 @@ import {
   unlink as unlink22,
   writeFile as writeFile44
 } from "fs/promises";
-import { basename as basename42, dirname as dirname65, join as join183 } from "path";
+import { basename as basename42, dirname as dirname65, join as join185 } from "path";
 function isTranscriptMessage(entry) {
   const t = entry.type;
   return t === "user" || t === "assistant" || t === "attachment" || t === "system";
@@ -593317,18 +594271,18 @@ function isEphemeralToolProgress(dataType) {
   return typeof dataType === "string" && EPHEMERAL_PROGRESS_TYPES.has(dataType);
 }
 function getProjectsDir2() {
-  return join183(getURConfigHomeDir(), "projects");
+  return join185(getURConfigHomeDir(), "projects");
 }
 function getTranscriptPath() {
   const projectDir = getSessionProjectDir() ?? getProjectDir2(getOriginalCwd());
-  return join183(projectDir, `${getSessionId()}.jsonl`);
+  return join185(projectDir, `${getSessionId()}.jsonl`);
 }
 function getTranscriptPathForSession(sessionId) {
   if (sessionId === getSessionId()) {
     return getTranscriptPath();
   }
   const projectDir = getProjectDir2(getOriginalCwd());
-  return join183(projectDir, `${sessionId}.jsonl`);
+  return join185(projectDir, `${sessionId}.jsonl`);
 }
 function setAgentTranscriptSubdir(agentId, subdir) {
   agentTranscriptSubdirs.set(agentId, subdir);
@@ -593340,8 +594294,8 @@ function getAgentTranscriptPath(agentId) {
   const projectDir = getSessionProjectDir() ?? getProjectDir2(getOriginalCwd());
   const sessionId = getSessionId();
   const subdir = agentTranscriptSubdirs.get(agentId);
-  const base2 = subdir ? join183(projectDir, sessionId, "subagents", subdir) : join183(projectDir, sessionId, "subagents");
-  return join183(base2, `agent-${agentId}.jsonl`);
+  const base2 = subdir ? join185(projectDir, sessionId, "subagents", subdir) : join185(projectDir, sessionId, "subagents");
+  return join185(base2, `agent-${agentId}.jsonl`);
 }
 function getAgentMetadataPath(agentId) {
   return getAgentTranscriptPath(agentId).replace(/\.jsonl$/, ".meta.json");
@@ -593364,10 +594318,10 @@ async function readAgentMetadata(agentId) {
 }
 function getRemoteAgentsDir() {
   const projectDir = getSessionProjectDir() ?? getProjectDir2(getOriginalCwd());
-  return join183(projectDir, getSessionId(), "remote-agents");
+  return join185(projectDir, getSessionId(), "remote-agents");
 }
 function getRemoteAgentMetadataPath(taskId) {
-  return join183(getRemoteAgentsDir(), `remote-agent-${taskId}.meta.json`);
+  return join185(getRemoteAgentsDir(), `remote-agent-${taskId}.meta.json`);
 }
 async function writeRemoteAgentMetadata(taskId, metadata) {
   const path22 = getRemoteAgentMetadataPath(taskId);
@@ -593410,7 +594364,7 @@ async function listRemoteAgentMetadata() {
     if (!entry.isFile() || !entry.name.endsWith(".meta.json"))
       continue;
     try {
-      const raw = await readFile50(join183(dir, entry.name), "utf-8");
+      const raw = await readFile50(join185(dir, entry.name), "utf-8");
       results.push(JSON.parse(raw));
     } catch (e) {
       logForDebugging(`listRemoteAgentMetadata: skipping ${entry.name}: ${String(e)}`);
@@ -593420,7 +594374,7 @@ async function listRemoteAgentMetadata() {
 }
 function sessionIdExists(sessionId) {
   const projectDir = getProjectDir2(getOriginalCwd());
-  const sessionFile = join183(projectDir, `${sessionId}.jsonl`);
+  const sessionFile = join185(projectDir, `${sessionId}.jsonl`);
   const fs12 = getFsImplementation();
   try {
     fs12.statSync(sessionFile);
@@ -595394,7 +596348,7 @@ async function loadTranscriptFile(filePath, opts) {
   };
 }
 async function loadSessionFile(sessionId) {
-  const sessionFile = join183(getSessionProjectDir() ?? getProjectDir2(getOriginalCwd()), `${sessionId}.jsonl`);
+  const sessionFile = join185(getSessionProjectDir() ?? getProjectDir2(getOriginalCwd()), `${sessionId}.jsonl`);
   return loadTranscriptFile(sessionFile);
 }
 function clearSessionMessagesCache() {
@@ -595462,7 +596416,7 @@ async function loadAllProjectsMessageLogsFull(limit) {
   } catch {
     return [];
   }
-  const projectDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join183(projectsDir, dirent.name));
+  const projectDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join185(projectsDir, dirent.name));
   const logsPerProject = await Promise.all(projectDirs.map((projectDir) => getLogsWithoutIndex(projectDir, limit)));
   const allLogs = logsPerProject.flat();
   const deduped = new Map;
@@ -595487,7 +596441,7 @@ async function loadAllProjectsMessageLogsProgressive(limit, initialEnrichCount =
   } catch {
     return { logs: [], allStatLogs: [], nextIndex: 0 };
   }
-  const projectDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join183(projectsDir, dirent.name));
+  const projectDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join185(projectsDir, dirent.name));
   const rawLogs = [];
   for (const projectDir of projectDirs) {
     rawLogs.push(...await getSessionFilesLite(projectDir, limit));
@@ -595548,7 +596502,7 @@ async function getStatOnlyLogsForWorktrees(worktreePaths, limit) {
     for (const { path: wtPath, prefix } of indexed) {
       if (dirName === prefix || dirName.startsWith(prefix + "-")) {
         seenDirs.add(dirName);
-        allLogs.push(...await getSessionFilesLite(join183(projectsDir, dirent.name), undefined, wtPath));
+        allLogs.push(...await getSessionFilesLite(join185(projectsDir, dirent.name), undefined, wtPath));
         break;
       }
     }
@@ -595617,7 +596571,7 @@ async function loadSubagentTranscripts(agentIds) {
   return transcripts;
 }
 async function loadAllSubagentTranscriptsFromDisk() {
-  const subagentsDir = join183(getSessionProjectDir() ?? getProjectDir2(getOriginalCwd()), getSessionId(), "subagents");
+  const subagentsDir = join185(getSessionProjectDir() ?? getProjectDir2(getOriginalCwd()), getSessionId(), "subagents");
   let entries;
   try {
     entries = await readdir29(subagentsDir, { withFileTypes: true });
@@ -595745,7 +596699,7 @@ async function getSessionFilesWithMtime(projectDir) {
     const sessionId = validateUuid2(basename42(dirent.name, ".jsonl"));
     if (!sessionId)
       continue;
-    candidates2.push({ sessionId, filePath: join183(projectDir, dirent.name) });
+    candidates2.push({ sessionId, filePath: join185(projectDir, dirent.name) });
   }
   await Promise.all(candidates2.map(async ({ sessionId, filePath }) => {
     try {
@@ -596131,7 +597085,7 @@ var init_sessionStorage = __esm(() => {
   init_settings2();
   init_slowOperations();
   init_uuid();
-  VERSION5 = typeof MACRO !== "undefined" ? "1.22.0" : "unknown";
+  VERSION5 = typeof MACRO !== "undefined" ? "1.22.1" : "unknown";
   MAX_TOMBSTONE_REWRITE_BYTES = 50 * 1024 * 1024;
   SKIP_FIRST_PROMPT_PATTERN = /^(?:\s*<[a-z][\w-]*[\s>]|\[Request interrupted by user[^\]]*\])/;
   EPHEMERAL_PROGRESS_TYPES = new Set([
@@ -596143,7 +597097,7 @@ var init_sessionStorage = __esm(() => {
   MAX_TRANSCRIPT_READ_BYTES = 50 * 1024 * 1024;
   agentTranscriptSubdirs = new Map;
   getProjectDir2 = memoize_default((projectDir) => {
-    return join183(getProjectsDir2(), sanitizePath2(projectDir));
+    return join185(getProjectsDir2(), sanitizePath2(projectDir));
   });
   METADATA_TYPE_MARKERS = [
     '"type":"summary"',
@@ -596381,41 +597335,41 @@ var init_memdir = __esm(() => {
 });
 
 // src/tools/AgentTool/agentMemory.ts
-import { join as join184, normalize as normalize14, sep as sep34 } from "path";
+import { join as join186, normalize as normalize14, sep as sep34 } from "path";
 function sanitizeAgentTypeForPath(agentType) {
   return agentType.replace(/:/g, "-");
 }
 function getLocalAgentMemoryDir(dirName) {
   if (process.env.UR_CODE_REMOTE_MEMORY_DIR) {
-    return join184(process.env.UR_CODE_REMOTE_MEMORY_DIR, "projects", sanitizePath2(findCanonicalGitRoot(getProjectRoot()) ?? getProjectRoot()), "agent-memory-local", dirName) + sep34;
+    return join186(process.env.UR_CODE_REMOTE_MEMORY_DIR, "projects", sanitizePath2(findCanonicalGitRoot(getProjectRoot()) ?? getProjectRoot()), "agent-memory-local", dirName) + sep34;
   }
-  return join184(getCwd(), ".ur", "agent-memory-local", dirName) + sep34;
+  return join186(getCwd(), ".ur", "agent-memory-local", dirName) + sep34;
 }
 function getAgentMemoryDir(agentType, scope) {
   const dirName = sanitizeAgentTypeForPath(agentType);
   switch (scope) {
     case "project":
-      return join184(getCwd(), ".ur", "agent-memory", dirName) + sep34;
+      return join186(getCwd(), ".ur", "agent-memory", dirName) + sep34;
     case "local":
       return getLocalAgentMemoryDir(dirName);
     case "user":
-      return join184(getMemoryBaseDir(), "agent-memory", dirName) + sep34;
+      return join186(getMemoryBaseDir(), "agent-memory", dirName) + sep34;
   }
 }
 function isAgentMemoryPath(absolutePath) {
   const normalizedPath = normalize14(absolutePath);
   const memoryBase = getMemoryBaseDir();
-  if (normalizedPath.startsWith(join184(memoryBase, "agent-memory") + sep34)) {
+  if (normalizedPath.startsWith(join186(memoryBase, "agent-memory") + sep34)) {
     return true;
   }
-  if (normalizedPath.startsWith(join184(getCwd(), ".ur", "agent-memory") + sep34)) {
+  if (normalizedPath.startsWith(join186(getCwd(), ".ur", "agent-memory") + sep34)) {
     return true;
   }
   if (process.env.UR_CODE_REMOTE_MEMORY_DIR) {
-    if (normalizedPath.includes(sep34 + "agent-memory-local" + sep34) && normalizedPath.startsWith(join184(process.env.UR_CODE_REMOTE_MEMORY_DIR, "projects") + sep34)) {
+    if (normalizedPath.includes(sep34 + "agent-memory-local" + sep34) && normalizedPath.startsWith(join186(process.env.UR_CODE_REMOTE_MEMORY_DIR, "projects") + sep34)) {
       return true;
     }
-  } else if (normalizedPath.startsWith(join184(getCwd(), ".ur", "agent-memory-local") + sep34)) {
+  } else if (normalizedPath.startsWith(join186(getCwd(), ".ur", "agent-memory-local") + sep34)) {
     return true;
   }
   return false;
@@ -596423,7 +597377,7 @@ function isAgentMemoryPath(absolutePath) {
 function getMemoryScopeDisplay(memory2) {
   switch (memory2) {
     case "user":
-      return `User (${join184(getMemoryBaseDir(), "agent-memory")}/)`;
+      return `User (${join186(getMemoryBaseDir(), "agent-memory")}/)`;
     case "project":
       return "Project (.ur/agent-memory/)";
     case "local":
@@ -596466,7 +597420,7 @@ var init_agentMemory = __esm(() => {
 // src/utils/permissions/filesystem.ts
 import { randomBytes as randomBytes18 } from "crypto";
 import { homedir as homedir32, tmpdir as tmpdir11 } from "os";
-import { join as join185, normalize as normalize15, posix as posix9, sep as sep35 } from "path";
+import { join as join187, normalize as normalize15, posix as posix9, sep as sep35 } from "path";
 function normalizeCaseForComparison(path22) {
   return path22.toLowerCase();
 }
@@ -596475,11 +597429,11 @@ function getURSkillScope(filePath) {
   const absolutePathLower = normalizeCaseForComparison(absolutePath);
   const bases = [
     {
-      dir: expandPath(join185(getOriginalCwd(), ".ur", "skills")),
+      dir: expandPath(join187(getOriginalCwd(), ".ur", "skills")),
       prefix: "/.ur/skills/"
     },
     {
-      dir: expandPath(join185(homedir32(), ".ur", "skills")),
+      dir: expandPath(join187(homedir32(), ".ur", "skills")),
       prefix: "~/.ur/skills/"
     }
   ];
@@ -596534,21 +597488,21 @@ function isURConfigFilePath(filePath) {
   if (isURSettingsPath(filePath)) {
     return true;
   }
-  const commandsDir = join185(getOriginalCwd(), ".ur", "commands");
-  const agentsDir = join185(getOriginalCwd(), ".ur", "agents");
-  const skillsDir = join185(getOriginalCwd(), ".ur", "skills");
+  const commandsDir = join187(getOriginalCwd(), ".ur", "commands");
+  const agentsDir = join187(getOriginalCwd(), ".ur", "agents");
+  const skillsDir = join187(getOriginalCwd(), ".ur", "skills");
   return pathInWorkingPath(filePath, commandsDir) || pathInWorkingPath(filePath, agentsDir) || pathInWorkingPath(filePath, skillsDir);
 }
 function isSessionPlanFile(absolutePath) {
-  const expectedPrefix = join185(getPlansDirectory(), getPlanSlug());
+  const expectedPrefix = join187(getPlansDirectory(), getPlanSlug());
   const normalizedPath = normalize15(absolutePath);
   return normalizedPath.startsWith(expectedPrefix) && normalizedPath.endsWith(".md");
 }
 function getSessionMemoryDir() {
-  return join185(getProjectDir2(getCwd()), getSessionId(), "session-memory") + sep35;
+  return join187(getProjectDir2(getCwd()), getSessionId(), "session-memory") + sep35;
 }
 function getSessionMemoryPath() {
-  return join185(getSessionMemoryDir(), "summary.md");
+  return join187(getSessionMemoryDir(), "summary.md");
 }
 function isSessionMemoryPath(absolutePath) {
   const normalizedPath = normalize15(absolutePath);
@@ -596570,10 +597524,10 @@ function getURTempDirName() {
   return `ur-${uid}`;
 }
 function getProjectTempDir() {
-  return join185(getURTempDir(), sanitizePath2(getOriginalCwd())) + sep35;
+  return join187(getURTempDir(), sanitizePath2(getOriginalCwd())) + sep35;
 }
 function getScratchpadDir() {
-  return join185(getProjectTempDir(), getSessionId(), "scratchpad");
+  return join187(getProjectTempDir(), getSessionId(), "scratchpad");
 }
 async function ensureScratchpadDir() {
   if (!isScratchpadEnabled()) {
@@ -597151,7 +598105,7 @@ function checkEditableInternalPath(absolutePath, input) {
       }
     };
   }
-  if (normalizeCaseForComparison(normalizedPath) === normalizeCaseForComparison(join185(getOriginalCwd(), ".ur", "launch.json"))) {
+  if (normalizeCaseForComparison(normalizedPath) === normalizeCaseForComparison(join187(getOriginalCwd(), ".ur", "launch.json"))) {
     return {
       behavior: "allow",
       updatedInput: input,
@@ -597248,7 +598202,7 @@ function checkReadableInternalPath(absolutePath, input) {
       }
     };
   }
-  const tasksDir = join185(getURConfigHomeDir(), "tasks") + sep35;
+  const tasksDir = join187(getURConfigHomeDir(), "tasks") + sep35;
   if (normalizedPath === tasksDir.slice(0, -1) || normalizedPath.startsWith(tasksDir)) {
     return {
       behavior: "allow",
@@ -597259,7 +598213,7 @@ function checkReadableInternalPath(absolutePath, input) {
       }
     };
   }
-  const teamsReadDir = join185(getURConfigHomeDir(), "teams") + sep35;
+  const teamsReadDir = join187(getURConfigHomeDir(), "teams") + sep35;
   if (normalizedPath === teamsReadDir.slice(0, -1) || normalizedPath.startsWith(teamsReadDir)) {
     return {
       behavior: "allow",
@@ -597332,11 +598286,11 @@ var init_filesystem = __esm(() => {
     try {
       resolvedBaseTmpDir = fs12.realpathSync(baseTmpDir);
     } catch {}
-    return join185(resolvedBaseTmpDir, getURTempDirName()) + sep35;
+    return join187(resolvedBaseTmpDir, getURTempDirName()) + sep35;
   });
   getBundledSkillsRoot = memoize_default(function getBundledSkillsRoot2() {
     const nonce = randomBytes18(16).toString("hex");
-    return join185(getURTempDir(), "bundled-skills", "1.22.0", nonce);
+    return join187(getURTempDir(), "bundled-skills", "1.22.1", nonce);
   });
   getResolvedWorkingDirPaths = memoize_default(getPathsForPermissionCheck);
 });
@@ -597350,10 +598304,10 @@ import {
   symlink as symlink4,
   unlink as unlink23
 } from "fs/promises";
-import { join as join186 } from "path";
+import { join as join188 } from "path";
 function getTaskOutputDir() {
   if (_taskOutputDir === undefined) {
-    _taskOutputDir = join186(getProjectTempDir(), getSessionId(), "tasks");
+    _taskOutputDir = join188(getProjectTempDir(), getSessionId(), "tasks");
   }
   return _taskOutputDir;
 }
@@ -597361,7 +598315,7 @@ async function ensureOutputDir() {
   await mkdir41(getTaskOutputDir(), { recursive: true });
 }
 function getTaskOutputPath(taskId) {
-  return join186(getTaskOutputDir(), `${taskId}.output`);
+  return join188(getTaskOutputDir(), `${taskId}.output`);
 }
 function track(p2) {
   _pendingOps.add(p2);
@@ -601629,7 +602583,7 @@ import {
   symlink as symlink5,
   utimes as utimes2
 } from "fs/promises";
-import { basename as basename44, dirname as dirname66, join as join187 } from "path";
+import { basename as basename44, dirname as dirname66, join as join189 } from "path";
 function validateWorktreeSlug(slug4) {
   if (slug4.length > MAX_WORKTREE_SLUG_LENGTH) {
     throw new Error(`Invalid worktree name: must be ${MAX_WORKTREE_SLUG_LENGTH} characters or fewer (got ${slug4.length})`);
@@ -601652,8 +602606,8 @@ async function symlinkDirectories(repoRootPath, worktreePath, dirsToSymlink) {
       logForDebugging(`Skipping symlink for "${dir}": path traversal detected`, { level: "warn" });
       continue;
     }
-    const sourcePath = join187(repoRootPath, dir);
-    const destPath = join187(worktreePath, dir);
+    const sourcePath = join189(repoRootPath, dir);
+    const destPath = join189(worktreePath, dir);
     try {
       await symlink5(sourcePath, destPath, "dir");
       logForDebugging(`Symlinked ${dir} from main repository to worktree to avoid disk bloat`);
@@ -601677,7 +602631,7 @@ function generateTmuxSessionName(repoPath, branch2) {
   return combined.replace(/[/.]/g, "_");
 }
 function worktreesDir2(repoRoot) {
-  return join187(repoRoot, ".ur", "worktrees");
+  return join189(repoRoot, ".ur", "worktrees");
 }
 function flattenSlug(slug4) {
   return slug4.replaceAll("/", "+");
@@ -601686,7 +602640,7 @@ function worktreeBranchName(slug4) {
   return `worktree-${flattenSlug(slug4)}`;
 }
 function worktreePathFor(repoRoot, slug4) {
-  return join187(worktreesDir2(repoRoot), flattenSlug(slug4));
+  return join189(worktreesDir2(repoRoot), flattenSlug(slug4));
 }
 async function getOrCreateWorktree(repoRoot, slug4, options2) {
   const worktreePath = worktreePathFor(repoRoot, slug4);
@@ -601767,7 +602721,7 @@ async function getOrCreateWorktree(repoRoot, slug4, options2) {
 async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
   let includeContent;
   try {
-    includeContent = await readFile51(join187(repoRoot, ".worktreeinclude"), "utf-8");
+    includeContent = await readFile51(join189(repoRoot, ".worktreeinclude"), "utf-8");
   } catch {
     return [];
   }
@@ -601822,8 +602776,8 @@ async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
   }
   const copied = [];
   for (const relativePath2 of files2) {
-    const srcPath = join187(repoRoot, relativePath2);
-    const destPath = join187(worktreePath, relativePath2);
+    const srcPath = join189(repoRoot, relativePath2);
+    const destPath = join189(worktreePath, relativePath2);
     try {
       await mkdir42(dirname66(destPath), { recursive: true });
       await copyFile10(srcPath, destPath);
@@ -601839,9 +602793,9 @@ async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
 }
 async function performPostCreationSetup(repoRoot, worktreePath) {
   const localSettingsRelativePath = getRelativeSettingsFilePathForSource("localSettings");
-  const sourceSettingsLocal = join187(repoRoot, localSettingsRelativePath);
+  const sourceSettingsLocal = join189(repoRoot, localSettingsRelativePath);
   try {
-    const destSettingsLocal = join187(worktreePath, localSettingsRelativePath);
+    const destSettingsLocal = join189(worktreePath, localSettingsRelativePath);
     await mkdirRecursive(dirname66(destSettingsLocal));
     await copyFile10(sourceSettingsLocal, destSettingsLocal);
     logForDebugging(`Copied settings.local.json to worktree: ${destSettingsLocal}`);
@@ -601851,8 +602805,8 @@ async function performPostCreationSetup(repoRoot, worktreePath) {
       logForDebugging(`Failed to copy settings.local.json: ${e.message}`, { level: "warn" });
     }
   }
-  const huskyPath = join187(repoRoot, ".husky");
-  const gitHooksPath = join187(repoRoot, ".git", "hooks");
+  const huskyPath = join189(repoRoot, ".husky");
+  const gitHooksPath = join189(repoRoot, ".git", "hooks");
   let hooksPath = null;
   for (const candidatePath of [huskyPath, gitHooksPath]) {
     try {
@@ -602127,7 +603081,7 @@ async function cleanupStaleAgentWorktrees(cutoffDate) {
     if (!EPHEMERAL_WORKTREE_PATTERNS.some((p2) => p2.test(slug4))) {
       continue;
     }
-    const worktreePath = join187(dir, slug4);
+    const worktreePath = join189(dir, slug4);
     if (currentPath === worktreePath) {
       continue;
     }
@@ -603367,7 +604321,7 @@ function computeFingerprint(messageText, version3) {
 }
 function computeFingerprintFromMessages(messages) {
   const firstMessageText = extractFirstMessageText(messages);
-  return computeFingerprint(firstMessageText, "1.22.0");
+  return computeFingerprint(firstMessageText, "1.22.1");
 }
 var FINGERPRINT_SALT = "59cf53e54c78";
 var init_fingerprint = () => {};
@@ -605233,7 +606187,7 @@ async function sideQuery(opts) {
     betas.push(STRUCTURED_OUTPUTS_BETA_HEADER);
   }
   const messageText = extractFirstUserMessageText(messages);
-  const fingerprint = computeFingerprint(messageText, "1.22.0");
+  const fingerprint = computeFingerprint(messageText, "1.22.1");
   const attributionHeader = getAttributionHeader(fingerprint);
   const systemBlocks = [
     attributionHeader ? { type: "text", text: attributionHeader } : null,
@@ -605519,7 +606473,7 @@ import {
 } from "fs/promises";
 import { createServer as createServer5 } from "net";
 import { homedir as homedir33, platform as platform6 } from "os";
-import { join as join188 } from "path";
+import { join as join190 } from "path";
 function log(message, ...args) {
   if (LOG_FILE) {
     const timestamp2 = new Date().toISOString();
@@ -605586,7 +606540,7 @@ class ChromeNativeHost {
           try {
             process.kill(pid, 0);
           } catch {
-            await unlink24(join188(socketDir, file4)).catch(() => {});
+            await unlink24(join190(socketDir, file4)).catch(() => {});
             log(`Removed stale socket for PID ${pid}`);
           }
         }
@@ -605857,7 +606811,7 @@ var init_chromeNativeHost = __esm(() => {
   init_slowOperations();
   init_common2();
   MAX_MESSAGE_SIZE = 1024 * 1024;
-  LOG_FILE = process.env.USER_TYPE === "ant" ? join188(homedir33(), ".ur", "debug", "chrome-native-host.txt") : undefined;
+  LOG_FILE = process.env.USER_TYPE === "ant" ? join190(homedir33(), ".ur", "debug", "chrome-native-host.txt") : undefined;
   messageSchema = lazySchema(() => exports_external2.object({
     type: exports_external2.string()
   }).passthrough());
@@ -608367,7 +609321,7 @@ __export(exports_upstreamproxy, {
 });
 import { mkdir as mkdir44, readFile as readFile52, unlink as unlink25, writeFile as writeFile45 } from "fs/promises";
 import { homedir as homedir34 } from "os";
-import { join as join189 } from "path";
+import { join as join191 } from "path";
 async function initUpstreamProxy(opts) {
   if (!isEnvTruthy(process.env.UR_CODE_REMOTE)) {
     return state;
@@ -608388,7 +609342,7 @@ async function initUpstreamProxy(opts) {
   }
   setNonDumpable();
   const baseUrl = opts?.ccrBaseUrl ?? "";
-  const caBundlePath = opts?.caBundlePath ?? join189(homedir34(), ".ccr", "ca-bundle.crt");
+  const caBundlePath = opts?.caBundlePath ?? join191(homedir34(), ".ccr", "ca-bundle.crt");
   const caOk = await downloadCaBundle(baseUrl, opts?.systemCaPath ?? SYSTEM_CA_BUNDLE, caBundlePath);
   if (!caOk)
     return state;
@@ -608488,7 +609442,7 @@ async function downloadCaBundle(baseUrl, systemCaPath, outPath) {
     }
     const ccrCa = await resp.text();
     const systemCa = await readFile52(systemCaPath, "utf8").catch(() => "");
-    await mkdir44(join189(outPath, ".."), { recursive: true });
+    await mkdir44(join191(outPath, ".."), { recursive: true });
     await writeFile45(outPath, systemCa + `
 ` + ccrCa, "utf8");
     return true;
@@ -609970,7 +610924,7 @@ function buildSystemInitMessage(inputs) {
     slash_commands: inputs.commands.filter((c4) => c4.userInvocable !== false).map((c4) => c4.name),
     apiKeySource: getURHQApiKeyWithSource().source,
     betas: getSdkBetas(),
-    ur_version: "1.22.0",
+    ur_version: "1.22.1",
     output_style: outputStyle2,
     agents: inputs.agents.map((agent) => agent.agentType),
     skills: inputs.skills.filter((s) => s.userInvocable !== false).map((skill) => skill.name),
@@ -616350,7 +617304,7 @@ var init_ShowInIDEPrompt = __esm(() => {
 
 // src/components/permissions/FilePermissionDialog/permissionOptions.tsx
 import { homedir as homedir35 } from "os";
-import { basename as basename48, join as join190, sep as sep36 } from "path";
+import { basename as basename48, join as join192, sep as sep36 } from "path";
 function isInURFolder(filePath) {
   const absolutePath = expandPath(filePath);
   const urFolderPath = expandPath(`${getOriginalCwd()}/.ur`);
@@ -616360,7 +617314,7 @@ function isInURFolder(filePath) {
 }
 function isInGlobalURFolder(filePath) {
   const absolutePath = expandPath(filePath);
-  const globalURFolderPath = join190(homedir35(), ".ur");
+  const globalURFolderPath = join192(homedir35(), ".ur");
   const normalizedAbsolutePath = normalizeCaseForComparison(absolutePath);
   const normalizedGlobalURFolderPath = normalizeCaseForComparison(globalURFolderPath);
   return normalizedAbsolutePath.startsWith(normalizedGlobalURFolderPath + sep36.toLowerCase()) || normalizedAbsolutePath.startsWith(normalizedGlobalURFolderPath + "/");
@@ -624598,7 +625552,7 @@ var init_useVoiceEnabled = __esm(() => {
 function getSemverPart(version3) {
   return `${import_semver13.major(version3, { loose: true })}.${import_semver13.minor(version3, { loose: true })}.${import_semver13.patch(version3, { loose: true })}`;
 }
-function useUpdateNotification(updatedVersion, initialVersion = "1.22.0") {
+function useUpdateNotification(updatedVersion, initialVersion = "1.22.1") {
   const [lastNotifiedSemver, setLastNotifiedSemver] = import_react224.useState(() => getSemverPart(initialVersion));
   if (!updatedVersion) {
     return null;
@@ -624647,7 +625601,7 @@ function AutoUpdater({
       return;
     }
     if (false) {}
-    const currentVersion = "1.22.0";
+    const currentVersion = "1.22.1";
     const channel = getInitialSettings()?.autoUpdatesChannel ?? "latest";
     let latestVersion = await getLatestVersion(channel);
     const isDisabled = isAutoUpdaterDisabled();
@@ -624876,12 +625830,12 @@ function NativeAutoUpdater({
     logEvent("tengu_native_auto_updater_start", {});
     try {
       const maxVersion = await getMaxVersion();
-      if (maxVersion && gt("1.22.0", maxVersion)) {
+      if (maxVersion && gt("1.22.1", maxVersion)) {
         const msg = await getMaxVersionMessage();
         setMaxVersionIssue(msg ?? "affects your version");
       }
       const result = await installLatest(channel);
-      const currentVersion = "1.22.0";
+      const currentVersion = "1.22.1";
       const latencyMs = Date.now() - startTime;
       if (result.lockFailed) {
         logEvent("tengu_native_auto_updater_lock_contention", {
@@ -625018,17 +625972,17 @@ function PackageManagerAutoUpdater(t0) {
       const maxVersion = await getMaxVersion();
       if (maxVersion && latest && gt(latest, maxVersion)) {
         logForDebugging(`PackageManagerAutoUpdater: maxVersion ${maxVersion} is set, capping update from ${latest} to ${maxVersion}`);
-        if (gte("1.22.0", maxVersion)) {
-          logForDebugging(`PackageManagerAutoUpdater: current version ${"1.22.0"} is already at or above maxVersion ${maxVersion}, skipping update`);
+        if (gte("1.22.1", maxVersion)) {
+          logForDebugging(`PackageManagerAutoUpdater: current version ${"1.22.1"} is already at or above maxVersion ${maxVersion}, skipping update`);
           setUpdateAvailable(false);
           return;
         }
         latest = maxVersion;
       }
-      const hasUpdate = latest && !gte("1.22.0", latest) && !shouldSkipVersion(latest);
+      const hasUpdate = latest && !gte("1.22.1", latest) && !shouldSkipVersion(latest);
       setUpdateAvailable(!!hasUpdate);
       if (hasUpdate) {
-        logForDebugging(`PackageManagerAutoUpdater: Update available ${"1.22.0"} -> ${latest}`);
+        logForDebugging(`PackageManagerAutoUpdater: Update available ${"1.22.1"} -> ${latest}`);
       }
     };
     $3[0] = t1;
@@ -625062,7 +626016,7 @@ function PackageManagerAutoUpdater(t0) {
       wrap: "truncate",
       children: [
         "currentVersion: ",
-        "1.22.0"
+        "1.22.1"
       ]
     }, undefined, true, undefined, this);
     $3[3] = verbose;
@@ -637424,7 +638378,7 @@ function buildStatusLineCommandInput(permissionMode, exceeds200kTokens, settings
       project_dir: getOriginalCwd(),
       added_dirs: addedDirs
     },
-    version: "1.22.0",
+    version: "1.22.1",
     output_style: {
       name: outputStyleName
     },
@@ -643532,9 +644486,9 @@ function initSkillImprovement() {
 async function applySkillImprovement(skillName, updates) {
   if (!skillName)
     return;
-  const { join: join191 } = await import("path");
+  const { join: join193 } = await import("path");
   const fs12 = await import("fs/promises");
-  const filePath = join191(getCwd(), ".ur", "skills", skillName, "SKILL.md");
+  const filePath = join193(getCwd(), ".ur", "skills", skillName, "SKILL.md");
   let currentContent;
   try {
     currentContent = await fs12.readFile(filePath, "utf-8");
@@ -643688,7 +644642,7 @@ function useMoreRight(_args) {
 // src/utils/cleanup.ts
 import * as fs12 from "fs/promises";
 import { homedir as homedir36 } from "os";
-import { join as join191 } from "path";
+import { join as join193 } from "path";
 function getCutoffDate() {
   const settings = getSettings_DEPRECATED() || {};
   const cleanupPeriodDays = settings.cleanupPeriodDays ?? DEFAULT_CLEANUP_PERIOD_DAYS;
@@ -643713,7 +644667,7 @@ async function cleanupOldFilesInDirectory(dirPath, cutoffDate, isMessagePath) {
       try {
         const timestamp2 = convertFileNameToDate(file4.name);
         if (timestamp2 < cutoffDate) {
-          await getFsImplementation().unlink(join191(dirPath, file4.name));
+          await getFsImplementation().unlink(join193(dirPath, file4.name));
           if (isMessagePath) {
             result.messages++;
           } else {
@@ -643744,7 +644698,7 @@ async function cleanupOldMessageFiles() {
     } catch {
       return result;
     }
-    const mcpLogDirs = dirents.filter((dirent) => dirent.isDirectory() && dirent.name.startsWith("mcp-logs-")).map((dirent) => join191(baseCachePath, dirent.name));
+    const mcpLogDirs = dirents.filter((dirent) => dirent.isDirectory() && dirent.name.startsWith("mcp-logs-")).map((dirent) => join193(baseCachePath, dirent.name));
     for (const mcpLogDir of mcpLogDirs) {
       result = addCleanupResults(result, await cleanupOldFilesInDirectory(mcpLogDir, cutoffDate, true));
       await tryRmdir(mcpLogDir, fsImpl);
@@ -643783,7 +644737,7 @@ async function cleanupOldSessionFiles() {
   for (const projectDirent of projectDirents) {
     if (!projectDirent.isDirectory())
       continue;
-    const projectDir = join191(projectsDir, projectDirent.name);
+    const projectDir = join193(projectsDir, projectDirent.name);
     let entries;
     try {
       entries = await fsImpl.readdir(projectDir);
@@ -643797,15 +644751,15 @@ async function cleanupOldSessionFiles() {
           continue;
         }
         try {
-          if (await unlinkIfOld(join191(projectDir, entry.name), cutoffDate, fsImpl)) {
+          if (await unlinkIfOld(join193(projectDir, entry.name), cutoffDate, fsImpl)) {
             result.messages++;
           }
         } catch {
           result.errors++;
         }
       } else if (entry.isDirectory()) {
-        const sessionDir = join191(projectDir, entry.name);
-        const toolResultsDir = join191(sessionDir, TOOL_RESULTS_SUBDIR);
+        const sessionDir = join193(projectDir, entry.name);
+        const toolResultsDir = join193(sessionDir, TOOL_RESULTS_SUBDIR);
         let toolDirs;
         try {
           toolDirs = await fsImpl.readdir(toolResultsDir);
@@ -643816,14 +644770,14 @@ async function cleanupOldSessionFiles() {
         for (const toolEntry of toolDirs) {
           if (toolEntry.isFile()) {
             try {
-              if (await unlinkIfOld(join191(toolResultsDir, toolEntry.name), cutoffDate, fsImpl)) {
+              if (await unlinkIfOld(join193(toolResultsDir, toolEntry.name), cutoffDate, fsImpl)) {
                 result.messages++;
               }
             } catch {
               result.errors++;
             }
           } else if (toolEntry.isDirectory()) {
-            const toolDirPath = join191(toolResultsDir, toolEntry.name);
+            const toolDirPath = join193(toolResultsDir, toolEntry.name);
             let toolFiles;
             try {
               toolFiles = await fsImpl.readdir(toolDirPath);
@@ -643834,7 +644788,7 @@ async function cleanupOldSessionFiles() {
               if (!tf.isFile())
                 continue;
               try {
-                if (await unlinkIfOld(join191(toolDirPath, tf.name), cutoffDate, fsImpl)) {
+                if (await unlinkIfOld(join193(toolDirPath, tf.name), cutoffDate, fsImpl)) {
                   result.messages++;
                 }
               } catch {
@@ -643866,7 +644820,7 @@ async function cleanupSingleDirectory(dirPath, extension, removeEmptyDir = true)
     if (!dirent.isFile() || !dirent.name.endsWith(extension))
       continue;
     try {
-      if (await unlinkIfOld(join191(dirPath, dirent.name), cutoffDate, fsImpl)) {
+      if (await unlinkIfOld(join193(dirPath, dirent.name), cutoffDate, fsImpl)) {
         result.messages++;
       }
     } catch {
@@ -643879,7 +644833,7 @@ async function cleanupSingleDirectory(dirPath, extension, removeEmptyDir = true)
   return result;
 }
 function cleanupOldPlanFiles() {
-  const plansDir = join191(getURConfigHomeDir(), "plans");
+  const plansDir = join193(getURConfigHomeDir(), "plans");
   return cleanupSingleDirectory(plansDir, ".md");
 }
 async function cleanupOldFileHistoryBackups() {
@@ -643888,14 +644842,14 @@ async function cleanupOldFileHistoryBackups() {
   const fsImpl = getFsImplementation();
   try {
     const configDir = getURConfigHomeDir();
-    const fileHistoryStorageDir = join191(configDir, "file-history");
+    const fileHistoryStorageDir = join193(configDir, "file-history");
     let dirents;
     try {
       dirents = await fsImpl.readdir(fileHistoryStorageDir);
     } catch {
       return result;
     }
-    const fileHistorySessionsDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join191(fileHistoryStorageDir, dirent.name));
+    const fileHistorySessionsDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join193(fileHistoryStorageDir, dirent.name));
     await Promise.all(fileHistorySessionsDirs.map(async (fileHistorySessionDir) => {
       try {
         const stats2 = await fsImpl.stat(fileHistorySessionDir);
@@ -643922,14 +644876,14 @@ async function cleanupOldSessionEnvDirs() {
   const fsImpl = getFsImplementation();
   try {
     const configDir = getURConfigHomeDir();
-    const sessionEnvBaseDir = join191(configDir, "session-env");
+    const sessionEnvBaseDir = join193(configDir, "session-env");
     let dirents;
     try {
       dirents = await fsImpl.readdir(sessionEnvBaseDir);
     } catch {
       return result;
     }
-    const sessionEnvDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join191(sessionEnvBaseDir, dirent.name));
+    const sessionEnvDirs = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => join193(sessionEnvBaseDir, dirent.name));
     for (const sessionEnvDir of sessionEnvDirs) {
       try {
         const stats2 = await fsImpl.stat(sessionEnvDir);
@@ -643951,7 +644905,7 @@ async function cleanupOldDebugLogs() {
   const cutoffDate = getCutoffDate();
   const result = { messages: 0, errors: 0 };
   const fsImpl = getFsImplementation();
-  const debugDir = join191(getURConfigHomeDir(), "debug");
+  const debugDir = join193(getURConfigHomeDir(), "debug");
   let dirents;
   try {
     dirents = await fsImpl.readdir(debugDir);
@@ -643963,7 +644917,7 @@ async function cleanupOldDebugLogs() {
       continue;
     }
     try {
-      if (await unlinkIfOld(join191(debugDir, dirent.name), cutoffDate, fsImpl)) {
+      if (await unlinkIfOld(join193(debugDir, dirent.name), cutoffDate, fsImpl)) {
         result.messages++;
       }
     } catch {
@@ -643973,7 +644927,7 @@ async function cleanupOldDebugLogs() {
   return result;
 }
 async function cleanupNpmCacheForURHQPackages() {
-  const markerPath = join191(getURConfigHomeDir(), ".npm-cache-cleanup");
+  const markerPath = join193(getURConfigHomeDir(), ".npm-cache-cleanup");
   try {
     const stat47 = await fs12.stat(markerPath);
     if (Date.now() - stat47.mtimeMs < ONE_DAY_MS) {
@@ -643988,7 +644942,7 @@ async function cleanupNpmCacheForURHQPackages() {
     return;
   }
   logForDebugging("npm cache cleanup: starting");
-  const npmCachePath = join191(homedir36(), ".npm", "_cacache");
+  const npmCachePath = join193(homedir36(), ".npm", "_cacache");
   const NPM_CACHE_RETENTION_COUNT = 5;
   const startTime = Date.now();
   try {
@@ -644043,7 +644997,7 @@ async function cleanupNpmCacheForURHQPackages() {
   }
 }
 async function cleanupOldVersionsThrottled() {
-  const markerPath = join191(getURConfigHomeDir(), ".version-cleanup");
+  const markerPath = join193(getURConfigHomeDir(), ".version-cleanup");
   try {
     const stat47 = await fs12.stat(markerPath);
     if (Date.now() - stat47.mtimeMs < ONE_DAY_MS) {
@@ -647286,7 +648240,7 @@ __export(exports_asciicast, {
   _resetRecordingStateForTesting: () => _resetRecordingStateForTesting
 });
 import { appendFile as appendFile7, rename as rename10 } from "fs/promises";
-import { basename as basename57, dirname as dirname67, join as join193 } from "path";
+import { basename as basename57, dirname as dirname67, join as join195 } from "path";
 function getRecordFilePath() {
   if (recordingState.filePath !== null) {
     return recordingState.filePath;
@@ -647297,10 +648251,10 @@ function getRecordFilePath() {
   if (!isEnvTruthy(process.env.UR_CODE_TERMINAL_RECORDING)) {
     return null;
   }
-  const projectsDir = join193(getURConfigHomeDir(), "projects");
-  const projectDir = join193(projectsDir, sanitizePath2(getOriginalCwd()));
+  const projectsDir = join195(getURConfigHomeDir(), "projects");
+  const projectDir = join195(projectsDir, sanitizePath2(getOriginalCwd()));
   recordingState.timestamp = Date.now();
-  recordingState.filePath = join193(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  recordingState.filePath = join195(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
   return recordingState.filePath;
 }
 function _resetRecordingStateForTesting() {
@@ -647309,13 +648263,13 @@ function _resetRecordingStateForTesting() {
 }
 function getSessionRecordingPaths() {
   const sessionId = getSessionId();
-  const projectsDir = join193(getURConfigHomeDir(), "projects");
-  const projectDir = join193(projectsDir, sanitizePath2(getOriginalCwd()));
+  const projectsDir = join195(getURConfigHomeDir(), "projects");
+  const projectDir = join195(projectsDir, sanitizePath2(getOriginalCwd()));
   try {
     const entries = getFsImplementation().readdirSync(projectDir);
     const names = typeof entries[0] === "string" ? entries : entries.map((e) => e.name);
     const files2 = names.filter((f) => f.startsWith(sessionId) && f.endsWith(".cast")).sort();
-    return files2.map((f) => join193(projectDir, f));
+    return files2.map((f) => join195(projectDir, f));
   } catch {
     return [];
   }
@@ -647325,9 +648279,9 @@ async function renameRecordingForSession() {
   if (!oldPath || recordingState.timestamp === 0) {
     return;
   }
-  const projectsDir = join193(getURConfigHomeDir(), "projects");
-  const projectDir = join193(projectsDir, sanitizePath2(getOriginalCwd()));
-  const newPath = join193(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  const projectsDir = join195(getURConfigHomeDir(), "projects");
+  const projectDir = join195(projectsDir, sanitizePath2(getOriginalCwd()));
+  const newPath = join195(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
   if (oldPath === newPath) {
     return;
   }
@@ -648932,7 +649886,7 @@ async function submitTranscriptShare(messages, trigger2, appearanceId) {
     } catch {}
     const data = {
       trigger: trigger2,
-      version: "1.22.0",
+      version: "1.22.1",
       platform: process.platform,
       transcript,
       subagentTranscripts: Object.keys(subagentTranscripts).length > 0 ? subagentTranscripts : undefined,
@@ -650204,7 +651158,7 @@ var init_useChromeExtensionNotification = __esm(() => {
 });
 
 // src/utils/plugins/officialMarketplaceStartupCheck.ts
-import { join as join194 } from "path";
+import { join as join196 } from "path";
 function isOfficialMarketplaceAutoInstallDisabled() {
   return isEnvTruthy(process.env.UR_CODE_DISABLE_OFFICIAL_MARKETPLACE_AUTOINSTALL);
 }
@@ -650288,7 +651242,7 @@ async function checkAndInstallOfficialMarketplace() {
       return { installed: false, skipped: true, reason: "policy_blocked" };
     }
     const cacheDir = getMarketplacesCacheDir();
-    const installLocation = join194(cacheDir, OFFICIAL_MARKETPLACE_NAME);
+    const installLocation = join196(cacheDir, OFFICIAL_MARKETPLACE_NAME);
     const gcsSha = await fetchOfficialMarketplaceFromGcs(installLocation, cacheDir);
     if (gcsSha !== null) {
       const known = await loadKnownMarketplacesConfig();
@@ -653303,7 +654257,7 @@ var init_usePluginRecommendationBase = __esm(() => {
 });
 
 // src/hooks/useLspPluginRecommendation.tsx
-import { extname as extname20, join as join195 } from "path";
+import { extname as extname20, join as join197 } from "path";
 function useLspPluginRecommendation() {
   const $3 = import_compiler_runtime347.c(12);
   const trackedFiles = useAppState(_temp205);
@@ -653388,7 +654342,7 @@ function useLspPluginRecommendation() {
           case "yes": {
             installPluginAndNotify(pluginId, pluginName, "lsp-plugin", addNotification, async (pluginData) => {
               logForDebugging(`[useLspPluginRecommendation] Installing plugin: ${pluginId}`);
-              const localSourcePath = typeof pluginData.entry.source === "string" ? join195(pluginData.marketplaceInstallLocation, pluginData.entry.source) : undefined;
+              const localSourcePath = typeof pluginData.entry.source === "string" ? join197(pluginData.marketplaceInstallLocation, pluginData.entry.source) : undefined;
               await cacheAndRegisterPlugin(pluginId, pluginData.entry, "user", undefined, localSourcePath);
               const settings = getSettingsForSource("userSettings");
               updateSettingsForSource("userSettings", {
@@ -656218,7 +657172,7 @@ var exports_REPL = {};
 __export(exports_REPL, {
   REPL: () => REPL
 });
-import { dirname as dirname69, join as join196 } from "path";
+import { dirname as dirname69, join as join198 } from "path";
 import { tmpdir as tmpdir12 } from "os";
 import { writeFile as writeFile47 } from "fs/promises";
 import { randomUUID as randomUUID51 } from "crypto";
@@ -658790,7 +659744,7 @@ Note: ctrl + z now suspends UR, ctrl + _ undoes input.
           const w = Math.max(80, (process.stdout.columns ?? 80) - 6);
           const raw = await renderMessagesToPlainText(deferredMessages, tools, w);
           const text = raw.replace(/[ \t]+$/gm, "");
-          const path24 = join196(tmpdir12(), `cc-transcript-${Date.now()}.txt`);
+          const path24 = join198(tmpdir12(), `cc-transcript-${Date.now()}.txt`);
           await writeFile47(path24, text);
           const opened = openFileInExternalEditor(path24);
           setStatus2(opened ? `opening ${path24}` : `wrote ${path24} \xB7 no $VISUAL/$EDITOR set`);
@@ -660841,7 +661795,7 @@ function WelcomeV2() {
             dimColor: true,
             children: [
               "v",
-              "1.22.0"
+              "1.22.1"
             ]
           }, undefined, true, undefined, this)
         ]
@@ -662101,7 +663055,7 @@ function completeOnboarding() {
   saveGlobalConfig((current) => ({
     ...current,
     hasCompletedOnboarding: true,
-    lastOnboardingVersion: "1.22.0"
+    lastOnboardingVersion: "1.22.1"
   }));
 }
 function showDialog(root2, renderer) {
@@ -667152,12 +668106,12 @@ var init_createDirectConnectSession = __esm(() => {
 });
 
 // src/utils/errorLogSink.ts
-import { dirname as dirname71, join as join197 } from "path";
+import { dirname as dirname71, join as join199 } from "path";
 function getErrorsPath() {
-  return join197(CACHE_PATHS.errors(), DATE + ".jsonl");
+  return join199(CACHE_PATHS.errors(), DATE + ".jsonl");
 }
 function getMCPLogsPath(serverName) {
-  return join197(CACHE_PATHS.mcpLogs(serverName), DATE + ".jsonl");
+  return join199(CACHE_PATHS.mcpLogs(serverName), DATE + ".jsonl");
 }
 function createJsonlWriter(options2) {
   const writer = createBufferedWriter(options2);
@@ -667201,7 +668155,7 @@ function appendToLog(path24, message) {
     cwd: getFsImplementation().cwd(),
     userType: process.env.USER_TYPE,
     sessionId: getSessionId(),
-    version: "1.22.0"
+    version: "1.22.1"
   };
   getLogWriter(path24).write(messageWithTimestamp);
 }
@@ -667500,7 +668454,7 @@ var init_sessionMemory = __esm(() => {
 // src/utils/iTermBackup.ts
 import { copyFile as copyFile11, stat as stat49 } from "fs/promises";
 import { homedir as homedir38 } from "os";
-import { join as join198 } from "path";
+import { join as join200 } from "path";
 function markITerm2SetupComplete() {
   saveGlobalConfig((current) => ({
     ...current,
@@ -667515,7 +668469,7 @@ function getIterm2RecoveryInfo() {
   };
 }
 function getITerm2PlistPath() {
-  return join198(homedir38(), "Library", "Preferences", "com.googlecode.iterm2.plist");
+  return join200(homedir38(), "Library", "Preferences", "com.googlecode.iterm2.plist");
 }
 async function checkAndRestoreITerm2Backup() {
   const { inProgress, backupPath } = getIterm2RecoveryInfo();
@@ -671024,7 +671978,7 @@ var init_idleTimeout = __esm(() => {
 // src/bridge/inboundAttachments.ts
 import { randomUUID as randomUUID54 } from "crypto";
 import { mkdir as mkdir45, writeFile as writeFile49 } from "fs/promises";
-import { basename as basename58, join as join199 } from "path";
+import { basename as basename58, join as join201 } from "path";
 function debug(msg) {
   logForDebugging(`[bridge:inbound-attach] ${msg}`);
 }
@@ -671040,7 +671994,7 @@ function sanitizeFileName(name) {
   return base2 || "attachment";
 }
 function uploadsDir() {
-  return join199(getURConfigHomeDir(), "uploads", getSessionId());
+  return join201(getURConfigHomeDir(), "uploads", getSessionId());
 }
 async function resolveOne(att) {
   const token = getBridgeAccessToken();
@@ -671069,7 +672023,7 @@ async function resolveOne(att) {
   const safeName = sanitizeFileName(att.file_name);
   const prefix = (att.file_uuid.slice(0, 8) || randomUUID54().slice(0, 8)).replace(/[^a-zA-Z0-9_-]/g, "_");
   const dir = uploadsDir();
-  const outPath = join199(dir, `${prefix}-${safeName}`);
+  const outPath = join201(dir, `${prefix}-${safeName}`);
   try {
     await mkdir45(dir, { recursive: true });
     await writeFile49(outPath, data);
@@ -671169,7 +672123,7 @@ var init_sessionUrl = __esm(() => {
 
 // src/utils/plugins/zipCacheAdapters.ts
 import { readFile as readFile54 } from "fs/promises";
-import { join as join200 } from "path";
+import { join as join202 } from "path";
 async function readZipCacheKnownMarketplaces() {
   try {
     const content = await readFile54(getZipCacheKnownMarketplacesPath(), "utf-8");
@@ -671194,13 +672148,13 @@ async function saveMarketplaceJsonToZipCache(marketplaceName, installLocation) {
   const content = await readMarketplaceJsonContent(installLocation);
   if (content !== null) {
     const relPath = getMarketplaceJsonRelativePath(marketplaceName);
-    await atomicWriteToZipCache(join200(zipCachePath, relPath), content);
+    await atomicWriteToZipCache(join202(zipCachePath, relPath), content);
   }
 }
 async function readMarketplaceJsonContent(dir) {
   const candidates2 = [
-    join200(dir, ".ur-plugin", "marketplace.json"),
-    join200(dir, "marketplace.json"),
+    join202(dir, ".ur-plugin", "marketplace.json"),
+    join202(dir, "marketplace.json"),
     dir
   ];
   for (const candidate of candidates2) {
@@ -671330,8 +672284,8 @@ async function getEnvLessBridgeConfig() {
 }
 async function checkEnvLessBridgeMinVersion() {
   const cfg = await getEnvLessBridgeConfig();
-  if (cfg.min_version && lt("1.22.0", cfg.min_version)) {
-    return `Your version of UR (${"1.22.0"}) is too old for Remote Control.
+  if (cfg.min_version && lt("1.22.1", cfg.min_version)) {
+    return `Your version of UR (${"1.22.1"}) is too old for Remote Control.
 Version ${cfg.min_version} or higher is required. Run \`ur update\` to update.`;
   }
   return null;
@@ -671659,9 +672613,9 @@ __export(exports_bridgePointer, {
   BRIDGE_POINTER_TTL_MS: () => BRIDGE_POINTER_TTL_MS
 });
 import { mkdir as mkdir46, readFile as readFile55, stat as stat50, unlink as unlink26, writeFile as writeFile50 } from "fs/promises";
-import { dirname as dirname72, join as join201 } from "path";
+import { dirname as dirname72, join as join203 } from "path";
 function getBridgePointerPath(dir) {
-  return join201(getProjectsDir(), sanitizePath2(dir), "bridge-pointer.json");
+  return join203(getProjectsDir(), sanitizePath2(dir), "bridge-pointer.json");
 }
 async function writeBridgePointer(dir, pointer) {
   const path24 = getBridgePointerPath(dir);
@@ -671805,7 +672759,7 @@ async function initBridgeCore(params) {
   const rawApi = createBridgeApiClient({
     baseUrl,
     getAccessToken,
-    runnerVersion: "1.22.0",
+    runnerVersion: "1.22.1",
     onDebug: logForDebugging,
     onAuth401,
     getTrustedDeviceToken
@@ -677486,7 +678440,7 @@ async function startMCPServer(cwd3, debug2, verbose) {
   setCwd(cwd3);
   const server2 = new Server({
     name: "ur/tengu",
-    version: "1.22.0"
+    version: "1.22.1"
   }, {
     capabilities: {
       tools: {}
@@ -677618,14 +678572,14 @@ __export(exports_urDesktop, {
 });
 import { readdir as readdir32, readFile as readFile57, stat as stat52 } from "fs/promises";
 import { homedir as homedir39 } from "os";
-import { join as join202 } from "path";
+import { join as join204 } from "path";
 async function getURDesktopConfigPath() {
   const platform7 = getPlatform();
   if (!SUPPORTED_PLATFORMS.includes(platform7)) {
     throw new Error(`Unsupported platform: ${platform7} - UR Desktop integration only works on macOS and WSL.`);
   }
   if (platform7 === "macos") {
-    return join202(homedir39(), "Library", "Application Support", "UR", "ur_desktop_config.json");
+    return join204(homedir39(), "Library", "Application Support", "UR", "ur_desktop_config.json");
   }
   const windowsHome = process.env.USERPROFILE ? process.env.USERPROFILE.replace(/\\/g, "/") : null;
   if (windowsHome) {
@@ -677644,7 +678598,7 @@ async function getURDesktopConfigPath() {
         if (user.name === "Public" || user.name === "Default" || user.name === "Default User" || user.name === "All Users") {
           continue;
         }
-        const potentialConfigPath = join202(usersDir, user.name, "AppData", "Roaming", "UR", "ur_desktop_config.json");
+        const potentialConfigPath = join204(usersDir, user.name, "AppData", "Roaming", "UR", "ur_desktop_config.json");
         try {
           await stat52(potentialConfigPath);
           return potentialConfigPath;
@@ -678553,12 +679507,12 @@ __export(exports_install, {
   install: () => install
 });
 import { homedir as homedir40 } from "os";
-import { join as join203 } from "path";
+import { join as join205 } from "path";
 function getInstallationPath2() {
   const isWindows2 = env2.platform === "win32";
   const homeDir = homedir40();
   if (isWindows2) {
-    const windowsPath = join203(homeDir, ".local", "bin", "ur.exe");
+    const windowsPath = join205(homeDir, ".local", "bin", "ur.exe");
     return windowsPath.replace(/\//g, "\\");
   }
   return "~/.local/bin/ur";
@@ -679097,7 +680051,7 @@ __export(exports_update, {
 });
 async function update() {
   logEvent("tengu_update_check", {});
-  writeToStdout(`Current version: ${"1.22.0"}
+  writeToStdout(`Current version: ${"1.22.1"}
 `);
   const channel = getInitialSettings()?.autoUpdatesChannel ?? "latest";
   writeToStdout(`Checking for updates to ${channel} version...
@@ -679172,8 +680126,8 @@ async function update() {
       writeToStdout(`UR is managed by Homebrew.
 `);
       const latest = await getLatestVersion(channel);
-      if (latest && !gte("1.22.0", latest)) {
-        writeToStdout(`${formatUpdateAvailableMessage("1.22.0", latest)}
+      if (latest && !gte("1.22.1", latest)) {
+        writeToStdout(`${formatUpdateAvailableMessage("1.22.1", latest)}
 `);
         writeToStdout(`
 `);
@@ -679189,8 +680143,8 @@ async function update() {
       writeToStdout(`UR is managed by winget.
 `);
       const latest = await getLatestVersion(channel);
-      if (latest && !gte("1.22.0", latest)) {
-        writeToStdout(`${formatUpdateAvailableMessage("1.22.0", latest)}
+      if (latest && !gte("1.22.1", latest)) {
+        writeToStdout(`${formatUpdateAvailableMessage("1.22.1", latest)}
 `);
         writeToStdout(`
 `);
@@ -679206,8 +680160,8 @@ async function update() {
       writeToStdout(`UR is managed by apk.
 `);
       const latest = await getLatestVersion(channel);
-      if (latest && !gte("1.22.0", latest)) {
-        writeToStdout(`${formatUpdateAvailableMessage("1.22.0", latest)}
+      if (latest && !gte("1.22.1", latest)) {
+        writeToStdout(`${formatUpdateAvailableMessage("1.22.1", latest)}
 `);
         writeToStdout(`
 `);
@@ -679272,11 +680226,11 @@ async function update() {
 `);
         await gracefulShutdown(1);
       }
-      if (result.latestVersion === "1.22.0") {
-        writeToStdout(source_default.green(`UR is up to date (${"1.22.0"})`) + `
+      if (result.latestVersion === "1.22.1") {
+        writeToStdout(source_default.green(`UR is up to date (${"1.22.1"})`) + `
 `);
       } else {
-        writeToStdout(source_default.green(`Successfully updated from ${"1.22.0"} to version ${result.latestVersion}`) + `
+        writeToStdout(source_default.green(`Successfully updated from ${"1.22.1"} to version ${result.latestVersion}`) + `
 `);
         await regenerateCompletionCache();
       }
@@ -679336,12 +680290,12 @@ async function update() {
 `);
     await gracefulShutdown(1);
   }
-  if (latestVersion === "1.22.0") {
-    writeToStdout(source_default.green(`UR is up to date (${"1.22.0"})`) + `
+  if (latestVersion === "1.22.1") {
+    writeToStdout(source_default.green(`UR is up to date (${"1.22.1"})`) + `
 `);
     await gracefulShutdown(0);
   }
-  writeToStdout(`${formatUpdateAvailableMessage("1.22.0", latestVersion)}
+  writeToStdout(`${formatUpdateAvailableMessage("1.22.1", latestVersion)}
 `);
   writeToStdout(`Installing update...
 `);
@@ -679386,7 +680340,7 @@ async function update() {
   logForDebugging(`update: Installation status: ${status2}`);
   switch (status2) {
     case "success":
-      writeToStdout(source_default.green(`Successfully updated from ${"1.22.0"} to version ${latestVersion}`) + `
+      writeToStdout(source_default.green(`Successfully updated from ${"1.22.1"} to version ${latestVersion}`) + `
 `);
       await regenerateCompletionCache();
       break;
@@ -679452,7 +680406,7 @@ __export(exports_main, {
   startDeferredPrefetches: () => startDeferredPrefetches,
   main: () => main
 });
-import { readFileSync as readFileSync53 } from "fs";
+import { readFileSync as readFileSync55 } from "fs";
 import { resolve as resolve50 } from "path";
 function logManagedSettings() {
   try {
@@ -679608,7 +680562,7 @@ function loadSettingsFromFlag(settingsFile) {
         resolvedPath: resolvedSettingsPath
       } = safeResolvePath(getFsImplementation(), settingsFile);
       try {
-        readFileSync53(resolvedSettingsPath, "utf8");
+        readFileSync55(resolvedSettingsPath, "utf8");
       } catch (e) {
         if (isENOENT(e)) {
           process.stderr.write(source_default.red(`Error: Settings file not found: ${resolvedSettingsPath}
@@ -680013,7 +680967,7 @@ ${getTmuxInstallInstructions2()}
       }
       try {
         const filePath = resolve50(options2.systemPromptFile);
-        systemPrompt = readFileSync53(filePath, "utf8");
+        systemPrompt = readFileSync55(filePath, "utf8");
       } catch (error40) {
         const code = getErrnoCode(error40);
         if (code === "ENOENT") {
@@ -680035,7 +680989,7 @@ ${getTmuxInstallInstructions2()}
       }
       try {
         const filePath = resolve50(options2.appendSystemPromptFile);
-        appendSystemPrompt = readFileSync53(filePath, "utf8");
+        appendSystemPrompt = readFileSync55(filePath, "utf8");
       } catch (error40) {
         const code = getErrnoCode(error40);
         if (code === "ENOENT") {
@@ -680662,7 +681616,7 @@ ${customInstructions}` : customInstructions;
       }
     }
     logForDiagnosticsNoPII("info", "started", {
-      version: "1.22.0",
+      version: "1.22.1",
       is_native_binary: isInBundledMode()
     });
     registerCleanup(async () => {
@@ -681446,7 +682400,7 @@ Usage: ur --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version("1.22.0 (Ur)", "-v, --version", "Output the version number");
+  }).version("1.22.1 (Ur)", "-v, --version", "Output the version number");
   program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
   program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
   if (canUserConfigureAdvisor()) {
@@ -681750,7 +682704,7 @@ Usage: ur --remote "your task description"`, () => gracefulShutdown(1));
   });
   program2.command("spec [action] [name] [phase]").alias("specs").description("Spec-driven development: scaffold requirements/design/tasks in .ur/specs and drive execution task-by-task").option("--goal <text>", "Goal text for init").option("--all", "Run all open tasks, not just the next one").option("--dry-run", "Run offline without calling any model").option("--max-turns <n>", "Max agentic turns per task when running").option("--skip-permissions", "Pass --dangerously-skip-permissions to each task (sandboxes only)").option("--json", "Output as JSON").action(async (action3, name, phase, opts) => {
     const args = [action3, name, phase, opts.goal ? `--goal ${quoteLocalCommandArg(opts.goal)}` : undefined, opts.all ? "--all" : undefined, opts.dryRun ? "--dry-run" : undefined, opts.maxTurns ? `--max-turns ${opts.maxTurns}` : undefined, opts.skipPermissions ? "--skip-permissions" : undefined, opts.json ? "--json" : undefined].filter(Boolean).join(" ");
-    await runLocalTextCommand(() => Promise.resolve().then(() => (init_spec2(), exports_spec)), args);
+    await runLocalTextCommand(() => Promise.resolve().then(() => (init_spec2(), exports_spec2)), args);
   });
   program2.command("escalate [action] [task...]").description("Capability-aware local model escalation: run on a fast model and auto-escalate hard work to the oracle").option("--dry-run", "Run offline without calling any model").option("--force-oracle", "Start on the oracle regardless of difficulty").option("--fast <model>", "Pin the fast-tier model (policy)").option("--oracle <model>", "Pin the oracle-tier model (policy)").option("--auto <onoff>", "Enable/disable auto-escalation (policy): on|off").option("--max-turns <n>", "Max agentic turns when running").option("--skip-permissions", "Pass --dangerously-skip-permissions (sandboxes only)").option("--json", "Output as JSON").action(async (action3, task = [], opts) => {
     const args = [action3, ...task, opts.dryRun ? "--dry-run" : undefined, opts.forceOracle ? "--force-oracle" : undefined, opts.fast ? `--fast ${quoteLocalCommandArg(opts.fast)}` : undefined, opts.oracle ? `--oracle ${quoteLocalCommandArg(opts.oracle)}` : undefined, opts.auto ? `--auto ${quoteLocalCommandArg(opts.auto)}` : undefined, opts.maxTurns ? `--max-turns ${opts.maxTurns}` : undefined, opts.skipPermissions ? "--skip-permissions" : undefined, opts.json ? "--json" : undefined].filter(Boolean).join(" ");
@@ -682243,7 +683197,7 @@ if (false) {}
 async function main2() {
   const args = process.argv.slice(2);
   if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
-    console.log(`${"1.22.0"} (Ur)`);
+    console.log(`${"1.22.1"} (Ur)`);
     return;
   }
   if (args[0] === "a2a" && args[1] === "serve" && !args.includes("--help") && !args.includes("-h")) {