@atlasharness/atlascode 0.1.64 → 0.1.66

package/dist/cli.js

@@ -37092,9 +37092,9 @@ function formatAgentLine(agent) {
 function getPrompt(agents) {
   const list = agents.length > 0 ? agents.map(formatAgentLine).join(`
 `) : "- general-purpose: General-purpose agent for researching and executing multi-step tasks.";
-  return "Launch a subagent to run a self-contained task in an isolated context. " + "Provide a short description (3-5 words) and a fully self-contained prompt " + "(the subagent cannot see this conversation). " + "Be cost-aware about delegating: prefer to do the work inline in this " + "conversation for a small task with a known, bounded target (a single-file " + "edit, a quick lookup, a change you can finish without broad exploration) — " + "spawning a subagent has overhead. Delegate when the task is genuinely " + "parallelizable or would otherwise flood this context with material you do " + "not need to keep (a broad multi-file search, an isolated multi-step " + "implementation, or independent work that can run alongside your own). Keep " + "each delegated brief narrow and evidence-focused: name the exact goal, the " + "files or area, and the expected deliverable rather than a broad " + '"figure this out." Because the subagent cannot see this conversation, its ' + "prompt must be fully self-contained — state every constraint, file, and " + "reporting requirement it needs. " + `Available agent types and the tools they have access to:
+  return "Launch a subagent to run a self-contained task in an isolated context. " + "Provide a short description (3-5 words) and a fully self-contained prompt " + "(the subagent cannot see this conversation). " + "Be cost-aware about delegating: prefer to do the work inline in this " + "conversation for a small task with a known, bounded target (a single-file " + "edit, a quick lookup, a change you can finish without broad exploration) — " + "spawning a subagent has overhead. Delegate when the task is genuinely " + "parallelizable or would otherwise flood this context with material you do " + "not need to keep (a broad multi-file search, an isolated multi-step " + "implementation, or independent work that can run alongside your own). Keep " + "each delegated brief narrow and evidence-focused: name the exact goal, the " + "files or area, and the expected deliverable rather than a broad " + '"figure this out." Because the subagent cannot see this conversation, its ' + "prompt must be fully self-contained — state every constraint, file, and " + "reporting requirement it needs. " + "Subagents run in the background by default; you will receive a " + "task-notification when one completes — do not poll or sleep waiting for " + "it. Set run_in_background to false only when you need the result before " + "you can proceed. Use background for genuinely parallel work, not to defer " + "a result you need immediately. " + `Available agent types and the tools they have access to:
 ${list}
-` + `The ${AGENT_TOOL_NAME} tool runs the subagent and returns its final result ` + "when it completes; act on that result once it is returned.";
+` + `The ${AGENT_TOOL_NAME} tool runs the subagent and returns its final result ` + "when it completes; act on that result once it is returned. " + "Do not predict or assume what the subagent will find — wait for its " + "returned result and act on what it actually reports.";
 }
 var init_prompt = () => {};
 
@@ -37136,13 +37136,112 @@ async function runAgent(args) {
     turns: loopResult.turns
   };
 }
+function wrapPermissionGateForBackground(gate, onNeedsInput) {
+  if (!gate)
+    return;
+  return async (tool, input, callContext) => {
+    const verdict = await gate(tool, input, callContext);
+    if (verdict.ask) {
+      onNeedsInput({
+        toolName: tool.name,
+        reason: verdict.reason
+      });
+    }
+    return verdict;
+  };
+}
+async function runAsyncAgentLifecycle(args) {
+  const { description, toolUseId, signal, agentId } = args;
+  const wrappedCheckPermission = wrapPermissionGateForBackground(args.checkPermission, (req) => {
+    enqueueAgentNotification({
+      taskId: agentId,
+      description,
+      status: "needs_input",
+      inputRequest: `Permission required for ${req.toolName}${req.reason ? `: ${req.reason}` : ""}`,
+      ...toolUseId ? { toolUseId } : {}
+    });
+  });
+  try {
+    const { result } = await runAgent({
+      ...args,
+      checkPermission: wrappedCheckPermission
+    });
+    const finalMessage = result.content.map((b) => b.text).join("");
+    enqueueAgentNotification({
+      taskId: agentId,
+      description,
+      status: "completed",
+      finalMessage: finalMessage || undefined,
+      usage: {
+        totalTokens: result.totalTokens,
+        toolUses: result.totalToolUseCount,
+        durationMs: result.totalDurationMs
+      },
+      ...toolUseId ? { toolUseId } : {}
+    });
+  } catch (err) {
+    if (signal?.aborted) {
+      enqueueAgentNotification({
+        taskId: agentId,
+        description,
+        status: "killed",
+        ...toolUseId ? { toolUseId } : {}
+      });
+      return;
+    }
+    enqueueAgentNotification({
+      taskId: agentId,
+      description,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err),
+      ...toolUseId ? { toolUseId } : {}
+    });
+  }
+}
 var init_runAgent = __esm(() => {
   init_query2();
   init_agentToolUtils();
+  init_localAgentTask();
+});
+
+// src/engine/tools/agent/backgroundTracker.ts
+function trackBackgroundAgent(p) {
+  const handled = p.then(() => {}, () => {});
+  pendingBackgroundAgents.add(handled);
+  handled.finally(() => {
+    pendingBackgroundAgents.delete(handled);
+  });
+}
+function hasPendingBackgroundAgents() {
+  return pendingBackgroundAgents.size > 0;
+}
+async function drainPendingBackgroundAgents(signal) {
+  if (pendingBackgroundAgents.size === 0)
+    return;
+  const promises = Array.from(pendingBackgroundAgents);
+  if (signal?.aborted)
+    return;
+  await Promise.allSettled(promises);
+}
+function resetBackgroundAgentTracker() {
+  pendingBackgroundAgents.clear();
+}
+var pendingBackgroundAgents;
+var init_backgroundTracker = __esm(() => {
+  pendingBackgroundAgents = new Set;
 });
 
 // src/engine/tools/agent/AgentTool.ts
 import { randomUUID as randomUUID5 } from "crypto";
+function isAgentBackgroundByDefault() {
+  return !isEnvTruthy(process.env.ATLAS_AGENT_DEFAULT_FOREGROUND);
+}
+function shouldRunInBackground(runInBg) {
+  if (isAgentBackgroundByDefault()) {
+    return runInBg !== false;
+  }
+  return !!runInBg;
+}
 function resolveAgentDefinition(subagentType, agents) {
   if (!subagentType)
     return GENERAL_PURPOSE_AGENT;
@@ -37164,6 +37263,10 @@ var init_AgentTool = __esm(() => {
   init_prompt();
   init_runAgent();
   init_coordinator();
+  init_task2();
+  init_localAgentTask();
+  init_shared();
+  init_backgroundTracker();
   AGENT_TOOL_INPUT_SCHEMA = {
     type: "object",
     properties: {
@@ -37182,6 +37285,10 @@ var init_AgentTool = __esm(() => {
       model: {
         enum: ["small", "premium", "fast"],
         description: "Optional model override for this agent. Takes precedence over the agent definition's model. If omitted, inherits from the parent."
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "Set to true to run this agent in the background. You will be notified when it completes."
       }
     },
     required: ["description", "prompt"]
@@ -37218,6 +37325,13 @@ var init_AgentTool = __esm(() => {
 ` + text
         };
       }
+      if (c && c.status === "async_launched") {
+        return {
+          type: "tool_result",
+          tool_use_id: toolUseID,
+          content: "[agent launched in background] agentId=" + (c.agentId ?? "") + " output=" + (c.outputFile ?? "")
+        };
+      }
       return {
         type: "tool_result",
         tool_use_id: toolUseID,
@@ -37235,6 +37349,39 @@ var init_AgentTool = __esm(() => {
       const allowFanOut = isCoordinatorMode() && childSpawnDepth < MAX_WORKER_SPAWN_DEPTH;
       const resolvedTools = resolveAgentTools(agentDefinition, availableTools, allowFanOut).resolvedTools;
       const agentId = "agent-" + randomUUID5();
+      if (shouldRunInBackground(input.run_in_background)) {
+        const outputFile = getTaskOutputPath(agentId);
+        const bgPromise = runAsyncAgentLifecycle({
+          agentDefinition,
+          prompt: input.prompt,
+          tools: resolvedTools,
+          modelProvider,
+          parentRole,
+          overrideRole: input.model,
+          agentId,
+          spawnDepth: childSpawnDepth,
+          signal: ctx.signal,
+          checkPermission: ctx.checkPermission,
+          description: input.description
+        }).catch((err) => {
+          enqueueAgentNotification({
+            taskId: agentId,
+            description: input.description,
+            status: "failed",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+        trackBackgroundAgent(bgPromise);
+        return {
+          data: {
+            status: "async_launched",
+            agentId,
+            description: input.description,
+            prompt: input.prompt,
+            outputFile
+          }
+        };
+      }
       const { result } = await runAgent({
         agentDefinition,
         prompt: input.prompt,
@@ -51573,6 +51720,7 @@ var init_agent = __esm(() => {
   init_forkSubagent();
   init_agentToolUtils();
   init_prompt();
+  init_backgroundTracker();
 });
 
 // src/engine/tools/bash/bashPrompt.ts
@@ -79621,24 +79769,27 @@ function enqueueAgentNotification({
   usage,
   toolUseId,
   worktreePath,
-  worktreeBranch
+  worktreeBranch,
+  inputRequest
 }) {
-  let shouldEnqueue = false;
-  updateTaskState(taskId, setAppState, (task) => {
-    if (task.notified) {
-      return task;
+  if (setAppState && status !== "needs_input") {
+    let shouldEnqueue = false;
+    updateTaskState(taskId, setAppState, (task) => {
+      if (task.notified) {
+        return task;
+      }
+      shouldEnqueue = true;
+      return {
+        ...task,
+        notified: true
+      };
+    });
+    if (!shouldEnqueue) {
+      return;
     }
-    shouldEnqueue = true;
-    return {
-      ...task,
-      notified: true
-    };
-  });
-  if (!shouldEnqueue) {
-    return;
   }
   const escapedDescription = escapeXml(description);
-  const summary = status === "completed" ? `Agent "${escapedDescription}" completed` : status === "failed" ? `Agent "${escapedDescription}" failed: ${escapeXml(error || "Unknown error")}` : `Agent "${escapedDescription}" was stopped`;
+  const summary = status === "completed" ? `Agent "${escapedDescription}" completed` : status === "failed" ? `Agent "${escapedDescription}" failed: ${escapeXml(error || "Unknown error")}` : status === "killed" ? `Agent "${escapedDescription}" was stopped` : status === "needs_input" ? `Agent "${escapedDescription}" needs input: ${escapeXml(inputRequest || "Permission request or question pending")}` : `Agent "${escapedDescription}" ${escapeXml(status)}`;
   const outputPath = getTaskOutputPath(taskId);
   const toolUseIdLine = toolUseId ? `
 <${TOOL_USE_ID_TAG}>${escapeXml(toolUseId)}</${TOOL_USE_ID_TAG}>` : "";
@@ -86835,6 +86986,7 @@ async function runHeadless(inputPrompt, options) {
     }
     cronScheduler.stop();
     await drainToOutput();
+    await drainPendingBackgroundAgents(abortController.signal);
   } catch (error) {
     cronScheduler.stop();
     logForDebugging2(headlessErrorLine(error), { level: "error" });
@@ -180233,6 +180385,7 @@ __export(exports_engineCompat, {
   dequeueAllMatching: () => dequeueAllMatching,
   dequeuePendingNotification: () => dequeuePendingNotification,
   doesMessageExistInSession: () => doesMessageExistInSession,
+  drainPendingBackgroundAgents: () => drainPendingBackgroundAgents,
   drainPendingMessages: () => drainPendingMessages,
   drainSdkEvents: () => drainSdkEvents,
   emitTaskTerminatedSdk: () => emitTaskTerminatedSdk,
@@ -180400,6 +180553,7 @@ __export(exports_engineCompat, {
   hasForegroundTasks: () => hasForegroundTasks,
   hasMetInitializationThreshold: () => hasMetInitializationThreshold,
   hasMetUpdateThreshold: () => hasMetUpdateThreshold,
+  hasPendingBackgroundAgents: () => hasPendingBackgroundAgents,
   hasPendingNotifications: () => hasPendingNotifications,
   hasSessionMessagesCache: () => hasSessionMessagesCache,
   hasWorkingInProcessTeammates: () => hasWorkingInProcessTeammates,
@@ -180582,6 +180736,7 @@ __export(exports_engineCompat, {
   renderableSearchText: () => renderableSearchText,
   reportAutoCompactCircuitFailures: () => reportAutoCompactCircuitFailures,
   resetAutoCompactCircuitForTesting: () => resetAutoCompactCircuitForTesting,
+  resetBackgroundAgentTracker: () => resetBackgroundAgentTracker,
   resetBuiltinCommandNamesSourceForTesting: () => resetBuiltinCommandNamesSourceForTesting,
   resetCheckInState: () => resetCheckInState,
   resetCommandQueue: () => resetCommandQueue,
@@ -180621,6 +180776,7 @@ __export(exports_engineCompat, {
   roughTokenCountEstimationForContent: () => roughTokenCountEstimationForContent,
   roughTokenCountEstimationForMessages: () => roughTokenCountEstimationForMessages,
   runAgent: () => runAgent,
+  runAsyncAgentLifecycle: () => runAsyncAgentLifecycle,
   runCleanupFunctions: () => runCleanupFunctions2,
   runHooksStream: () => runHooksStream,
   runPostCompactCleanup: () => runPostCompactCleanup,
@@ -180689,6 +180845,7 @@ __export(exports_engineCompat, {
   tokenCountWithEstimation: () => tokenCountWithEstimation,
   toolResultSearchText: () => toolResultSearchText,
   toolUseSearchText: () => toolUseSearchText,
+  trackBackgroundAgent: () => trackBackgroundAgent,
   truncateHeadForPTLRetry: () => truncateHeadForPTLRetry,
   tryAcquireSchedulerLock: () => tryAcquireSchedulerLock,
   tryReactiveCompact: () => tryReactiveCompact,
@@ -180712,6 +180869,7 @@ __export(exports_engineCompat, {
   waitForSessionMemoryExtraction: () => waitForSessionMemoryExtraction,
   waitForTeammatesToBecomeIdle: () => waitForTeammatesToBecomeIdle,
   worktreeBranchName: () => worktreeBranchName,
+  wrapPermissionGateForBackground: () => wrapPermissionGateForBackground,
   writeCronTasks: () => writeCronTasks,
   writeToMailbox: () => writeToMailbox
 });
@@ -275861,7 +276019,7 @@ function extractPartialResult(messages) {
   }
   return;
 }
-async function runAsyncAgentLifecycle({
+async function runAsyncAgentLifecycle2({
   taskId,
   abortController,
   makeStream,
@@ -276188,8 +276346,8 @@ ${whenNotToUseSection}
 Usage notes:
 - Always include a short description (3-5 words) summarizing what the agent will do${concurrencyNote}
 - When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.${!isEnvTruthy2(process.env.ATLAS_DISABLE_BACKGROUND_TASKS) && !isInProcessTeammate3() && !forkEnabled ? `
-- You can optionally run agents in the background using the run_in_background parameter. When an agent runs in the background, you will be automatically notified when it completes — do NOT sleep, poll, or proactively check on its progress. Continue with other work or respond to the user instead.
-- **Foreground vs background**: Use foreground (default) when you need the agent's results before you can proceed — e.g., research agents whose findings inform your next steps. Use background when you have genuinely independent work to do in parallel.` : ""}
+- Agents run in the background by default. When an agent runs in the background, you will be automatically notified when it completes — do NOT sleep, poll, or proactively check on its progress. Continue with other work or respond to the user instead.
+- **Foreground vs background**: Agents run in the background by default. Use foreground (set run_in_background to false) when you need the agent's results before you can proceed — e.g., research agents whose findings inform your next steps. Use background when you have genuinely independent work to do in parallel.` : ""}
 - To continue a previously spawned agent, use ${SEND_MESSAGE_TOOL_NAME3} with the agent's ID or name as the \`to\` field. The agent resumes with its full context preserved. ${forkEnabled ? "Each fresh Agent invocation with a subagent_type starts without context — provide a complete task description." : "Each Agent invocation starts fresh — provide a complete task description."}
 - The agent's outputs should generally be trusted
 - Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.)${forkEnabled ? "" : ", since it is not aware of the user's intent"}
@@ -276214,6 +276372,15 @@ var init_prompt13 = __esm(() => {
 });
 
 // src/tui/tools/AgentTool/AgentTool.ts
+function isAgentBackgroundByDefault2() {
+  return !isEnvTruthy2(process.env.ATLAS_AGENT_DEFAULT_FOREGROUND);
+}
+function shouldRunInBackground2(runInBg) {
+  if (isAgentBackgroundByDefault2()) {
+    return runInBg !== false;
+  }
+  return !!runInBg;
+}
 function resolveAgentDefinition2(subagentType, agents) {
   if (!subagentType)
     return GENERAL_PURPOSE_AGENT2;
@@ -276246,6 +276413,7 @@ var init_AgentTool2 = __esm(() => {
   init_prompt13();
   init_runAgent2();
   init_UI9();
+  init_envUtils2();
   inputSchema13 = lazySchema2(() => object({
     description: string2().describe("A short (3-5 word) description of the task"),
     prompt: string2().describe("The task for the agent to perform"),
@@ -276315,7 +276483,7 @@ var init_AgentTool2 = __esm(() => {
     },
     async call(args, context, canUseTool, parentMessage, onProgress) {
       const agents = getBuiltInAgents2();
-      const isAsync = !!args.run_in_background;
+      const isAsync = shouldRunInBackground2(args.run_in_background);
       const agentId = createAgentId(args.description);
       const parentModel = context && context.options && (context.options.mainLoopModel || context.options.model) || "small";
       logForDebugging3("[AGENT] launching agent, type=" + (args.subagent_type ?? (isForkSubagentEnabled2() ? "fork" : "general-purpose")));
@@ -311132,7 +311300,7 @@ async function resumeAgentBackground({
     invocationEmitted: false
   };
   const wrapWithCwd = (fn) => resumedWorktreePath ? runWithCwdOverride(resumedWorktreePath, fn) : fn();
-  runWithAgentContext(asyncAgentContext, () => wrapWithCwd(() => runAsyncAgentLifecycle({
+  runWithAgentContext(asyncAgentContext, () => wrapWithCwd(() => runAsyncAgentLifecycle2({
     taskId: agentBackgroundTask.agentId,
     abortController: agentBackgroundTask.abortController,
     makeStream: (onCacheSafeParams) => runAgent2({
@@ -321060,6 +321228,10 @@ function buildAgentLoopParams(m) {
       toolUseContext: m.toolUseContext
     }),
     toolContext: m.toolUseContext,
+    hasPendingBackgroundTasks: () => {
+      const tasks = m.toolUseContext?.getAppState?.()?.tasks;
+      return tasks ? hasNonTerminalTasks(tasks) : false;
+    },
     hooks: createLoopHooks({
       options: {
         sessionId: getSessionId(),
@@ -321091,6 +321263,7 @@ function buildAgentLoopParams(m) {
 var init_agentLoopDeps = __esm(() => {
   init_modelprovider2();
   init_engine();
+  init_Task();
   init_settings3();
   init_shared();
   init_bootstrap();
@@ -425283,6 +425456,9 @@ import { randomBytes as randomBytes22 } from "crypto";
 function isTerminalTaskStatus2(status) {
   return status === "completed" || status === "failed" || status === "killed";
 }
+function hasNonTerminalTasks(tasks) {
+  return Object.values(tasks).some((t) => !isTerminalTaskStatus2(t.status));
+}
 function getTaskIdPrefix(type) {
   return TASK_ID_PREFIXES[type] ?? "x";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlasharness/atlascode",
-  "version": "0.1.64",
+  "version": "0.1.66",
   "description": "AtlasCode \u2014 Coding Agent for the domestic computing ecosystem (Ascend NPU + domestic LLM backends)",
   "bin": {
     "atlas": "dist/cli.js",