ur-agent 1.40.1 → 1.41.0

package/dist/cli.js

@@ -71146,7 +71146,7 @@ var init_auth = __esm(() => {
 
 // src/utils/userAgent.ts
 function getURCodeUserAgent() {
-  return `ur/${"1.40.1"}`;
+  return `ur/${"1.41.0"}`;
 }
 
 // src/utils/workloadContext.ts
@@ -71168,7 +71168,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.40.1"} (${process.env.USER_TYPE}, ${process.env.UR_CODE_ENTRYPOINT ?? "cli"}${agentSdkVersion}${clientApp}${workloadSuffix})`;
+  return `ur-cli/${"1.41.0"} (${process.env.USER_TYPE}, ${process.env.UR_CODE_ENTRYPOINT ?? "cli"}${agentSdkVersion}${clientApp}${workloadSuffix})`;
 }
 function getMCPUserAgent() {
   const parts = [];
@@ -71182,7 +71182,7 @@ function getMCPUserAgent() {
     parts.push(`client-app/${process.env.UR_AGENT_SDK_CLIENT_APP}`);
   }
   const suffix = parts.length > 0 ? ` (${parts.join(", ")})` : "";
-  return `ur/${"1.40.1"}${suffix}`;
+  return `ur/${"1.41.0"}${suffix}`;
 }
 function getWebFetchUserAgent() {
   return `UR-User (${getURCodeUserAgent()})`;
@@ -71320,7 +71320,7 @@ var init_user = __esm(() => {
       deviceId,
       sessionId: getSessionId(),
       email: getEmail(),
-      appVersion: "1.40.1",
+      appVersion: "1.41.0",
       platform: getHostPlatformForAnalytics(),
       organizationUuid,
       accountUuid,
@@ -77837,7 +77837,7 @@ var init_metadata = __esm(() => {
   COMPOUND_OPERATOR_REGEX = /\s*(?:&&|\|\||[;|])\s*/;
   WHITESPACE_REGEX = /\s+/;
   getVersionBase = memoize_default(() => {
-    const match = "1.40.1".match(/^\d+\.\d+\.\d+(?:-[a-z]+)?/);
+    const match = "1.41.0".match(/^\d+\.\d+\.\d+(?:-[a-z]+)?/);
     return match ? match[0] : undefined;
   });
   buildEnvContext = memoize_default(async () => {
@@ -77877,7 +77877,7 @@ var init_metadata = __esm(() => {
       isGithubAction: isEnvTruthy(process.env.GITHUB_ACTIONS),
       isURCodeAction: isEnvTruthy(process.env.UR_CODE_ACTION),
       isURAiAuth: isURAISubscriber(),
-      version: "1.40.1",
+      version: "1.41.0",
       versionBase: getVersionBase(),
       buildTime: "",
       deploymentEnvironment: env2.detectDeploymentEnvironment(),
@@ -78547,7 +78547,7 @@ function initialize1PEventLogging() {
   const platform2 = getPlatform();
   const attributes = {
     [import_semantic_conventions4.ATTR_SERVICE_NAME]: "ur",
-    [import_semantic_conventions4.ATTR_SERVICE_VERSION]: "1.40.1"
+    [import_semantic_conventions4.ATTR_SERVICE_VERSION]: "1.41.0"
   };
   if (platform2 === "wsl") {
     const wslVersion = getWslVersion();
@@ -78574,7 +78574,7 @@ function initialize1PEventLogging() {
       })
     ]
   });
-  firstPartyEventLogger = firstPartyEventLoggerProvider.getLogger("com.urhq.ur.events", "1.40.1");
+  firstPartyEventLogger = firstPartyEventLoggerProvider.getLogger("com.urhq.ur.events", "1.41.0");
 }
 async function reinitialize1PEventLoggingIfConfigChanged() {
   if (!is1PEventLoggingEnabled() || !firstPartyEventLoggerProvider) {
@@ -83873,7 +83873,7 @@ function formatAgentTrendReport(report = buildAgentTrendReport()) {
 function formatA2AAgentCard(options = {}, pretty = true) {
   return JSON.stringify(buildA2AAgentCard(options), null, pretty ? 2 : 0);
 }
-var urVersion = "1.40.1", coverage, priorityRoadmap;
+var urVersion = "1.41.0", coverage, priorityRoadmap;
 var init_trends = __esm(() => {
   coverage = [
     {
@@ -85868,7 +85868,7 @@ function getAttributionHeader(fingerprint) {
   if (!isAttributionHeaderEnabled()) {
     return "";
   }
-  const version2 = `${"1.40.1"}.${fingerprint}`;
+  const version2 = `${"1.41.0"}.${fingerprint}`;
   const entrypoint = process.env.UR_CODE_ENTRYPOINT ?? "unknown";
   const cch = "";
   const workload = getWorkload();
@@ -127181,10 +127181,10 @@ async function detectWorktreeMainRepoPath(cwd2) {
 function getSandboxEnabledSetting() {
   try {
     const settings = getSettings_DEPRECATED();
-    return settings?.sandbox?.enabled ?? false;
+    return settings?.sandbox?.enabled ?? true;
   } catch (error40) {
     logForDebugging(`Failed to get settings for sandbox check: ${error40}`);
-    return false;
+    return true;
   }
 }
 function isAutoAllowBashIfSandboxedEnabled() {
@@ -193771,7 +193771,7 @@ function getTelemetryAttributes() {
     attributes["session.id"] = sessionId;
   }
   if (shouldIncludeAttribute("OTEL_METRICS_INCLUDE_VERSION")) {
-    attributes["app.version"] = "1.40.1";
+    attributes["app.version"] = "1.41.0";
   }
   const oauthAccount = getOauthAccountInfo();
   if (oauthAccount) {
@@ -229157,7 +229157,7 @@ function getInstallationEnv() {
   return;
 }
 function getURCodeVersion() {
-  return "1.40.1";
+  return "1.41.0";
 }
 async function getInstalledVSCodeExtensionVersion(command) {
   const { stdout } = await execFileNoThrow(command, ["--list-extensions", "--show-versions"], {
@@ -231996,7 +231996,7 @@ async function setupSdkMcpClients(sdkMcpConfigs, sendMcpMessage) {
     const client2 = new Client({
       name: "ur",
       title: "UR",
-      version: "1.40.1",
+      version: "1.41.0",
       description: "UR-Nexus autonomous engineering workflow engine",
       websiteUrl: PRODUCT_URL
     }, {
@@ -232350,7 +232350,7 @@ var init_client5 = __esm(() => {
       const client2 = new Client({
         name: "ur",
         title: "UR",
-        version: "1.40.1",
+        version: "1.41.0",
         description: "UR-Nexus autonomous engineering workflow engine",
         websiteUrl: PRODUCT_URL
       }, {
@@ -242164,9 +242164,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.40.1", versionConfig.minVersion)) {
+    if (versionConfig.minVersion && lt("1.41.0", versionConfig.minVersion)) {
       console.error(`
-It looks like your version of UR (${"1.40.1"}) needs an update.
+It looks like your version of UR (${"1.41.0"}) needs an update.
 A newer version (${versionConfig.minVersion} or higher) is required to continue.
 
 To update, please run:
@@ -242382,7 +242382,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.40.1"
+      currentVersion: "1.41.0"
     });
     return "in_progress";
   }
@@ -242391,7 +242391,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.40.1"
+        currentVersion: "1.41.0"
       });
       console.error(`
 Error: Windows NPM detected in WSL
@@ -242926,7 +242926,7 @@ function detectLinuxGlobPatternWarnings() {
 }
 async function getDoctorDiagnostic() {
   const installationType = await getCurrentInstallationType();
-  const version2 = typeof MACRO !== "undefined" ? "1.40.1" : "unknown";
+  const version2 = typeof MACRO !== "undefined" ? "1.41.0" : "unknown";
   const installationPath = await getInstallationPath();
   const invokedBinary = getInvokedBinary();
   const multipleInstallations = await detectMultipleInstallations();
@@ -243861,8 +243861,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.40.1", maxVersion)) {
-        logForDebugging(`Native installer: current version ${"1.40.1"} is already at or above maxVersion ${maxVersion}, skipping update`);
+      if (gte("1.41.0", maxVersion)) {
+        logForDebugging(`Native installer: current version ${"1.41.0"} is already at or above maxVersion ${maxVersion}, skipping update`);
         logEvent("tengu_native_update_skipped_max_version", {
           latency_ms: Date.now() - startTime,
           max_version: maxVersion,
@@ -243873,7 +243873,7 @@ async function updateLatest(channelOrVersion, forceReinstall = false) {
       version2 = maxVersion;
     }
   }
-  if (!forceReinstall && version2 === "1.40.1" && await versionIsAvailable(version2) && await isPossibleURBinary(executablePath)) {
+  if (!forceReinstall && version2 === "1.41.0" && await versionIsAvailable(version2) && await isPossibleURBinary(executablePath)) {
     logForDebugging(`Found ${version2} at ${executablePath}, skipping install`);
     logEvent("tengu_native_update_complete", {
       latency_ms: Date.now() - startTime,
@@ -340826,7 +340826,7 @@ function Feedback({
       platform: env2.platform,
       gitRepo: envInfo.isGit,
       terminal: env2.terminal,
-      version: "1.40.1",
+      version: "1.41.0",
       transcript: normalizeMessagesForAPI(messages),
       errors: sanitizedErrors,
       lastApiRequest: getLastAPIRequest(),
@@ -341018,7 +341018,7 @@ function Feedback({
                       ", ",
                       env2.terminal,
                       ", v",
-                      "1.40.1"
+                      "1.41.0"
                     ]
                   }, undefined, true, undefined, this)
                 ]
@@ -341124,7 +341124,7 @@ ${sanitizedDescription}
 ` + `**Environment Info**
 ` + `- Platform: ${env2.platform}
 ` + `- Terminal: ${env2.terminal}
-` + `- Version: ${"1.40.1"}
+` + `- Version: ${"1.41.0"}
 ` + `- Feedback ID: ${feedbackId}
 ` + `
 **Errors**
@@ -344235,7 +344235,7 @@ function buildPrimarySection() {
   }, undefined, false, undefined, this);
   return [{
     label: "Version",
-    value: "1.40.1"
+    value: "1.41.0"
   }, {
     label: "Session name",
     value: nameValue
@@ -347536,7 +347536,7 @@ function Config({
         }
       }, undefined, false, undefined, this)
     }, undefined, false, undefined, this) : showSubmenu === "ChannelDowngrade" ? /* @__PURE__ */ jsx_dev_runtime177.jsxDEV(ChannelDowngradeDialog, {
-      currentVersion: "1.40.1",
+      currentVersion: "1.41.0",
       onChoice: (choice) => {
         setShowSubmenu(null);
         setTabsHidden(false);
@@ -347548,7 +347548,7 @@ function Config({
           autoUpdatesChannel: "stable"
         };
         if (choice === "stay") {
-          newSettings.minimumVersion = "1.40.1";
+          newSettings.minimumVersion = "1.41.0";
         }
         updateSettingsForSource("userSettings", newSettings);
         setSettingsData((prev_27) => ({
@@ -355618,7 +355618,7 @@ function HelpV2(t0) {
   let t6;
   if ($3[31] !== tabs) {
     t6 = /* @__PURE__ */ jsx_dev_runtime204.jsxDEV(Tabs, {
-      title: `UR v${"1.40.1"}`,
+      title: `UR v${"1.41.0"}`,
       color: "professionalBlue",
       defaultTab: "general",
       children: tabs
@@ -356364,7 +356364,7 @@ function buildToolUseContext(tools, readFileStateCache) {
 async function handleInitialize(options2) {
   return {
     name: "UR",
-    version: "1.40.1",
+    version: "1.41.0",
     protocolVersion: "0.1.0",
     workspaceRoot: options2.cwd,
     capabilities: {
@@ -376506,7 +376506,7 @@ function getAllReleaseNotes(changelogContent = getStoredChangelogFromMemory()) {
     return [];
   }
 }
-async function checkForReleaseNotes(lastSeenVersion, currentVersion = "1.40.1") {
+async function checkForReleaseNotes(lastSeenVersion, currentVersion = "1.41.0") {
   if (process.env.USER_TYPE === "ant") {
     const changelog = "";
     if (changelog) {
@@ -376533,7 +376533,7 @@ async function checkForReleaseNotes(lastSeenVersion, currentVersion = "1.40.1")
     releaseNotes
   };
 }
-function checkForReleaseNotesSync(lastSeenVersion, currentVersion = "1.40.1") {
+function checkForReleaseNotesSync(lastSeenVersion, currentVersion = "1.41.0") {
   if (process.env.USER_TYPE === "ant") {
     const changelog = "";
     if (changelog) {
@@ -377712,7 +377712,7 @@ function getRecentActivitySync() {
   return cachedActivity;
 }
 function getLogoDisplayData() {
-  const version2 = process.env.DEMO_VERSION ?? "1.40.1";
+  const version2 = process.env.DEMO_VERSION ?? "1.41.0";
   const serverUrl = getDirectConnectServerUrl();
   const displayPath = process.env.DEMO_VERSION ? "/code/ur" : getDisplayPath(getCwd());
   const cwd2 = serverUrl ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, "")}` : displayPath;
@@ -378501,7 +378501,7 @@ function LogoV2() {
   if ($3[2] === Symbol.for("react.memo_cache_sentinel")) {
     t2 = () => {
       const currentConfig2 = getGlobalConfig();
-      if (currentConfig2.lastReleaseNotesSeen === "1.40.1") {
+      if (currentConfig2.lastReleaseNotesSeen === "1.41.0") {
         return;
       }
       saveGlobalConfig(_temp326);
@@ -379186,12 +379186,12 @@ function LogoV2() {
   return t41;
 }
 function _temp326(current) {
-  if (current.lastReleaseNotesSeen === "1.40.1") {
+  if (current.lastReleaseNotesSeen === "1.41.0") {
     return current;
   }
   return {
     ...current,
-    lastReleaseNotesSeen: "1.40.1"
+    lastReleaseNotesSeen: "1.41.0"
   };
 }
 function _temp243(s_0) {
@@ -397255,23 +397255,53 @@ var init_evidence3 = __esm(() => {
 function pad(value, width) {
   return value.padEnd(width, " ");
 }
+function publicStatus(task) {
+  if (task.status === "pending" || task.status === "ready")
+    return "queued";
+  if (task.status === "blocked" || task.status === "needs-context") {
+    return "needs context";
+  }
+  if (task.status === "needs-scope")
+    return "needs scope";
+  if (task.status === "waiting-approval")
+    return "waiting approval";
+  if (task.status === "paused-review")
+    return "paused for review";
+  if (task.status === "skipped")
+    return "skipped by policy";
+  return task.status;
+}
+function isWaiting(task) {
+  return [
+    "blocked",
+    "waiting-approval",
+    "needs-scope",
+    "needs-context",
+    "paused-review"
+  ].includes(task.status);
+}
 function progressSummary(tasks2) {
   const finished7 = tasks2.filter((task) => task.status === "finished").length;
   const running = tasks2.filter((task) => task.status === "running").length;
-  const blocked = tasks2.filter((task) => task.status === "blocked").length;
+  const queued = tasks2.filter((task) => task.status === "pending" || task.status === "ready").length;
+  const waiting = tasks2.filter(isWaiting).length;
   const failed = tasks2.filter((task) => task.status === "failed").length;
-  return `Progress: ${finished7}/${tasks2.length} finished, ${running} running, ${blocked} blocked, ${failed} failed`;
+  const skipped = tasks2.filter((task) => task.status === "skipped").length;
+  return `Progress: ${finished7}/${tasks2.length} finished, ${running} running, ${queued} queued, ${waiting} waiting, ${failed} failed, ${skipped} skipped`;
 }
-function renderTaskBoard(planOrTasks) {
+function renderTaskBoard(planOrTasks, options2 = {}) {
   const tasks2 = Array.isArray(planOrTasks) ? planOrTasks : planOrTasks.tasks;
-  const rows = tasks2.map((task, index2) => {
-    const status2 = pad(task.status, 8);
+  const activeAgents = options2.activeAgents ?? tasks2.filter((task) => task.status === "running").length;
+  const maxAgents2 = options2.maxAgents ?? (Array.isArray(planOrTasks) ? activeAgents || 1 : planOrTasks.config.maxAgents);
+  const orderedTasks = [...tasks2].sort((a2, b) => a2.order - b.order);
+  const rows = orderedTasks.map((task) => {
+    const status2 = pad(publicStatus(task), 18);
     const agent = pad(String(task.assignedAgent), 8);
-    return `${index2 + 1}. ${status2} | ${agent} | ${task.title}`;
+    return `${task.order}. ${status2} | ${agent} | ${task.title}`;
   });
   return [
     "[UR-Nexus Task Board]",
-    "",
+    `Agents: ${activeAgents} active / ${maxAgents2} max`,
     ...rows,
     "",
     progressSummary(tasks2)
@@ -397313,8 +397343,20 @@ function extractClaims(output) {
 function validateBeforeExecution(task, context4) {
   const issues = [];
   const knownFiles = normalizeSet(context4.existingFiles);
-  if (task.status === "blocked") {
-    issues.push(issue2("task_blocked", `${task.id} is blocked before execution.`));
+  if (task.approvalRequired) {
+    issues.push(issue2("approval_required", `${task.id} cannot continue safely without approval: ${task.approvalReason ?? "explicit approval is required"}`));
+  }
+  if (task.status === "blocked" || task.status === "needs-context") {
+    issues.push(issue2("needs_context", `${task.id} needs context before execution.`));
+  }
+  if (task.status === "needs-scope") {
+    issues.push(issue2("needs_scope", `${task.id} needs target scope and authorization confirmation before execution.`));
+  }
+  if (task.status === "paused-review") {
+    issues.push(issue2("paused_for_review", `${task.id} is paused for review.`));
+  }
+  if (task.status === "skipped") {
+    issues.push(issue2("skipped_by_policy", `${task.id} was skipped by policy.`));
   }
   if (task.input.assumptions.length === 0) {
     issues.push(issue2("missing_assumptions", `${task.id} has no explicit assumptions.`));
@@ -397402,7 +397444,10 @@ function cloneTasks(tasks2) {
       targetFiles: [...task.input.targetFiles],
       resources: [...task.input.resources]
     },
-    verificationCriteria: [...task.verificationCriteria]
+    verificationCriteria: [...task.verificationCriteria],
+    fileTargets: [...task.fileTargets],
+    approvalPaths: [...task.approvalPaths],
+    outsideWorkspacePaths: [...task.outsideWorkspacePaths]
   }));
 }
 function lockKeys(task) {
@@ -397414,7 +397459,15 @@ function dependenciesFinished(task, tasksById) {
 function dependenciesFailed(task, tasksById) {
   return task.dependencies.some((id) => {
     const status2 = tasksById.get(id)?.status;
-    return status2 === "failed" || status2 === "blocked";
+    return [
+      "failed",
+      "blocked",
+      "waiting-approval",
+      "needs-scope",
+      "needs-context",
+      "paused-review",
+      "skipped"
+    ].includes(status2 ?? "");
   });
 }
 function isLocked(task, activeLocks) {
@@ -397428,33 +397481,74 @@ function releaseLocks(task, activeLocks) {
   for (const key of lockKeys(task))
     activeLocks.delete(key);
 }
-function summary(tasks2, records) {
+function summary(tasks2, records, maxAgentsAllowed, maxAgentsUsed) {
+  const taskResults = tasks2.map((task) => {
+    const record3 = records.get(task.id);
+    if (record3)
+      return record3;
+    return {
+      taskId: task.id,
+      task,
+      actualChangedFiles: [],
+      reportedChangedFiles: [],
+      unreportedChangedFiles: [],
+      observedCommands: [],
+      reportedCommands: [],
+      unverifiedCommandClaims: [],
+      outsideWorkspaceReads: [],
+      outsideWorkspaceWrites: [],
+      approvalDecisions: approvalDecisionFor(task) ? [approvalDecisionFor(task)] : [],
+      preVerification: { ok: true, blocked: false, issues: [] }
+    };
+  });
   return {
     tasks: tasks2,
     finished: tasks2.filter((task) => task.status === "finished").length,
     failed: tasks2.filter((task) => task.status === "failed").length,
     blocked: tasks2.filter((task) => task.status === "blocked").length,
-    taskResults: tasks2.map((task) => {
-      const record3 = records.get(task.id);
-      if (record3)
-        return record3;
-      return {
-        taskId: task.id,
-        task,
-        actualChangedFiles: [],
-        reportedChangedFiles: [],
-        unreportedChangedFiles: [],
-        observedCommands: [],
-        reportedCommands: [],
-        unverifiedCommandClaims: [],
-        preVerification: { ok: true, blocked: false, issues: [] }
-      };
-    })
+    waitingApproval: tasks2.filter((task) => [
+      "waiting-approval",
+      "needs-scope",
+      "needs-context",
+      "paused-review"
+    ].includes(task.status)).length,
+    skipped: tasks2.filter((task) => task.status === "skipped").length,
+    maxAgentsAllowed,
+    maxAgentsUsed,
+    approvalDecisions: uniqueApprovalDecisions(taskResults.flatMap((record3) => record3.approvalDecisions)),
+    outsideWorkspaceReads: unique2(taskResults.flatMap((record3) => record3.outsideWorkspaceReads)),
+    outsideWorkspaceWrites: unique2(taskResults.flatMap((record3) => record3.outsideWorkspaceWrites)),
+    taskResults
   };
 }
 function unique2(values2) {
   return [...new Set([...values2].map((value) => value.trim()).filter(Boolean))];
 }
+function uniqueApprovalDecisions(values2) {
+  const seen = new Set;
+  const decisions = [];
+  for (const value of values2) {
+    const key = `${value.taskId}:${value.status}:${value.action}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    decisions.push(value);
+  }
+  return decisions;
+}
+function approvalDecisionFor(task) {
+  if (!task.approvalRequired)
+    return null;
+  return {
+    taskId: task.id,
+    taskTitle: task.title,
+    status: task.status === "skipped" ? "skipped-by-policy" : "waiting-approval",
+    reason: task.approvalReason ?? "Explicit approval is required before this action can run.",
+    action: task.approvalAction ?? task.description,
+    command: task.approvalCommand,
+    paths: task.approvalPaths
+  };
+}
 function reportedChangedFiles(result) {
   return unique2([
     ...result?.reportedChangedFiles ?? [],
@@ -397473,20 +397567,70 @@ function reportedCommands(result) {
 function issueValues(issues, code) {
   return unique2(issues.filter((issue3) => issue3.code === code && issue3.value).map((issue3) => issue3.value));
 }
-function emitStatus(options2, task, tasks2, lastStatuses) {
-  if (lastStatuses.get(task.id) === task.status)
-    return;
-  lastStatuses.set(task.id, task.status);
-  options2.onEvent?.({ type: "status", task, tasks: tasks2 });
+function emitBoard(options2, tasks2, maxAgents2) {
   const config3 = {
     ...DEFAULT_PROMPT_PLANNING_CONFIG,
     ...resolvePromptPlanningConfig(options2.config)
   };
   if (config3.showTaskBoard) {
-    options2.onEvent?.({ type: "board", board: renderTaskBoard(tasks2), tasks: tasks2 });
+    options2.onEvent?.({
+      type: "board",
+      board: renderTaskBoard(tasks2, { maxAgents: maxAgents2 }),
+      tasks: tasks2
+    });
   }
 }
-async function runOneTask(task, tasks2, options2, records, lastStatuses) {
+function emitStatus(options2, task, tasks2, lastStatuses, maxAgents2) {
+  if (lastStatuses.get(task.id) === task.status)
+    return;
+  lastStatuses.set(task.id, task.status);
+  options2.onEvent?.({ type: "status", task, tasks: tasks2 });
+  emitBoard(options2, tasks2, maxAgents2);
+}
+function waitingStatusFor(task) {
+  if (task.status === "needs-scope")
+    return "needs-scope";
+  if (task.status === "needs-context")
+    return "needs-context";
+  if (task.status === "paused-review")
+    return "paused-review";
+  if (task.status === "skipped")
+    return "skipped";
+  if (task.approvalRequired)
+    return "waiting-approval";
+  return "needs-context";
+}
+function runnablePlanningTasks(tasks2) {
+  return tasks2.filter((task) => ["pending", "ready"].includes(task.status));
+}
+function independentWidth(tasks2) {
+  const selectedLocks = new Set;
+  let width = 0;
+  for (const task of runnablePlanningTasks(tasks2)) {
+    if (task.dependencies.length > 0)
+      continue;
+    const keys2 = lockKeys(task);
+    if (keys2.length > 0 && keys2.some((key) => selectedLocks.has(key)))
+      continue;
+    for (const key of keys2)
+      selectedLocks.add(key);
+    width += 1;
+  }
+  return width;
+}
+function usefulAgentCount(tasks2, config3) {
+  if (!config3.parallelAgents)
+    return 1;
+  const runnable = runnablePlanningTasks(tasks2);
+  if (runnable.length <= 1)
+    return 1;
+  const width = Math.max(1, independentWidth(tasks2));
+  if (runnable.length <= 4) {
+    return Math.max(1, Math.min(config3.maxAgents, 3, width));
+  }
+  return Math.max(1, Math.min(config3.maxAgents, width));
+}
+async function runOneTask(task, tasks2, options2, records, lastStatuses, maxAgents2) {
   const config3 = {
     ...DEFAULT_PROMPT_PLANNING_CONFIG,
     ...resolvePromptPlanningConfig(options2.config)
@@ -397505,17 +397649,21 @@ async function runOneTask(task, tasks2, options2, records, lastStatuses) {
     observedCommands: [],
     reportedCommands: [],
     unverifiedCommandClaims: [],
+    outsideWorkspaceReads: [],
+    outsideWorkspaceWrites: [],
+    approvalDecisions: approvalDecisionFor(task) ? [approvalDecisionFor(task)] : [],
     preVerification: before
   };
   records.set(task.id, record3);
   if (!before.ok) {
-    task.status = "blocked";
+    task.status = waitingStatusFor(task);
+    record3.task = task;
     record3.finishedAt = new Date().toISOString();
-    emitStatus(options2, task, tasks2, lastStatuses);
+    emitStatus(options2, task, tasks2, lastStatuses, maxAgents2);
     return;
   }
   task.status = "running";
-  emitStatus(options2, task, tasks2, lastStatuses);
+  emitStatus(options2, task, tasks2, lastStatuses, maxAgents2);
   const workspaceBefore = captureWorkspaceFileState(options2.cwd);
   let result;
   try {
@@ -397534,6 +397682,8 @@ async function runOneTask(task, tasks2, options2, records, lastStatuses) {
   const observed = observedCommands(result);
   const reportedFiles = reportedChangedFiles(result);
   const reportedCommandClaims = reportedCommands(result);
+  const outsideWorkspaceReads = unique2(result.outsideWorkspaceReads ?? []);
+  const outsideWorkspaceWrites = unique2(result.outsideWorkspaceWrites ?? []);
   const after = validateAfterExecution(task, result, {
     cwd: options2.cwd,
     strict: config3.strictVerification,
@@ -397548,10 +397698,16 @@ async function runOneTask(task, tasks2, options2, records, lastStatuses) {
   record3.observedCommands = observed;
   record3.reportedCommands = reportedCommandClaims;
   record3.unverifiedCommandClaims = issueValues(after.issues, "unsupported_command_claim");
+  record3.outsideWorkspaceReads = outsideWorkspaceReads;
+  record3.outsideWorkspaceWrites = outsideWorkspaceWrites;
+  record3.approvalDecisions = uniqueApprovalDecisions([
+    ...record3.approvalDecisions,
+    ...result.approvalDecisions ?? []
+  ]);
   record3.postVerification = after;
   record3.finishedAt = new Date().toISOString();
   task.status = result.ok && after.ok ? "finished" : "failed";
-  emitStatus(options2, task, tasks2, lastStatuses);
+  emitStatus(options2, task, tasks2, lastStatuses, maxAgents2);
 }
 async function runPromptPlan(plan, options2) {
   const config3 = {
@@ -397564,16 +397720,22 @@ async function runPromptPlan(plan, options2) {
   const activeLocks = new Set;
   const running = new Set;
   const lastStatuses = new Map;
-  const maxAgents2 = config3.parallelAgents ? config3.maxAgents : 1;
+  const maxAgentsAllowed = config3.parallelAgents ? config3.maxAgents : 1;
+  const maxAgents2 = usefulAgentCount(tasks2, {
+    parallelAgents: config3.parallelAgents,
+    maxAgents: maxAgentsAllowed
+  });
+  let maxAgentsUsed = 0;
+  emitBoard(options2, tasks2, maxAgentsAllowed);
   while (true) {
     for (const task of tasks2) {
       if (task.status === "pending" && dependenciesFailed(task, tasksById)) {
-        task.status = "blocked";
-        emitStatus(options2, task, tasks2, lastStatuses);
+        task.status = "needs-context";
+        emitStatus(options2, task, tasks2, lastStatuses, maxAgentsAllowed);
       }
       if (task.status === "pending" && dependenciesFinished(task, tasksById)) {
         task.status = "ready";
-        emitStatus(options2, task, tasks2, lastStatuses);
+        emitStatus(options2, task, tasks2, lastStatuses, maxAgentsAllowed);
       }
     }
     const ready = tasks2.filter((task) => task.status === "ready" && running.size < maxAgents2 && !isLocked(task, activeLocks));
@@ -397583,19 +397745,21 @@ async function runPromptPlan(plan, options2) {
       if (isLocked(task, activeLocks))
         continue;
       acquireLocks(task, activeLocks);
-      const promise3 = runOneTask(task, tasks2, options2, records, lastStatuses).finally(() => {
+      const promise3 = runOneTask(task, tasks2, options2, records, lastStatuses, maxAgentsAllowed).finally(() => {
         releaseLocks(task, activeLocks);
         running.delete(promise3);
       });
       running.add(promise3);
+      maxAgentsUsed = Math.max(maxAgentsUsed, running.size);
     }
     if (running.size === 0) {
       const open12 = tasks2.some((task) => ["pending", "ready", "running"].includes(task.status));
-      if (!open12)
-        return summary(tasks2, records);
+      if (!open12) {
+        return summary(tasks2, records, maxAgentsAllowed, maxAgentsUsed);
+      }
       for (const task of tasks2) {
         if (task.status === "pending" || task.status === "ready") {
-          task.status = "blocked";
+          task.status = "needs-context";
           records.set(task.id, {
             taskId: task.id,
             task,
@@ -397606,22 +397770,25 @@ async function runPromptPlan(plan, options2) {
             observedCommands: [],
             reportedCommands: [],
             unverifiedCommandClaims: [],
+            outsideWorkspaceReads: [],
+            outsideWorkspaceWrites: [],
+            approvalDecisions: approvalDecisionFor(task) ? [approvalDecisionFor(task)] : [],
             preVerification: {
               ok: false,
               blocked: true,
               issues: [
                 {
                   code: "unsatisfied_dependencies",
-                  message: `${task.id} could not run because dependencies did not finish.`,
+                  message: `${task.id} cannot continue because dependencies did not finish.`,
                   severity: "error"
                 }
               ]
             }
           });
-          emitStatus(options2, task, tasks2, lastStatuses);
+          emitStatus(options2, task, tasks2, lastStatuses, maxAgentsAllowed);
         }
       }
-      return summary(tasks2, records);
+      return summary(tasks2, records, maxAgentsAllowed, maxAgentsUsed);
     }
     await Promise.race(running);
   }
@@ -397633,6 +397800,7 @@ var init_executor = __esm(() => {
 });
 
 // src/services/promptPlanning/planner.ts
+import { isAbsolute as isAbsolute29 } from "path";
 function compact2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
@@ -397658,6 +397826,12 @@ function extractReferencedFiles(text) {
       continue;
     paths2.push(value.replace(/[),.;:]+$/g, ""));
   }
+  for (const match of text.matchAll(ABSOLUTE_PATH_PATTERN)) {
+    const value = match[1];
+    if (!value)
+      continue;
+    paths2.push(value.replace(/[),.;:]+$/g, ""));
+  }
   return unique3(paths2);
 }
 function splitNumberedOrBulletedLines(prompt) {
@@ -397704,11 +397878,70 @@ function isCriticallyAmbiguous(segment) {
     return true;
   return /^(do|fix|update|improve|change|make|handle|clean up)(\s+(it|this|that|things?|stuff|everything))?\.?$/.test(text);
 }
+function extractCommand(segment) {
+  const backtickCommand = segment.match(/`([^`]+)`/)?.[1];
+  if (backtickCommand)
+    return compact2(backtickCommand);
+  const runCommand2 = segment.match(/\b(?:run|execute)\s+(.+)$/i)?.[1];
+  if (runCommand2 && /(?:\s|^)(?:rm|curl|wget|nmap|sqlmap|git|npm|bun|ssh|scp|kubectl|terraform)\b/.test(runCommand2)) {
+    return compact2(runCommand2);
+  }
+  if (DESTRUCTIVE_PATTERN.test(segment) || NETWORK_PATTERN.test(segment) || SECURITY_PATTERN.test(segment)) {
+    return compact2(segment);
+  }
+  return;
+}
+function isOutsideReadOnly(segment, outsidePaths) {
+  return outsidePaths.length > 0 && READ_PATTERN.test(segment) && !WRITE_PATTERN.test(segment);
+}
+function riskSignals(segment, outsidePaths) {
+  const signals2 = [];
+  if (DESTRUCTIVE_PATTERN.test(segment))
+    signals2.push("destructive command");
+  if (NETWORK_PATTERN.test(segment))
+    signals2.push("network or external-system action");
+  if (CREDENTIAL_PATTERN.test(segment))
+    signals2.push("credential-sensitive access");
+  if (SECURITY_PATTERN.test(segment))
+    signals2.push("security research scope");
+  if (outsidePaths.length > 0 && !isOutsideReadOnly(segment, outsidePaths)) {
+    signals2.push("outside-workspace modification");
+  }
+  return signals2;
+}
+function riskLevel(signals2, files) {
+  if (signals2.length > 0)
+    return "high";
+  if (files.length > 3)
+    return "medium";
+  return "low";
+}
+function approvalReasonFor(segment, signals2, outsidePaths) {
+  if (signals2.length === 0)
+    return;
+  if (SECURITY_PATTERN.test(segment) && !AUTHORIZED_SECURITY_PATTERN.test(segment)) {
+    return "Security research needs target scope and authorization confirmation before execution.";
+  }
+  if (outsidePaths.length > 0 && !isOutsideReadOnly(segment, outsidePaths)) {
+    return "Modifying or deleting outside-workspace paths requires explicit approval.";
+  }
+  if (DESTRUCTIVE_PATTERN.test(segment)) {
+    return "Destructive commands require explicit approval before execution.";
+  }
+  if (NETWORK_PATTERN.test(segment)) {
+    return "Network or external-system actions require explicit approval before execution.";
+  }
+  if (CREDENTIAL_PATTERN.test(segment)) {
+    return "Credential-sensitive access requires explicit approval before execution.";
+  }
+  return "This task requires explicit approval before execution.";
+}
 function verificationCriteria(segment, files) {
   const criteria = [
     `Result directly addresses: ${compact2(segment)}`,
     "Assumptions are stated before execution when context is incomplete.",
-    "Unsupported claims are rejected during verification."
+    "Unsupported claims are rejected during verification.",
+    "Approval-required actions are not executed before approval evidence exists."
   ];
   if (files.length > 0) {
     criteria.push("Referenced files exist before file-specific work starts.");
@@ -397718,17 +397951,24 @@ function verificationCriteria(segment, files) {
 }
 function makeTask(segment, index2, previousTaskId) {
   const files = extractReferencedFiles(segment);
-  const blocked = isCriticallyAmbiguous(segment);
+  const outsidePaths = files.filter((file2) => isAbsolute29(file2));
+  const signals2 = riskSignals(segment, outsidePaths);
+  const approvalRequired = signals2.length > 0;
+  const approvalReason = approvalReasonFor(segment, signals2, outsidePaths);
+  const command5 = extractCommand(segment);
+  const needsScope = SECURITY_PATTERN.test(segment) && !AUTHORIZED_SECURITY_PATTERN.test(segment);
+  const needsContext = isCriticallyAmbiguous(segment);
   const dependencies = previousTaskId && needsPreviousTask(segment) ? [previousTaskId] : [];
-  const assumptions = blocked ? ["Critical target/context is missing; ask for clarification before execution."] : [
+  const assumptions = needsContext ? ["Critical target/context is missing; ask for clarification before execution."] : [
     "Use the current workspace as the source of truth.",
     files.length === 0 ? "No specific files were named; discover relevant files before changing code." : "Only touch referenced files unless repository inspection proves another file is required."
   ];
   return {
     id: `task-${index2 + 1}`,
+    order: index2 + 1,
     title: titleFromSegment(segment),
     description: compact2(segment) || "Clarify the requested work.",
-    status: blocked ? "blocked" : dependencies.length > 0 ? "pending" : "ready",
+    status: needsContext ? "needs-context" : needsScope ? "needs-scope" : approvalRequired ? "waiting-approval" : dependencies.length > 0 ? "pending" : "ready",
     dependencies,
     assignedAgent: inferRole(segment),
     input: {
@@ -397738,8 +397978,16 @@ function makeTask(segment, index2, previousTaskId) {
       targetFiles: files,
       resources: extractUrls(segment)
     },
-    expectedOutput: blocked ? "A clarification request naming the missing target or context." : `Completed work for: ${compact2(segment)}`,
-    verificationCriteria: verificationCriteria(segment, files)
+    expectedOutput: needsContext ? "A clarification request naming the missing target or context." : `Completed work for: ${compact2(segment)}`,
+    verificationCriteria: verificationCriteria(segment, files),
+    fileTargets: files,
+    riskLevel: riskLevel(signals2, files),
+    approvalRequired,
+    approvalReason,
+    approvalAction: approvalRequired ? compact2(segment) || "Approval-required task" : undefined,
+    approvalCommand: command5,
+    approvalPaths: outsidePaths,
+    outsideWorkspacePaths: outsidePaths
   };
 }
 function decomposePrompt(prompt, config3) {
@@ -397765,11 +398013,19 @@ function decomposePrompt(prompt, config3) {
     config: resolvedConfig
   };
 }
-var URL_PATTERN, PATH_PATTERN;
+var URL_PATTERN, PATH_PATTERN, ABSOLUTE_PATH_PATTERN, DESTRUCTIVE_PATTERN, WRITE_PATTERN, READ_PATTERN, NETWORK_PATTERN, CREDENTIAL_PATTERN, SECURITY_PATTERN, AUTHORIZED_SECURITY_PATTERN;
 var init_planner = __esm(() => {
   init_config9();
   URL_PATTERN = /\bhttps?:\/\/[^\s)]+/gi;
   PATH_PATTERN = /(?:^|[\s"'`(])((?:\.{0,2}\/)?(?:[A-Za-z0-9_.@-]+\/)+[A-Za-z0-9_.@/-]+|(?:README|CHANGELOG|RELEASE|SECURITY|CONTRIBUTING|QUALITY|LICENSE)(?:\.[A-Za-z0-9]+)?)\b/g;
+  ABSOLUTE_PATH_PATTERN = /(?:^|[\s"'`(])((?:\/[A-Za-z0-9_.@-]+)+\/?)(?=$|[\s"',.;:)])/g;
+  DESTRUCTIVE_PATTERN = /\b(rm\s+-[A-Za-z]*r|rm\s+-[A-Za-z]*f|delete|remove|wipe|destroy|drop\s+(?:database|table)|git\s+reset\s+--hard|mkfs|chmod\s+-R\s+777|chown\s+-R)\b/i;
+  WRITE_PATTERN = /\b(write|modify|edit|update|delete|remove|rm|move|rename|chmod|chown|overwrite)\b/i;
+  READ_PATTERN = /\b(read|inspect|view|cat|open|list|show)\b/i;
+  NETWORK_PATTERN = /\b(curl|wget|ssh|scp|rsync|git\s+push|npm\s+(?:publish|install)|bun\s+add|kubectl|terraform\s+apply|deploy|production|cloud)\b/i;
+  CREDENTIAL_PATTERN = /\b(credential|api\s*key|secret|token|password|oauth|\.env)\b/i;
+  SECURITY_PATTERN = /\b(pentest|penetration\s+test|exploit|sqlmap|nmap|metasploit|payload|vulnerabilit(?:y|ies)|cve|xss|csrf|rce|security\s+scan|attack)\b/i;
+  AUTHORIZED_SECURITY_PATTERN = /\b(authorized|authorization|owned|own\s+system|my\s+(?:app|site|server|service)|localhost|127\.0\.0\.1|::1|lab|sandbox|ctf|test\s+target)\b/i;
 });
 
 // src/services/promptPlanning/index.ts
@@ -397788,6 +398044,7 @@ __export(exports_exec, {
   readPrompts: () => readPrompts,
   formatExecFinalReport: () => formatExecFinalReport,
   execCommandForPrompt: () => execCommandForPrompt,
+  changedFilesSinceBefore: () => changedFilesSinceBefore,
   call: () => call60,
   buildExecFinalReport: () => buildExecFinalReport
 });
@@ -397922,13 +398179,22 @@ async function currentChangedFiles(cwd2) {
   });
   return result.code === 0 ? parseGitStatusFiles(result.stdout) : [];
 }
+function changedFilesSinceBefore(beforeFiles, afterFiles) {
+  const before = new Set(beforeFiles);
+  return [...afterFiles].filter((file2) => !before.has(file2));
+}
 function plannedTaskPrompt(task) {
   return [
     `UR-Nexus planned task ${task.id}: ${task.title}`,
+    `Order: ${task.order}`,
+    `Risk level: ${task.riskLevel}`,
+    `Approval required: ${task.approvalRequired ? "yes" : "not required"}`,
+    ...task.approvalReason ? [`Approval reason: ${task.approvalReason}`] : [],
     "",
     task.description,
     "",
     `Assigned role: ${task.assignedAgent}`,
+    `File targets: ${task.fileTargets.length > 0 ? task.fileTargets.join(", ") : "not specified"}`,
     "",
     "Assumptions:",
     ...task.input.assumptions.map((value) => `- ${value}`),
@@ -397943,7 +398209,7 @@ function plannedTaskPrompt(task) {
 function defaultPlannedTaskExecutor(opts) {
   return async (task) => {
     const command5 = execCommandForPrompt(plannedTaskPrompt(task), opts);
-    const before = new Set(await currentChangedFiles(opts.cwd));
+    const before = await currentChangedFiles(opts.cwd);
     const result = await execFileNoThrowWithCwd(command5[0], command5.slice(1), {
       cwd: opts.cwd,
       timeout: 10 * 60000,
@@ -397956,13 +398222,13 @@ function defaultPlannedTaskExecutor(opts) {
       }
     });
     const after = await currentChangedFiles(opts.cwd);
-    const changedFiles = after.filter((file2) => !before.has(file2));
+    const changedFiles = changedFilesSinceBefore(before, after);
     const output = [result.stdout, result.stderr].filter(Boolean).join(`
 `);
     return {
       ok: result.code === 0,
       output,
-      changedFiles: changedFiles.length > 0 ? changedFiles : after,
+      changedFiles,
       commandsRun: [formatCommand3(command5)],
       error: result.code === 0 ? undefined : result.error ?? result.stderr
     };
@@ -397984,6 +398250,15 @@ function taskLine(task) {
     agent: String(task.assignedAgent)
   };
 }
+function isWaitingTask(task) {
+  return [
+    "blocked",
+    "waiting-approval",
+    "needs-scope",
+    "needs-context",
+    "paused-review"
+  ].includes(task.status);
+}
 function buildExecFinalReport(run) {
   const issues = run.taskResults.flatMap((record3) => {
     const issues2 = [
@@ -398007,15 +398282,22 @@ function buildExecFinalReport(run) {
       total: run.tasks.length,
       finished: run.finished,
       failed: run.failed,
-      blocked: run.blocked
+      waitingApproval: run.waitingApproval,
+      skipped: run.skipped
     },
+    activeAgentsUsed: run.maxAgentsUsed,
+    maxAgentsAllowed: run.maxAgentsAllowed,
     finishedTasks: run.tasks.filter((task) => task.status === "finished").map(taskLine),
     failedTasks: run.tasks.filter((task) => task.status === "failed").map(taskLine),
-    blockedTasks: run.tasks.filter((task) => task.status === "blocked").map(taskLine),
+    waitingApprovalTasks: run.tasks.filter(isWaitingTask).map(taskLine),
+    skippedTasks: run.tasks.filter((task) => task.status === "skipped").map(taskLine),
     actualChangedFiles,
     unreportedChangedFiles: unique4(run.taskResults.flatMap((record3) => record3.unreportedChangedFiles)),
+    outsideWorkspaceFilesAccessed: run.outsideWorkspaceReads,
+    outsideWorkspaceFilesModified: run.outsideWorkspaceWrites,
     verifiedCommands,
     unverifiedCommandClaims: unique4(run.taskResults.flatMap((record3) => record3.unverifiedCommandClaims)),
+    approvalDecisions: run.approvalDecisions,
     filesChanged: actualChangedFiles,
     commandsRun: verifiedCommands,
     verificationFailures,
@@ -398030,13 +398312,27 @@ function buildExecFinalReport(run) {
 function formatList(items, empty, render2) {
   return items.length > 0 ? items.map(render2) : [`- ${empty}`];
 }
+function formatApprovalDecision(decision) {
+  const details = [
+    decision.command ? `command: ${decision.command}` : "",
+    decision.paths.length > 0 ? `paths: ${decision.paths.join(", ")}` : ""
+  ].filter(Boolean);
+  return [
+    `- ${decision.taskId} | ${decision.status} | ${decision.action}`,
+    `  reason: ${decision.reason}`,
+    ...details.length > 0 ? [`  ${details.join(" | ")}`] : []
+  ].join(`
+`);
+}
 function formatExecFinalReport(report) {
   return [
     "UR-Nexus task summary",
     `Total: ${report.summary.total}`,
     `Finished: ${report.summary.finished}`,
     `Failed: ${report.summary.failed}`,
-    `Blocked: ${report.summary.blocked}`,
+    `Waiting approval/input: ${report.summary.waitingApproval}`,
+    `Skipped: ${report.summary.skipped}`,
+    `Agents used: ${report.activeAgentsUsed} active / ${report.maxAgentsAllowed} max`,
     "",
     "Finished tasks:",
     ...formatList(report.finishedTasks, "none", (task) => `- ${task.id} | ${task.agent} | ${task.title}`),
@@ -398044,12 +398340,21 @@ function formatExecFinalReport(report) {
     "Failed tasks:",
     ...formatList(report.failedTasks, "none", (task) => `- ${task.id} | ${task.agent} | ${task.title}`),
     "",
-    "Blocked tasks:",
-    ...formatList(report.blockedTasks, "none", (task) => `- ${task.id} | ${task.agent} | ${task.title}`),
+    "Waiting approval/input tasks:",
+    ...formatList(report.waitingApprovalTasks, "none", (task) => `- ${task.id} | ${task.agent} | ${task.title}`),
+    "",
+    "Skipped tasks:",
+    ...formatList(report.skippedTasks, "none", (task) => `- ${task.id} | ${task.agent} | ${task.title}`),
     "",
     "Actual changed files:",
     ...formatList(report.actualChangedFiles, "none observed", (file2) => `- ${file2}`),
     "",
+    "Outside-workspace files accessed:",
+    ...formatList(report.outsideWorkspaceFilesAccessed, "none observed", (file2) => `- ${file2}`),
+    "",
+    "Outside-workspace files modified:",
+    ...formatList(report.outsideWorkspaceFilesModified, "none observed", (file2) => `- ${file2}`),
+    "",
     "Unreported changed files:",
     ...formatList(report.unreportedChangedFiles, "none", (file2) => `- ${file2}`),
     "",
@@ -398059,6 +398364,9 @@ function formatExecFinalReport(report) {
     "Unverified command claims:",
     ...formatList(report.unverifiedCommandClaims, "none", (command5) => `- ${command5}`),
     "",
+    "Approval decisions:",
+    ...formatList(report.approvalDecisions, "none", formatApprovalDecision),
+    "",
     "Verification failures:",
     ...formatList(report.verificationFailures, "none", (failure) => `- ${failure.taskId} | ${failure.code} | ${failure.message}`),
     "",
@@ -398071,7 +398379,7 @@ function formatExecFinalReport(report) {
 `);
 }
 function aggregateTask(prompt, plan, run, cwd2) {
-  const failed = run.failed > 0 || run.blocked > 0;
+  const failed = run.failed > 0 || run.blocked > 0 || run.waitingApproval > 0 || run.skipped > 0;
   const now7 = new Date().toISOString();
   return {
     id: plan.id,
@@ -398115,7 +398423,7 @@ async function runPromptPlans(prompts, opts) {
         }
       });
       const completedPlan = { ...plan, tasks: run.tasks };
-      const taskBoard = config3.showTaskBoard ? renderTaskBoard(completedPlan) : undefined;
+      const taskBoard = config3.showTaskBoard ? renderTaskBoard(completedPlan, { maxAgents: run.maxAgentsAllowed }) : undefined;
       const finalReport = buildExecFinalReport(run);
       const command5 = finalReport.commandsRun;
       results[index2] = {
@@ -410506,7 +410814,7 @@ var init_code_index2 = __esm(() => {
 
 // node_modules/typescript/lib/typescript.js
 var require_typescript2 = __commonJS((exports, module) => {
-  var __dirname = "/sessions/brave-exciting-keller/mnt/UR-1.37.2/node_modules/typescript/lib", __filename = "/sessions/brave-exciting-keller/mnt/UR-1.37.2/node_modules/typescript/lib/typescript.js";
+  var __dirname = "/Users/maith/Desktop/ur3-dev/UR-1.41.0/node_modules/typescript/lib", __filename = "/Users/maith/Desktop/ur3-dev/UR-1.41.0/node_modules/typescript/lib/typescript.js";
   /*! *****************************************************************************
   Copyright (c) Microsoft Corporation. All rights reserved.
   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -579248,7 +579556,7 @@ import {
   statSync as statSync12,
   writeFileSync as writeFileSync45
 } from "fs";
-import { dirname as dirname64, extname as extname17, isAbsolute as isAbsolute29, join as join176, relative as relative37, resolve as resolve46 } from "path";
+import { dirname as dirname64, extname as extname17, isAbsolute as isAbsolute30, join as join176, relative as relative37, resolve as resolve46 } from "path";
 import { promisify as promisify4 } from "util";
 function repoEditIndexPath(root2) {
   return join176(root2, ".ur", "repo-edit", "index.json");
@@ -579641,7 +579949,7 @@ function formatSearchHits(hits) {
 `);
 }
 function resolveRepoPath(root2, maybePath) {
-  const resolved = isAbsolute29(maybePath) ? maybePath : resolve46(root2, maybePath);
+  const resolved = isAbsolute30(maybePath) ? maybePath : resolve46(root2, maybePath);
   const rel = relative37(root2, resolved);
   if (rel.startsWith("..")) {
     throw new Error(`Path escapes repository root: ${maybePath}`);
@@ -581484,9 +581792,9 @@ var init_cite2 = __esm(() => {
 
 // src/ur/fileops.ts
 import { existsSync as existsSync55, mkdirSync as mkdirSync48, readdirSync as readdirSync23, readFileSync as readFileSync62, statSync as statSync13, writeFileSync as writeFileSync47 } from "fs";
-import { extname as extname19, isAbsolute as isAbsolute30, join as join180, relative as relative39, resolve as resolve47 } from "path";
+import { extname as extname19, isAbsolute as isAbsolute31, join as join180, relative as relative39, resolve as resolve47 } from "path";
 function readFileSafe2(cwd2, target, maxBytes = 64000) {
-  const abs = isAbsolute30(target) ? target : resolve47(cwd2, target);
+  const abs = isAbsolute31(target) ? target : resolve47(cwd2, target);
   if (!existsSync55(abs))
     return { ok: false, error: `not found: ${target}` };
   const st = statSync13(abs);
@@ -581825,12 +582133,12 @@ __export(exports_image, {
   call: () => call108
 });
 import { existsSync as existsSync56, statSync as statSync14 } from "fs";
-import { extname as extname20, isAbsolute as isAbsolute31, resolve as resolve48 } from "path";
+import { extname as extname20, isAbsolute as isAbsolute32, resolve as resolve48 } from "path";
 var call108 = async (args) => {
   const f = (args ?? "").trim().split(/\s+/)[0] ?? "";
   if (!f)
     return { type: "text", value: "usage: /image <file> [task]" };
-  const abs = isAbsolute31(f) ? f : resolve48(getCwd(), f);
+  const abs = isAbsolute32(f) ? f : resolve48(getCwd(), f);
   if (!existsSync56(abs))
     return { type: "text", value: `not found: ${f}` };
   const kb = Math.round(statSync14(abs).size / 1024);
@@ -581873,7 +582181,7 @@ __export(exports_video, {
   call: () => call109
 });
 import { existsSync as existsSync57 } from "fs";
-import { isAbsolute as isAbsolute32, resolve as resolve49 } from "path";
+import { isAbsolute as isAbsolute33, resolve as resolve49 } from "path";
 var call109 = async (args) => {
   const target = (args ?? "").trim().split(/\s+/)[0] ?? "";
   if (!target)
@@ -581884,7 +582192,7 @@ var call109 = async (args) => {
     return { type: "text", value: `remote video: ${target}
 ${yd}` };
   }
-  const abs = isAbsolute32(target) ? target : resolve49(getCwd(), target);
+  const abs = isAbsolute33(target) ? target : resolve49(getCwd(), target);
   if (!existsSync57(abs))
     return { type: "text", value: `not found: ${target}` };
   if (!commandExists("ffprobe")) {
@@ -596040,7 +596348,7 @@ async function captureMemoryDiagnostics(trigger2, dumpNumber = 0) {
     smapsRollup,
     platform: process.platform,
     nodeVersion: process.version,
-    ccVersion: "1.40.1"
+    ccVersion: "1.41.0"
   };
 }
 async function performHeapDump(trigger2 = "manual", dumpNumber = 0) {
@@ -596626,7 +596934,7 @@ var init_bridge_kick = __esm(() => {
 var call137 = async () => {
   return {
     type: "text",
-    value: "1.40.1"
+    value: "1.41.0"
   };
 }, version2, version_default;
 var init_version = __esm(() => {
@@ -598682,7 +598990,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 dirname68, isAbsolute as isAbsolute33, join as join193, normalize as normalize13, sep as pathSep3 } from "path";
+import { dirname as dirname68, isAbsolute as isAbsolute34, join as join193, normalize as normalize13, sep as pathSep3 } from "path";
 function registerBundledSkill(definition) {
   const { files: files2 } = definition;
   let skillRoot;
@@ -598769,7 +599077,7 @@ async function safeWriteFile(p2, content) {
 }
 function resolveSkillFilePath(baseDir, relPath) {
   const normalized = normalize13(relPath);
-  if (isAbsolute33(normalized) || normalized.split(pathSep3).includes("..") || normalized.split("/").includes("..")) {
+  if (isAbsolute34(normalized) || normalized.split(pathSep3).includes("..") || normalized.split("/").includes("..")) {
     throw new Error(`bundled skill file path escapes skill dir: ${relPath}`);
   }
   return join193(baseDir, normalized);
@@ -600145,6 +600453,11 @@ function ModelPickerWrapper(t0) {
         mainLoopModel: model,
         mainLoopModelForSession: null
       }));
+      if (model && metadata) {
+        setProviderModel(metadata.providerId, model, {
+          modelSource: metadata.modelSource
+        });
+      }
       let message = metadata ? `Selected provider: ${source_default.bold(metadata.providerName)} (${metadata.accessType})
 Selected model: ${source_default.bold(renderModelLabel(model))}
 Model source: ${metadata.modelSource}
@@ -600293,6 +600606,14 @@ function SetModelAndClose({
           }
         } : {}
       }));
+      if (modelValue === null) {
+        updateSettingsForSource("localSettings", {
+          model: undefined,
+          provider: {
+            model: undefined
+          }
+        });
+      }
       let message = `Set model to ${source_default.bold(renderModelLabel(modelValue))}`;
       let wasFastModeToggledOn = undefined;
       if (isFastModeEnabled()) {
@@ -606706,7 +607027,7 @@ function generateHtmlReport(data, insights) {
 </html>`;
 }
 function buildExportData(data, insights, facets, remoteStats) {
-  const version3 = typeof MACRO !== "undefined" ? "1.40.1" : "unknown";
+  const version3 = typeof MACRO !== "undefined" ? "1.41.0" : "unknown";
   const remote_hosts_collected = remoteStats?.hosts.filter((h2) => h2.sessionCount > 0).map((h2) => h2.name);
   const facets_summary = {
     total: facets.size,
@@ -610986,7 +611307,7 @@ var init_sessionStorage = __esm(() => {
   init_settings2();
   init_slowOperations();
   init_uuid();
-  VERSION5 = typeof MACRO !== "undefined" ? "1.40.1" : "unknown";
+  VERSION5 = typeof MACRO !== "undefined" ? "1.41.0" : "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([
@@ -612191,7 +612512,7 @@ var init_filesystem = __esm(() => {
   });
   getBundledSkillsRoot = memoize_default(function getBundledSkillsRoot2() {
     const nonce = randomBytes18(16).toString("hex");
-    return join202(getURTempDir(), "bundled-skills", "1.40.1", nonce);
+    return join202(getURTempDir(), "bundled-skills", "1.41.0", nonce);
   });
   getResolvedWorkingDirPaths = memoize_default(getPathsForPermissionCheck);
 });
@@ -618480,7 +618801,7 @@ function computeFingerprint(messageText2, version3) {
 }
 function computeFingerprintFromMessages(messages) {
   const firstMessageText = extractFirstMessageText(messages);
-  return computeFingerprint(firstMessageText, "1.40.1");
+  return computeFingerprint(firstMessageText, "1.41.0");
 }
 var FINGERPRINT_SALT = "59cf53e54c78";
 var init_fingerprint = () => {};
@@ -620354,7 +620675,7 @@ async function sideQuery(opts) {
     betas.push(STRUCTURED_OUTPUTS_BETA_HEADER);
   }
   const messageText2 = extractFirstUserMessageText(messages);
-  const fingerprint2 = computeFingerprint(messageText2, "1.40.1");
+  const fingerprint2 = computeFingerprint(messageText2, "1.41.0");
   const attributionHeader = getAttributionHeader(fingerprint2);
   const systemBlocks = [
     attributionHeader ? { type: "text", text: attributionHeader } : null,
@@ -625091,7 +625412,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.40.1",
+    ur_version: "1.41.0",
     output_style: outputStyle2,
     agents: inputs.agents.map((agent) => agent.agentType),
     skills: inputs.skills.filter((s) => s.userInvocable !== false).map((skill2) => skill2.name),
@@ -630599,8 +630920,8 @@ function ShimmerLoadingText() {
   }
   return t2;
 }
-function getRiskColor(riskLevel) {
-  switch (riskLevel) {
+function getRiskColor(riskLevel2) {
+  switch (riskLevel2) {
     case "LOW":
       return "success";
     case "MEDIUM":
@@ -630609,8 +630930,8 @@ function getRiskColor(riskLevel) {
       return "error";
   }
 }
-function getRiskLabel(riskLevel) {
-  switch (riskLevel) {
+function getRiskLabel(riskLevel2) {
+  switch (riskLevel2) {
     case "LOW":
       return "Low risk";
     case "MEDIUM":
@@ -639719,7 +640040,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.40.1") {
+function useUpdateNotification(updatedVersion, initialVersion = "1.41.0") {
   const [lastNotifiedSemver, setLastNotifiedSemver] = import_react226.useState(() => getSemverPart(initialVersion));
   if (!updatedVersion) {
     return null;
@@ -639768,7 +640089,7 @@ function AutoUpdater({
       return;
     }
     if (false) {}
-    const currentVersion = "1.40.1";
+    const currentVersion = "1.41.0";
     const channel = getInitialSettings()?.autoUpdatesChannel ?? "latest";
     let latestVersion = await getLatestVersion(channel);
     const isDisabled = isAutoUpdaterDisabled();
@@ -639997,12 +640318,12 @@ function NativeAutoUpdater({
     logEvent("tengu_native_auto_updater_start", {});
     try {
       const maxVersion = await getMaxVersion();
-      if (maxVersion && gt("1.40.1", maxVersion)) {
+      if (maxVersion && gt("1.41.0", maxVersion)) {
         const msg = await getMaxVersionMessage();
         setMaxVersionIssue(msg ?? "affects your version");
       }
       const result = await installLatest(channel);
-      const currentVersion = "1.40.1";
+      const currentVersion = "1.41.0";
       const latencyMs = Date.now() - startTime;
       if (result.lockFailed) {
         logEvent("tengu_native_auto_updater_lock_contention", {
@@ -640139,17 +640460,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.40.1", maxVersion)) {
-          logForDebugging(`PackageManagerAutoUpdater: current version ${"1.40.1"} is already at or above maxVersion ${maxVersion}, skipping update`);
+        if (gte("1.41.0", maxVersion)) {
+          logForDebugging(`PackageManagerAutoUpdater: current version ${"1.41.0"} is already at or above maxVersion ${maxVersion}, skipping update`);
           setUpdateAvailable(false);
           return;
         }
         latest = maxVersion;
       }
-      const hasUpdate = latest && !gte("1.40.1", latest) && !shouldSkipVersion(latest);
+      const hasUpdate = latest && !gte("1.41.0", latest) && !shouldSkipVersion(latest);
       setUpdateAvailable(!!hasUpdate);
       if (hasUpdate) {
-        logForDebugging(`PackageManagerAutoUpdater: Update available ${"1.40.1"} -> ${latest}`);
+        logForDebugging(`PackageManagerAutoUpdater: Update available ${"1.41.0"} -> ${latest}`);
       }
     };
     $3[0] = t1;
@@ -640183,7 +640504,7 @@ function PackageManagerAutoUpdater(t0) {
       wrap: "truncate",
       children: [
         "currentVersion: ",
-        "1.40.1"
+        "1.41.0"
       ]
     }, undefined, true, undefined, this);
     $3[3] = verbose;
@@ -652635,7 +652956,7 @@ function buildStatusLineCommandInput(permissionMode, exceeds200kTokens, settings
       project_dir: getOriginalCwd(),
       added_dirs: addedDirs
     },
-    version: "1.40.1",
+    version: "1.41.0",
     output_style: {
       name: outputStyleName
     },
@@ -652718,7 +653039,7 @@ function StatusLineInner({
   const taskValues = Object.values(tasks2);
   const taskRunningCount = taskValues.filter((task2) => task2.status === "running" || task2.status === "pending").length;
   const defaultStatusLineText = buildDefaultStatusBar({
-    version: "1.40.1",
+    version: "1.41.0",
     providerLabel: providerRuntime.providerLabel,
     authMode: providerRuntime.authLabel,
     model: providerRuntime.model ?? renderModelName(mainLoopModel),
@@ -664206,7 +664527,7 @@ async function submitTranscriptShare(messages, trigger2, appearanceId) {
     } catch {}
     const data = {
       trigger: trigger2,
-      version: "1.40.1",
+      version: "1.41.0",
       platform: process.platform,
       transcript,
       subagentTranscripts: Object.keys(subagentTranscripts).length > 0 ? subagentTranscripts : undefined,
@@ -669340,7 +669661,7 @@ var init_usePluginAutoupdateNotification = __esm(() => {
 });
 
 // src/utils/plugins/reconciler.ts
-import { isAbsolute as isAbsolute34, resolve as resolve51 } from "path";
+import { isAbsolute as isAbsolute35, resolve as resolve51 } from "path";
 function diffMarketplaces(declared, materialized, opts) {
   const missing = [];
   const sourceChanged = [];
@@ -669448,7 +669769,7 @@ async function reconcileMarketplaces(opts) {
   return { installed, updated, failed, upToDate: diff3.upToDate, skipped };
 }
 function normalizeSource(source, projectRoot2) {
-  if ((source.source === "directory" || source.source === "file") && !isAbsolute34(source.path)) {
+  if ((source.source === "directory" || source.source === "file") && !isAbsolute35(source.path)) {
     const base2 = projectRoot2 ?? getOriginalCwd();
     const canonicalRoot = findCanonicalGitRoot(base2);
     return {
@@ -676091,7 +676412,7 @@ function WelcomeV2() {
             dimColor: true,
             children: [
               "v",
-              "1.40.1"
+              "1.41.0"
             ]
           }, undefined, true, undefined, this)
         ]
@@ -677351,7 +677672,7 @@ function completeOnboarding() {
   saveGlobalConfig((current) => ({
     ...current,
     hasCompletedOnboarding: true,
-    lastOnboardingVersion: "1.40.1"
+    lastOnboardingVersion: "1.41.0"
   }));
 }
 function showDialog(root2, renderer) {
@@ -682388,7 +682709,7 @@ function appendToLog(path24, message) {
     cwd: getFsImplementation().cwd(),
     userType: process.env.USER_TYPE,
     sessionId: getSessionId(),
-    version: "1.40.1"
+    version: "1.41.0"
   };
   getLogWriter(path24).write(messageWithTimestamp);
 }
@@ -686482,8 +686803,8 @@ async function getEnvLessBridgeConfig() {
 }
 async function checkEnvLessBridgeMinVersion() {
   const cfg = await getEnvLessBridgeConfig();
-  if (cfg.min_version && lt("1.40.1", cfg.min_version)) {
-    return `Your version of UR (${"1.40.1"}) is too old for Remote Control.
+  if (cfg.min_version && lt("1.41.0", cfg.min_version)) {
+    return `Your version of UR (${"1.41.0"}) is too old for Remote Control.
 Version ${cfg.min_version} or higher is required. Run \`ur update\` to update.`;
   }
   return null;
@@ -686957,7 +687278,7 @@ async function initBridgeCore(params) {
   const rawApi = createBridgeApiClient({
     baseUrl,
     getAccessToken,
-    runnerVersion: "1.40.1",
+    runnerVersion: "1.41.0",
     onDebug: logForDebugging,
     onAuth401,
     getTrustedDeviceToken
@@ -692639,7 +692960,7 @@ async function startMCPServer(cwd3, debug2, verbose) {
   setCwd(cwd3);
   const server2 = new Server({
     name: "ur/tengu",
-    version: "1.40.1"
+    version: "1.41.0"
   }, {
     capabilities: {
       tools: {}
@@ -694681,7 +695002,7 @@ async function update() {
   logEvent("tengu_update_check", {});
   const diagnostic = await getDoctorDiagnostic();
   const result = await checkUpgradeStatus({
-    currentVersion: "1.40.1",
+    currentVersion: "1.41.0",
     packageName: UR_AGENT_PACKAGE_NAME,
     installationType: diagnostic.installationType,
     latestVersion: () => getLatestNpmPackageVersion(UR_AGENT_PACKAGE_NAME)
@@ -695927,7 +696248,7 @@ ${customInstructions}` : customInstructions;
       }
     }
     logForDiagnosticsNoPII("info", "started", {
-      version: "1.40.1",
+      version: "1.41.0",
       is_native_binary: isInBundledMode()
     });
     registerCleanup(async () => {
@@ -696713,7 +697034,7 @@ Usage: ur --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version("1.40.1 (UR-Nexus)", "-v, --version", "Output the version number");
+  }).version("1.41.0 (UR-Nexus)", "-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()) {
@@ -697628,7 +697949,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.40.1"} (UR-Nexus)`);
+    console.log(`${"1.41.0"} (UR-Nexus)`);
     return;
   }
   if (args[0] === "a2a" && args[1] === "serve" && !args.includes("--help") && !args.includes("-h")) {