Show desktop harness progress

chenbo · chenbo · commit a148338cfad5 · 2026-06-21T19:19:04.000+08:00
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
@@ -31,6 +31,9 @@ interface LatestReportSummary {
 let mainWindow: BrowserWindow | undefined;
 let currentTask: ChildProcess | undefined;
 let currentRepo: string | undefined;
+let currentTaskHeartbeat: NodeJS.Timeout | undefined;
+let currentTaskStartedAt = 0;
+let currentTaskLastOutputAt = 0;
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -81,26 +84,37 @@ function registerIpc(): void {
     const command = commandName();
     const args = ["oc", "run", "--repo", repo, "--max-loops", "2", "--stream-executor", "--", task];
     currentRepo = repo;
+    currentTaskStartedAt = Date.now();
+    currentTaskLastOutputAt = currentTaskStartedAt;
     currentTask = spawn(command, args, {
       cwd: repo,
       env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
       shell: process.platform === "win32",
       windowsHide: true
     });
 
     mainWindow?.webContents.send("task:output", { stream: "system", text: `Starting: ${formatCommand(command, args)}\n` });
+    mainWindow?.webContents.send("task:output", {
+      stream: "system",
+      text: `Process started with PID ${currentTask.pid ?? "unknown"}. Waiting for harness progress and OpenCode output...\n`
+    });
+    startTaskHeartbeat();
 
     currentTask.stdout?.on("data", (chunk: Buffer) => {
+      currentTaskLastOutputAt = Date.now();
       mainWindow?.webContents.send("task:output", { stream: "stdout", text: chunk.toString("utf8") });
     });
 
     currentTask.stderr?.on("data", (chunk: Buffer) => {
+      currentTaskLastOutputAt = Date.now();
       mainWindow?.webContents.send("task:output", { stream: "stderr", text: chunk.toString("utf8") });
     });
 
     let finished = false;
     currentTask.once("error", (error) => {
       finished = true;
+      stopTaskHeartbeat();
       currentTask = undefined;
       mainWindow?.webContents.send("task:output", { stream: "stderr", text: `${error.message}\n` });
       mainWindow?.webContents.send("task:exit", {
@@ -113,6 +127,7 @@ function registerIpc(): void {
     currentTask.once("close", (code, signal) => {
       if (finished) return;
       finished = true;
+      stopTaskHeartbeat();
       const summary = currentRepo ? findLatestReportSummary(currentRepo) : {};
       currentTask = undefined;
       mainWindow?.webContents.send("task:exit", {
@@ -131,6 +146,7 @@ function registerIpc(): void {
   ipcMain.handle("task:stop", async () => {
     if (!currentTask) return { stopped: false };
     const pid = currentTask.pid;
+    mainWindow?.webContents.send("task:output", { stream: "system", text: `Stopping task PID ${pid ?? "unknown"}...\n` });
     if (process.platform === "win32" && pid) {
       spawn("taskkill", ["/pid", String(pid), "/t", "/f"], { windowsHide: true });
     } else {
@@ -151,6 +167,30 @@ function registerIpc(): void {
   });
 }
 
+function startTaskHeartbeat(): void {
+  stopTaskHeartbeat();
+  currentTaskHeartbeat = setInterval(() => {
+    if (!currentTask) {
+      stopTaskHeartbeat();
+      return;
+    }
+    const now = Date.now();
+    const silenceMs = now - currentTaskLastOutputAt;
+    if (silenceMs < 8000) return;
+    mainWindow?.webContents.send("task:output", {
+      stream: "system",
+      text: `Still running (${formatDuration(now - currentTaskStartedAt)} elapsed, no output for ${formatDuration(silenceMs)}). Waiting for harness/OpenCode output...\n`
+    });
+    currentTaskLastOutputAt = now;
+  }, 8000);
+}
+
+function stopTaskHeartbeat(): void {
+  if (!currentTaskHeartbeat) return;
+  clearInterval(currentTaskHeartbeat);
+  currentTaskHeartbeat = undefined;
+}
+
 function findLatestReport(repo: string): string | undefined {
   return findLatestReportSummary(repo).reportPath;
 }
@@ -207,6 +247,13 @@ function quoteArg(value: string): string {
   return /[\s"]/u.test(value) ? `"${value.replaceAll('"', '\\"').replaceAll("\n", "\\n")}"` : value;
 }
 
+function formatDuration(milliseconds: number): string {
+  const totalSeconds = Math.max(0, Math.floor(milliseconds / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
 registerIpc();
 
 app
diff --git a/apps/desktop/src/renderer/src/App.tsx b/apps/desktop/src/renderer/src/App.tsx
@@ -15,6 +15,8 @@ function App() {
   const [status, setStatus] = useState("Select a repository and describe the coding task.");
   const [reportPath, setReportPath] = useState<string | undefined>();
   const [logs, setLogs] = useState<LogEntry[]>([]);
+  const [runStartedAt, setRunStartedAt] = useState<number | undefined>();
+  const [now, setNow] = useState(Date.now());
   const nextLogId = useRef(1);
   const logEndRef = useRef<HTMLSpanElement | null>(null);
   const bridge = window.openCodePlusPlus;
@@ -26,6 +28,7 @@ function App() {
     });
     const offExit = bridge.onTaskExit((event) => {
       setRunning(false);
+      setRunStartedAt(undefined);
       setReportPath(event.reportPath);
       if (event.error) {
         appendLog("stderr", `${event.error}\n`);
@@ -58,6 +61,12 @@ function App() {
     logEndRef.current?.scrollIntoView({ behavior: "smooth", block: "end" });
   }, [logs]);
 
+  useEffect(() => {
+    if (!running) return;
+    const timer = window.setInterval(() => setNow(Date.now()), 1000);
+    return () => window.clearInterval(timer);
+  }, [running]);
+
   const commandPreview = useMemo(() => {
     const normalizedTask = normalizeTaskForCli(task);
     if (!repo || !normalizedTask) return 'opencode-plusplus.cmd oc run --repo "<repo>" --max-loops 2 --stream-executor -- "<task>"';
@@ -97,12 +106,15 @@ function App() {
     setLogs([]);
     setReportPath(undefined);
     setRunning(true);
+    setRunStartedAt(Date.now());
+    setNow(Date.now());
     setStatus("Starting task...");
     appendLog("system", "Starting task...\n");
     try {
       const result = await bridge.runTask({ repo, task });
       if (result.error) {
         setRunning(false);
+        setRunStartedAt(undefined);
         appendLog("stderr", `${result.error}\n`);
         setStatus(result.error);
         return;
@@ -111,6 +123,7 @@ function App() {
       appendLog("system", `$ ${result.command} ${(result.args ?? []).map(quoteArg).join(" ")}\n\n`);
     } catch (error) {
       setRunning(false);
+      setRunStartedAt(undefined);
       const message = error instanceof Error ? error.message : String(error);
       appendLog("stderr", `${message}\n`);
       setStatus(`Task failed to start: ${message}`);
@@ -142,7 +155,7 @@ function App() {
           <p className="eyebrow">OpenCode++ Desktop MVP</p>
           <h1>Harness-led tasks without embedding the OpenCode TUI</h1>
         </div>
-        <div className={`status ${running ? "running" : ""}`}>{running ? "Running" : "Idle"}</div>
+        <div className={`status ${running ? "running" : ""}`}>{running ? `Running ${formatElapsed(now - (runStartedAt ?? now))}` : "Idle"}</div>
       </section>
 
       <section className="controls">
@@ -221,4 +234,11 @@ function normalizeTaskForCli(task: string): string {
   return task.trim().replace(/\s+/gu, " ").replaceAll('"', "'");
 }
 
+function formatElapsed(milliseconds: number): string {
+  const totalSeconds = Math.max(0, Math.floor(milliseconds / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
 createRoot(document.getElementById("root") as HTMLElement).render(<App />);
diff --git a/docs/desktop.md b/docs/desktop.md
@@ -26,6 +26,7 @@ OpenCode++ remains the harness. The desktop app only gives users a visual contro
 - Enter a task in a desktop form.
 - Run `opencode-plusplus.cmd oc run --repo "<repo>" --max-loops 2 --stream-executor -- "<task>"`.
 - Stream stdout and stderr in real time.
+- Show a running heartbeat when the harness or OpenCode is still alive but has not emitted output yet.
 - Stop the current task.
 - Open the latest `.agent-context/orchestrator/<task-id>/orchestrator.md` report.
 
diff --git a/src/cli/commands/opencode.ts b/src/cli/commands/opencode.ts
@@ -194,6 +194,12 @@ async function runOpencodePreset(args: string[], options: OpencodeRunCliOptions)
             const target = event.stream === "stderr" ? process.stderr : process.stdout;
             target.write(event.text);
           }
+        : undefined,
+    onProgress:
+      options.streamExecutor && !options.json
+        ? (event) => {
+            process.stdout.write(`[OpenCode++ ${event.phase}${event.loop ? `:${event.loop}` : ""}] ${event.message}\n`);
+          }
         : undefined
   });
   console.log(
diff --git a/src/harness/control-plane/orchestrator.ts b/src/harness/control-plane/orchestrator.ts
@@ -49,6 +49,14 @@ export interface HarnessOrchestratorOptions {
   checkpoint?: OrchestratorCheckpointMode;
   opencodeTranscript?: string;
   onExecutorOutput?: (event: { stream: "stdout" | "stderr"; text: string }) => void;
+  onProgress?: (event: HarnessProgressEvent) => void;
+}
+
+export interface HarnessProgressEvent {
+  at: string;
+  phase: "context" | "plan" | "sandbox" | "execute" | "collect" | "evaluate" | "decision" | "write";
+  message: string;
+  loop?: number;
 }
 
 export interface AgentExecutorInput {
@@ -65,6 +73,7 @@ export interface AgentExecutorInput {
   executorCommand?: string;
   dryRun?: boolean;
   onExecutorOutput?: (event: { stream: "stdout" | "stderr"; text: string }) => void;
+  onProgress?: (event: HarnessProgressEvent) => void;
 }
 
 export interface AgentExecutorResult {
@@ -171,21 +180,29 @@ export async function runHarnessOrchestrator(repo: string, task: string, options
   const executorName = options.executor ?? "mock";
   const maxLoops = Math.max(1, options.maxLoops ?? 1);
   const root = path.resolve(repo);
+  const progress = (phase: HarnessProgressEvent["phase"], message: string, loop?: number) => {
+    options.onProgress?.({ at: new Date().toISOString(), phase, message, loop });
+  };
 
+  progress("context", `building repository context for ${root}`);
   const preContext = await buildContextPackage(root);
+  progress("context", "writing context package");
   const contextWrite = writeContextPackage(preContext);
   const executor = createAgentExecutor(executorName);
+  progress("plan", "writing task run and edit boundary");
   const taskRun = writeTaskRun(preContext, task, { base, type: options.type ?? "auto", tokenBudget: options.tokenBudget, preserveTrace: true });
   const dir = path.join(root, ".agent-context", "orchestrator", taskRun.runId);
   mkdirSync(dir, { recursive: true });
   const checkpoint = createCheckpoint(root, taskRun.runId, taskRun.dir, options.checkpoint ?? "none");
   const sandbox = createSandboxAdapter(options.checkpoint ?? "none");
+  progress("sandbox", `preparing ${options.checkpoint ?? "none"} sandbox`);
   const sandboxHandle = await sandbox.prepare(taskRun.runId, root);
   let sandboxDiscarded = sandboxHandle.mode === "host";
   const iterations: OrchestratorIterationReport[] = [];
   let previousDecision: HarnessOrchestratorReport["decision"] | undefined;
   let latestContext = preContext;
   if (sandboxHandle.mode === "git-worktree") {
+    progress("context", "building context inside git-worktree sandbox");
     latestContext = await buildContextPackage(sandboxHandle.root);
     writeContextPackage(latestContext);
     writeTaskRun(latestContext, task, { base, type: options.type ?? "auto", tokenBudget: options.tokenBudget, preserveTrace: true });
@@ -200,7 +217,9 @@ export async function runHarnessOrchestrator(repo: string, task: string, options
 
   try {
     for (let loopIndex = 1; loopIndex <= maxLoops; loopIndex += 1) {
+      progress("plan", `starting loop ${loopIndex} of ${maxLoops}`, loopIndex);
       if (loopIndex > 1 || previousDecision?.action === "repack") {
+        progress("context", "refreshing context for next loop", loopIndex);
         latestContext = await buildContextPackage(sandboxHandle.root);
         writeContextPackage(latestContext);
         writeTaskRun(latestContext, task, { base, type: options.type ?? "auto", tokenBudget: options.tokenBudget, preserveTrace: true });
@@ -211,6 +230,7 @@ export async function runHarnessOrchestrator(repo: string, task: string, options
       mkdirSync(iterationDir, { recursive: true });
       const prompt = buildExecutorPrompt(latestContext, taskRun, executorName, options, previousDecision, loopIndex);
       const promptFile = write(path.join(iterationDir, "prompt.md"), prompt);
+      progress("execute", `launching ${executorName} executor`, loopIndex);
       const executorResult = await executor({
         repo: sandboxHandle.root,
         hostRepo: root,
@@ -224,9 +244,12 @@ export async function runHarnessOrchestrator(repo: string, task: string, options
         agent: options.agent,
         executorCommand: options.executorCommand,
         dryRun: options.dryRun,
-        onExecutorOutput: options.onExecutorOutput
+        onExecutorOutput: options.onExecutorOutput,
+        onProgress: options.onProgress
       });
+      progress("collect", `${executorName} executor finished with exit code ${executorResult.exitCode ?? "unknown"}`, loopIndex);
 
+      progress("collect", "normalizing executor events", loopIndex);
       const normalized = normalizeAgentEvents({
         executor: executorName,
         stdout: executorResult.stdout,
@@ -246,6 +269,7 @@ export async function runHarnessOrchestrator(repo: string, task: string, options
       appendExecutorTrace(root, taskRun.runId, executorName, executorResult, loopIndex, normalized.warnings);
       mirrorTraceForEvaluation(root, sandboxHandle.root, taskRun.runId);
 
+      progress("evaluate", "running hallucination, regression, impact, policy, and verify checks", loopIndex);
       const postContext = await buildContextPackage(sandboxHandle.root);
       const hallucination = buildHallucinationReport(postContext, { base, traceId: taskRun.runId, task });
       writeHallucinationReport(postContext, hallucination);
@@ -298,6 +322,7 @@ export async function runHarnessOrchestrator(repo: string, task: string, options
       } else {
         latestDecision = decision;
       }
+      progress("decision", `decision: ${latestDecision.action}`, loopIndex);
 
       const iterationFiles = writeIterationArtifacts(root, iterationDir, {
         runId: taskRun.runId,
@@ -438,6 +463,7 @@ export async function runHarnessOrchestrator(repo: string, task: string, options
     ];
     report.artifacts.orchestratorFiles = files.map((file) => path.relative(root, file).replaceAll("\\", "/"));
     writeFileSync(path.join(dir, "orchestrator.json"), `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    progress("write", `wrote orchestrator report to ${path.relative(root, path.join(dir, "orchestrator.md")).replaceAll("\\", "/")}`);
 
     return { report, files };
   } finally {
