@astroanywhere/agent 0.4.0 → 0.4.2

package/dist/lib/task-executor.js

@@ -16,7 +16,7 @@ import { SlurmJobMonitor } from './slurm-job-monitor.js';
 import { createWorktree, syncProjectWorktree } from './worktree.js';
 import { ensureProjectWorkspace } from './workspace-root.js';
 import { BranchLockManager } from './branch-lock.js';
-import { pushAndCreatePR, mergePullRequest, getRemoteBranchSha, isGhAvailable } from './git-pr.js';
+import { pushAndCreatePR, mergePullRequest, getRemoteBranchSha, isGhAvailable, getRepoSlug } from './git-pr.js';
 import { localMergeIntoProjectBranch } from './local-merge.js';
 import { checkWorkdirSafety, isGitAvailable, isGitRepo, isUntrackedInParentRepo, createSandbox, WorkdirSafetyTier, } from './workdir-safety.js';
 import { initializeGit } from './git-bootstrap.js';
@@ -94,22 +94,45 @@ After you force-push, I will automatically retry the GitHub merge.`;
  * existing merge retry loop handles real conflicts.
  */
 async function tryPreMergeRebase(workdir, targetBranch, isRemote) {
+    // `git rebase` always operates on the currently checked-out branch (HEAD).
+    // It cannot rebase a detached branch ref. When the worktree is gone, HEAD
+    // in gitRoot is the user's main checkout (e.g., main) — NOT the task branch.
+    // Rebasing from gitRoot would corrupt the user's working directory.
+    // Skip the rebase entirely; the merge/PR flow handles conflicts anyway.
+    //
+    // Best-effort check — worktree could still be deleted after this (TOCTOU),
+    // but the git commands will fail safely and be caught by the outer catch.
+    try {
+        statSync(workdir);
+    }
+    catch {
+        console.log(`[git] Worktree at ${workdir} gone — skipping rebase (cannot rebase non-checked-out branch)`);
+        return { rebased: false, skipped: true };
+    }
     try {
         const rebaseTarget = isRemote ? `origin/${targetBranch}` : targetBranch;
+        const gitEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0' };
         if (isRemote) {
-            await execFileAsync('git', ['fetch', 'origin', targetBranch], { cwd: workdir, timeout: 30_000 });
+            console.log(`[git] fetch origin ${targetBranch} (cwd: ${workdir})`);
+            await execFileAsync('git', ['fetch', 'origin', targetBranch], { cwd: workdir, env: gitEnv, timeout: 30_000 });
         }
         // Check if rebase is needed (target branch moved since we branched)
-        const { stdout: mergeBase } = await execFileAsync('git', ['merge-base', 'HEAD', rebaseTarget], { cwd: workdir });
-        const { stdout: targetTip } = await execFileAsync('git', ['rev-parse', rebaseTarget], { cwd: workdir });
+        console.log(`[git] merge-base HEAD ${rebaseTarget} (cwd: ${workdir})`);
+        const { stdout: mergeBase } = await execFileAsync('git', ['merge-base', 'HEAD', rebaseTarget], { cwd: workdir, env: gitEnv });
+        const { stdout: targetTip } = await execFileAsync('git', ['rev-parse', rebaseTarget], { cwd: workdir, env: gitEnv });
         if (mergeBase.trim() === targetTip.trim()) {
-            return { rebased: false, skipped: true }; // Already up to date
+            console.log(`[git] Already up to date (merge-base = target tip: ${targetTip.trim().slice(0, 7)})`);
+            return { rebased: false, skipped: true };
         }
         // Try automatic rebase — timeout after 60s (should be fast for non-conflicting changes)
-        await execFileAsync('git', ['rebase', rebaseTarget], { cwd: workdir, timeout: 60_000 });
+        console.log(`[git] rebase ${rebaseTarget} (cwd: ${workdir})`);
+        await execFileAsync('git', ['rebase', rebaseTarget], { cwd: workdir, env: gitEnv, timeout: 60_000 });
+        console.log(`[git] Rebase onto ${rebaseTarget} succeeded`);
         return { rebased: true };
     }
-    catch {
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[git] Rebase onto ${targetBranch} failed: ${msg}`);
         // Abort on failure — existing retry loop will handle conflicts
         await execFileAsync('git', ['rebase', '--abort'], { cwd: workdir }).catch(() => { });
         return { rebased: false };
@@ -214,12 +237,15 @@ export class TaskExecutor {
         }
         this.claimedTasks.add(task.id);
         try {
-            // Skip workingDirectory resolution for lightweight text-only tasks (no file system access)
-            const isTextOnlyTask = task.type === 'summarize' || task.type === 'chat' || task.type === 'plan';
-            // Text-only tasks (plan/chat/summarize) can run without a working directory.
-            // For all others, resolve the directory or auto-provision one.
+            // Only execution tasks need workingDirectory resolution, safety checks,
+            // git diff, and summary generation. All other types (plan/chat/summarize/
+            // playground) skip this overhead but still get full tool access when they
+            // have a working directory.
+            const isExecutionTask = !task.type || task.type === 'execution';
+            // Non-execution tasks can run without a working directory.
+            // For execution tasks, resolve the directory or auto-provision one.
             let resolvedWorkDir;
-            if (isTextOnlyTask && !task.workingDirectory) {
+            if (!isExecutionTask && !task.workingDirectory) {
                 resolvedWorkDir = undefined;
             }
             else {
@@ -251,14 +277,14 @@ export class TaskExecutor {
             // thinks worktree isolation is active and allows parallel execution, but
             // prepareTaskWorkspace() later falls back to direct in-place execution —
             // causing file conflicts when multiple tasks run on the same non-git directory.
-            const isGitDir = !isTextOnlyTask && normalizedTask.workingDirectory && this.gitAvailable
+            const isGitDir = isExecutionTask && normalizedTask.workingDirectory && this.gitAvailable
                 ? await isGitRepo(normalizedTask.workingDirectory)
                 : false;
             const willUseWorktree = this.useWorktree
                 && normalizedTask.useWorktree !== false
                 && normalizedTask.deliveryMode !== 'direct'
                 && (isGitDir || normalizedTask.deliveryMode === 'copy');
-            if (!isTextOnlyTask && task.skipSafetyCheck) {
+            if (isExecutionTask && task.skipSafetyCheck) {
                 // Server already approved safety for this directory — skip the prompt.
                 // Only init git when the original safety decision was 'init-git'.
                 // When safetyDecision is 'proceed' (user chose non-git direct execution)
@@ -279,7 +305,7 @@ export class TaskExecutor {
                 }
                 return;
             }
-            if (!isTextOnlyTask) {
+            if (isExecutionTask) {
                 // Perform safety check (worktree flag affects tier assignment)
                 const safetyCheck = await this.performSafetyCheck(normalizedTask, willUseWorktree);
                 // Handle safety tiers
@@ -571,11 +597,14 @@ export class TaskExecutor {
             text: (data) => {
                 this.wsClient.sendTaskText(taskId, data, textSequence++);
             },
-            toolUse: (toolName, toolInput) => {
-                this.wsClient.sendTaskToolUse(taskId, toolName, toolInput);
+            operational: (message, source) => {
+                this.wsClient.sendTaskOperational(taskId, message, source);
+            },
+            toolUse: (toolName, toolInput, toolUseId) => {
+                this.wsClient.sendTaskToolUse(taskId, toolName, toolInput, toolUseId);
             },
-            toolResult: (toolName, result, success) => {
-                this.wsClient.sendTaskToolResult(taskId, toolName, result, success);
+            toolResult: (toolName, result, success, toolUseId) => {
+                this.wsClient.sendTaskToolResult(taskId, toolName, result, success, toolUseId);
             },
             fileChange: (path, action, linesAdded, linesRemoved, diff) => {
                 this.wsClient.sendTaskFileChange(taskId, path, action, linesAdded, linesRemoved, diff);
@@ -607,6 +636,7 @@ export class TaskExecutor {
                         projectBranch: meta.projectBranch,
                         stdout: stream.stdout,
                         stderr: stream.stderr,
+                        operational: stream.operational,
                     });
                     if (worktree) {
                         resumeDir = worktree.workingDirectory;
@@ -902,13 +932,17 @@ export class TaskExecutor {
                 resetIdleTimeout();
                 this.wsClient.sendTaskText(normalizedTask.id, data, textSequence++);
             },
-            toolUse: (toolName, toolInput) => {
+            operational: (message, source) => {
+                resetIdleTimeout();
+                this.wsClient.sendTaskOperational(normalizedTask.id, message, source);
+            },
+            toolUse: (toolName, toolInput, toolUseId) => {
                 resetIdleTimeout();
-                this.wsClient.sendTaskToolUse(normalizedTask.id, toolName, toolInput);
+                this.wsClient.sendTaskToolUse(normalizedTask.id, toolName, toolInput, toolUseId);
             },
-            toolResult: (toolName, result, success) => {
+            toolResult: (toolName, result, success, toolUseId) => {
                 resetIdleTimeout();
-                this.wsClient.sendTaskToolResult(normalizedTask.id, toolName, result, success);
+                this.wsClient.sendTaskToolResult(normalizedTask.id, toolName, result, success, toolUseId);
             },
             fileChange: (path, action, linesAdded, linesRemoved, diff) => {
                 resetIdleTimeout();
@@ -947,20 +981,22 @@ export class TaskExecutor {
         // 30s aligns with the server's heartbeat check interval and is well under
         // the 3-minute startup timeout (STARTUP_TIMEOUT_MS in dispatch.ts).
         const TASK_HEARTBEAT_INTERVAL_MS = 30_000;
-        let taskHeartbeatPhase = 'preparing';
         let heartbeatSeq = 0;
         const taskHeartbeatTimer = setInterval(() => {
             // Send directly via wsClient to keep the server's activity timer alive
             // WITHOUT resetting the agent-side idle timeout. stream.text() calls
             // resetIdleTimeout(), which would make a hung agent run until hard cap
             // instead of idle-timing out after 15 minutes of no real activity.
-            this.wsClient.sendTaskText(normalizedTask.id, `[Astro] Heartbeat — ${taskHeartbeatPhase}...\n`, -(++heartbeatSeq));
+            // Heartbeat text is intentionally empty — it exists only to keep the
+            // server's activity timer alive, not to display anything to the user.
+            this.wsClient.sendTaskText(normalizedTask.id, '', -(++heartbeatSeq));
         }, TASK_HEARTBEAT_INTERVAL_MS);
-        // Text-only tasks (plan/chat/summarize) without a working directory skip workspace prep
-        const isTextOnly = normalizedTask.type === 'summarize' || normalizedTask.type === 'chat' || normalizedTask.type === 'plan';
+        // Only execution tasks get git diff, delivery, and summary — all other types (chat, plan, playground, summarize) skip them.
+        // These non-execution types still get full tool access when they have a working directory.
+        const isExecutionTask = !normalizedTask.type || normalizedTask.type === 'execution';
         let prepared;
         try {
-            prepared = isTextOnly && !normalizedTask.workingDirectory
+            prepared = !isExecutionTask && !normalizedTask.workingDirectory
                 ? { workingDirectory: '', cleanup: async () => { } }
                 : await this.prepareTaskWorkspace(normalizedTask, stream, abortController.signal);
         }
@@ -975,7 +1011,6 @@ export class TaskExecutor {
         }
         const taskWithWorkspace = { ...normalizedTask, workingDirectory: prepared.workingDirectory };
         runningTask.task = taskWithWorkspace;
-        taskHeartbeatPhase = 'executing';
         console.log(`[executor] Task ${task.id}: workspace prepared, cwd=${prepared.workingDirectory}`);
         // Execute with idle timeout + hard cap.
         // Idle timeout resets on every stream activity (text, tool, file, etc.).
@@ -999,7 +1034,7 @@ export class TaskExecutor {
             // Resume existing session if resumeSessionId is provided
             const canResume = taskWithWorkspace.resumeSessionId
                 && this.isResumableAdapter(adapter)
-                && isTextOnly;
+                && !isExecutionTask;
             let result;
             if (canResume) {
                 console.log(`[executor] Task ${task.id}: resuming session ${taskWithWorkspace.resumeSessionId} with ${adapter.name} (type=${adapter.type}, hasMessages=${!!taskWithWorkspace.messages?.length})...`);
@@ -1052,7 +1087,7 @@ export class TaskExecutor {
                 });
             }
             // Emit accurate file change events via git diff (covers all change methods)
-            if (!isTextOnly && prepared.workingDirectory) {
+            if (isExecutionTask && prepared.workingDirectory) {
                 await this.emitGitDiffFileChanges(task.id, prepared.workingDirectory, prepared.commitBeforeSha, stream);
             }
             // Delivery-mode-aware result handling
@@ -1070,7 +1105,7 @@ export class TaskExecutor {
             if (summary) {
                 console.log(`[executor] Task ${task.id}: summary available — status=${summary.status}, workCompleted=${!!summary.workCompleted}, executiveSummary=${!!summary.executiveSummary}, keyFindings=${summary.keyFindings?.length ?? 0}, filesChanged=${summary.filesChanged?.length ?? 0}`);
             }
-            else if (!isTextOnly) {
+            else if (isExecutionTask) {
                 console.warn(`[executor] Task ${task.id}: no summary available for PR body`);
             }
             const rawTitle = summary?.workCompleted || task.title || task.prompt.slice(0, 100);
@@ -1078,9 +1113,12 @@ export class TaskExecutor {
                 ? `[${task.shortProjectId}/${task.shortNodeId}] ${rawTitle}`
                 : rawTitle;
             if (prepared.branchName && result.status === 'completed') {
-                taskHeartbeatPhase = 'delivering';
-                stream.text?.(`\n[Astro] Delivering changes (mode: ${deliveryMode})...\n`);
+                stream.operational?.(`Delivering changes (mode: ${deliveryMode})...`, 'astro');
                 this.wsClient.sendTaskStatus(task.id, 'running', 90, 'Delivering changes...');
+                // Resolve GitHub repo slug (OWNER/REPO) for explicit gh --repo targeting.
+                // This makes gh pr create/merge independent of local filesystem state
+                // (worktree may be cleaned up by the agent during execution).
+                const repoSlug = prepared.gitRoot ? await getRepoSlug(prepared.gitRoot) : undefined;
                 // Build PR body: enrich with summary data when available
                 const prBodyParts = [];
                 if (summary) {
@@ -1113,14 +1151,16 @@ export class TaskExecutor {
                 try {
                     if (deliveryMode === 'direct') {
                         // No git delivery — files modified in-place
+                        stream.operational?.('Changes applied in-place (direct mode)', 'delivery');
                         console.log(`[executor] Task ${task.id}: direct mode, skipping git delivery`);
                     }
                     else if (deliveryMode === 'copy') {
                         // Copy mode: worktree preserved, no git operations
+                        stream.operational?.('Worktree preserved (copy mode)', 'delivery');
                         console.log(`[executor] Task ${task.id}: copy mode, worktree preserved at ${prepared.workingDirectory}`);
                     }
                     else if (deliveryMode === 'branch') {
-                        stream.text?.(`[Astro] Merging into project branch ${prepared.projectBranch ?? 'local'}...\n`);
+                        stream.operational?.(`Merging into project branch ${prepared.projectBranch ?? 'local'}...`, 'git');
                         // Branch mode: commit locally, merge into project branch if available.
                         // The merge lock is held only during the squash-merge (seconds, not minutes),
                         // allowing tasks to execute in parallel. The squash merge naturally handles
@@ -1138,9 +1178,11 @@ export class TaskExecutor {
                             // don't overlap, and saves one retry cycle when they do.
                             const preRebase = await tryPreMergeRebase(prepared.workingDirectory, prepared.projectBranch, false);
                             if (preRebase.rebased) {
+                                stream.operational?.(`Rebased onto ${prepared.projectBranch}`, 'git');
                                 console.log(`[executor] Task ${task.id}: pre-merge rebase onto ${prepared.projectBranch} succeeded`);
                             }
                             else if (!preRebase.skipped) {
+                                stream.operational?.('Rebase skipped (conflicts), retrying via merge', 'git');
                                 console.log(`[executor] Task ${task.id}: pre-merge rebase had conflicts, falling back to merge retry loop`);
                             }
                             const mergeLockKey = BranchLockManager.computeLockKey(prepared.gitRoot, task.shortProjectId, task.shortNodeId, task.id);
@@ -1153,7 +1195,7 @@ export class TaskExecutor {
                                 let mergeResult;
                                 try {
                                     this.wsClient.sendTaskStatus(task.id, 'running', 96, 'Merging into project branch...');
-                                    mergeResult = await localMergeIntoProjectBranch(prepared.gitRoot, prepared.branchName, prepared.projectBranch, commitMessage);
+                                    mergeResult = await localMergeIntoProjectBranch(prepared.gitRoot, prepared.branchName, prepared.projectBranch, commitMessage, (msg) => stream.operational?.(msg, 'git'));
                                 }
                                 finally {
                                     mergeLock.release();
@@ -1162,7 +1204,7 @@ export class TaskExecutor {
                                 if (mergeResult.merged) {
                                     result.deliveryStatus = 'success';
                                     result.commitAfterSha = mergeResult.commitSha;
-                                    stream.text?.(`[Astro] Merged into ${prepared.projectBranch} (${mergeResult.commitSha?.slice(0, 7)})\n`);
+                                    stream.operational?.(`Merged into ${prepared.projectBranch} (${mergeResult.commitSha?.slice(0, 7)})`, 'git');
                                     console.log(`[executor] Task ${task.id}: merged into ${prepared.projectBranch} (${mergeResult.commitSha})`);
                                     // Sync project worktree to reflect the merged changes on disk
                                     if (prepared.projectWorktreePath && prepared.projectBranch && prepared.gitRoot) {
@@ -1178,7 +1220,7 @@ export class TaskExecutor {
                                         : null;
                                     if (taskContext?.sessionId && this.isResumableAdapter(adapter) && attempt < MAX_MERGE_ATTEMPTS) {
                                         const conflictFiles = mergeResult.conflictFiles?.join(', ') ?? 'unknown files';
-                                        stream.text?.(`[Astro] Merge conflict in: ${conflictFiles} — agent resolving (attempt ${attempt})...\n`);
+                                        stream.operational?.(`Merge conflict: ${conflictFiles} — agent resolving (attempt ${attempt})...`, 'git');
                                         console.log(`[executor] Task ${task.id}: merge conflict (attempt ${attempt}), resuming ${adapter.name} to resolve: ${conflictFiles}`);
                                         this.wsClient.sendTaskStatus(task.id, 'running', 97, `Merge conflict — agent resolving (attempt ${attempt})...`);
                                         // Resume agent session with conflict resolution instructions.
@@ -1227,7 +1269,7 @@ export class TaskExecutor {
                     }
                     else if (deliveryMode === 'push') {
                         // Push branch to remote, but don't create a PR — user creates PR manually
-                        stream.text?.(`[Astro] Pushing branch ${prepared.branchName} to origin...\n`);
+                        stream.operational?.(`Pushing ${prepared.branchName} to origin...`, 'git');
                         this.wsClient.sendTaskStatus(task.id, 'running', 95, 'Pushing branch...');
                         console.log(`[executor] Task ${task.id}: push mode, pushing branch ${prepared.branchName}`);
                         const prResult = await pushAndCreatePR(prepared.workingDirectory, {
@@ -1236,30 +1278,31 @@ export class TaskExecutor {
                             taskDescription: task.description || task.prompt.slice(0, 500),
                             skipPR: true,
                             baseBranch: prepared.baseBranch,
+                            gitRoot: prepared.gitRoot,
                         });
                         result.branchName = prResult.branchName;
                         if (prResult.error) {
                             // Delivery failure — don't override execution status
                             result.deliveryStatus = 'failed';
                             result.deliveryError = `Push delivery failed: ${prResult.error}`;
-                            stream.text?.(`[Astro] Push failed: ${prResult.error}\n`);
+                            stream.operational?.(`Push failed: ${prResult.error}`, 'git');
                             console.error(`[executor] Task ${task.id}: push delivery failed: ${prResult.error}`);
                         }
                         else if (prResult.pushed) {
                             result.deliveryStatus = 'success';
                             keepBranch = true;
-                            stream.text?.(`[Astro] Branch pushed to origin: ${prepared.branchName}\n`);
+                            stream.operational?.(`Pushed to origin: ${prepared.branchName}`, 'git');
                             console.log(`[executor] Task ${task.id}: branch pushed (${prepared.branchName})`);
                         }
                         else {
                             result.deliveryStatus = 'skipped';
-                            stream.text?.(`[Astro] No changes to push\n`);
+                            stream.operational?.('No changes to push', 'git');
                             console.log(`[executor] Task ${task.id}: no changes to push`);
                         }
                     }
                     else {
                         // 'pr' — push + create PR, auto-merge into project branch if applicable
-                        stream.text?.(`[Astro] Creating pull request for branch ${prepared.branchName}...\n`);
+                        stream.operational?.(`Creating PR: ${prepared.branchName} → ${prepared.baseBranch ?? 'main'}...`, 'git');
                         this.wsClient.sendTaskStatus(task.id, 'running', 94, 'Rebasing before push...');
                         // Pre-push rebase: if the target branch moved forward, rebase our task
                         // branch so the PR will be cleanly mergeable. The branch hasn't been
@@ -1267,9 +1310,11 @@ export class TaskExecutor {
                         if (prepared.baseBranch) {
                             const preRebase = await tryPreMergeRebase(prepared.workingDirectory, prepared.baseBranch, true);
                             if (preRebase.rebased) {
+                                stream.operational?.(`Rebased onto origin/${prepared.baseBranch}`, 'git');
                                 console.log(`[executor] Task ${task.id}: pre-push rebase onto origin/${prepared.baseBranch} succeeded`);
                             }
                             else if (!preRebase.skipped) {
+                                stream.operational?.('Rebase skipped (conflicts), proceeding without rebase', 'git');
                                 console.log(`[executor] Task ${task.id}: pre-push rebase had conflicts, proceeding without rebase`);
                             }
                         }
@@ -1284,6 +1329,7 @@ export class TaskExecutor {
                             baseBranch: prepared.baseBranch,
                             autoMerge: hasProjectBranch,
                             commitBeforeSha: prepared.commitBeforeSha,
+                            gitRoot: prepared.gitRoot,
                         });
                         result.branchName = prResult.branchName;
                         if (prResult.prUrl) {
@@ -1292,7 +1338,7 @@ export class TaskExecutor {
                             result.commitBeforeSha = prResult.commitBeforeSha;
                             result.commitAfterSha = prResult.commitAfterSha;
                             keepBranch = true;
-                            stream.text?.(`[Astro] Pull request created: ${prResult.prUrl}\n`);
+                            stream.operational?.(`PR created: ${prResult.prUrl}`, 'git');
                             if (prResult.autoMergeFailed) {
                                 // PR was created but auto-merge failed (likely conflict).
                                 // If the adapter supports session resume, ask the agent to
@@ -1304,7 +1350,7 @@ export class TaskExecutor {
                                     : null;
                                 if (prTaskContext?.sessionId && this.isResumableAdapter(adapter) && hasProjectBranch && prepared.branchName && prepared.baseBranch && prResult.prNumber && prepared.gitRoot) {
                                     for (let attempt = 1; attempt <= MAX_PR_MERGE_ATTEMPTS; attempt++) {
-                                        stream.text?.(`[Astro] PR auto-merge failed — agent resolving conflict (attempt ${attempt})...\n`);
+                                        stream.operational?.(`Auto-merge failed — agent resolving conflict (attempt ${attempt})...`, 'git');
                                         console.log(`[executor] Task ${task.id}: PR auto-merge failed (attempt ${attempt}), resuming ${adapter.name} to resolve`);
                                         this.wsClient.sendTaskStatus(task.id, 'running', 97, `PR merge conflict — agent resolving (attempt ${attempt})...`);
                                         // Resume agent session — agent rebases and force-pushes.
@@ -1318,11 +1364,14 @@ export class TaskExecutor {
                                             result.deliveryError = `PR created but auto-merge failed. Agent resolution failed: ${resumeErr instanceof Error ? resumeErr.message : resumeErr}`;
                                             break;
                                         }
-                                        // Retry the GitHub merge
+                                        // Retry the GitHub merge.
+                                        // Use gitRoot as cwd (always valid, guarded at L1518) instead of
+                                        // worktree path which may have been deleted during resolution.
                                         this.wsClient.sendTaskStatus(task.id, 'running', 98, `Retrying PR merge (attempt ${attempt})...`);
-                                        const retryMerge = await mergePullRequest(prepared.workingDirectory, prResult.prNumber, {
+                                        const retryMerge = await mergePullRequest(prepared.gitRoot, prResult.prNumber, {
                                             method: 'squash',
                                             deleteBranch: true,
+                                            repoSlug: repoSlug ?? undefined,
                                         });
                                         if (retryMerge.ok) {
                                             result.commitAfterSha = await getRemoteBranchSha(prepared.gitRoot, prepared.baseBranch) ?? undefined;
@@ -1362,18 +1411,18 @@ export class TaskExecutor {
                             result.deliveryStatus = 'failed';
                             result.deliveryError = `PR delivery failed: ${prResult.error}`;
                             keepBranch = prResult.pushed ?? false; // Keep branch if it was pushed
-                            stream.text?.(`[Astro] PR delivery failed: ${prResult.error}\n`);
+                            stream.operational?.(`PR delivery failed: ${prResult.error}`, 'git');
                             console.error(`[executor] Task ${task.id}: PR delivery failed: ${prResult.error}`);
                         }
                         else {
-                            stream.text?.(`[Astro] No changes to deliver\n`);
+                            stream.operational?.('No changes to deliver', 'git');
                             console.log(`[executor] Task ${task.id}: no changes to push`);
                         }
                     }
                 }
                 catch (prError) {
                     const prMsg = prError instanceof Error ? prError.message : String(prError);
-                    stream.text?.(`[Astro] Delivery failed: ${prMsg}\n`);
+                    stream.operational?.(`Failed: ${prMsg}`, 'delivery');
                     console.error(`[executor] Task ${task.id}: delivery (${deliveryMode}) failed: ${prMsg}`);
                     // Delivery failure — don't override execution status
                     result.deliveryStatus = 'failed';
@@ -1430,14 +1479,13 @@ export class TaskExecutor {
             clearTimeout(hardCapTimeoutId);
             if (idleTimerId !== undefined)
                 clearTimeout(idleTimerId);
-            taskHeartbeatPhase = 'cleaning up';
             // Always cleanup the local worktree directory to reclaim disk space
             // (node_modules alone is ~680MB per worktree). When keepBranch is true
             // (PR created or branch pushed), we preserve the git branch but still
             // remove the working copy — the branch lives on remote/local refs,
             // and re-execution will create a fresh worktree if needed.
             if (prepared.branchName) {
-                stream.text?.(`\n[Astro] Cleaning up worktree (branch: ${prepared.branchName})...\n`);
+                stream.operational?.(`Cleaning up worktree (branch: ${prepared.branchName})...`, 'astro');
             }
             if (this.preserveWorktrees) {
                 console.log(`[executor] Task ${task.id}: worktree preserved (debug mode)`);
@@ -1596,7 +1644,7 @@ export class TaskExecutor {
                 projectBranch: task.projectBranch,
                 stdout: stream.stdout,
                 stderr: stream.stderr,
-                text: stream.text,
+                operational: stream.operational,
                 signal,
             });
             if (!worktree) {