edsger 0.64.0 → 0.65.0

package/dist/commands/session-turn/index.d.ts

@@ -4,12 +4,30 @@
  * its own line and free of logger formatting so it parses cleanly.
  */
 export declare const SESSION_ID_MARKER = "__EDSGER_SESSION_ID__=";
+/**
+ * Marker emitted on stdout for each background `cli_*` run still in flight when
+ * the turn ends. The desktop main process parses these, watches each run to
+ * completion (the turn process itself exits immediately), and then re-engages
+ * the agent via `--run-finished` so it reports results without the user having
+ * to ask. The JSON payload is `{ run_id, pid, log_path, command }`.
+ */
+export declare const CLI_RUN_MARKER = "__EDSGER_CLI_RUN__=";
 export interface SessionTurnCliOptions {
     channelId: string;
     productId: string;
     repositoryIds?: string[];
     /** SDK session id from a previous turn, to resume the same conversation. */
     resumeSessionId?: string;
+    /**
+     * Follow-up turn triggered by the desktop watcher when a background `cli_*`
+     * run finishes. When set, the turn is driven by a synthetic prompt instead of
+     * the channel's pending human messages: the agent inspects what the run
+     * produced and reports it to the user.
+     */
+    runFinished?: {
+        runId: string;
+        command?: string;
+    };
     verbose?: boolean;
 }
 export declare function runSessionTurnCommand(options: SessionTurnCliOptions): Promise<void>;

package/dist/commands/session-turn/index.js

@@ -4,6 +4,14 @@
  * its own line and free of logger formatting so it parses cleanly.
  */
 export const SESSION_ID_MARKER = '__EDSGER_SESSION_ID__=';
+/**
+ * Marker emitted on stdout for each background `cli_*` run still in flight when
+ * the turn ends. The desktop main process parses these, watches each run to
+ * completion (the turn process itself exits immediately), and then re-engages
+ * the agent via `--run-finished` so it reports results without the user having
+ * to ask. The JSON payload is `{ run_id, pid, log_path, command }`.
+ */
+export const CLI_RUN_MARKER = '__EDSGER_CLI_RUN__=';
 /**
  * `edsger session-turn <channelId>` — run one conversational agent turn for a
  * chat session (an ai_assistant channel bound to a product).
@@ -17,7 +25,7 @@ export const SESSION_ID_MARKER = '__EDSGER_SESSION_ID__=';
  * there is no fixed pipeline.
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { buildSessionAgentOptions, buildSessionSystemPrompt, buildSessionUserPrompt, createSessionMcpServer, loadExternalMcpServers, SESSION_MAX_TURNS, } from 'edsger-tools';
+import { buildSessionAgentOptions, buildSessionSystemPrompt, buildSessionUserPrompt, createSessionMcpServer, listActiveCliRuns, loadExternalMcpServers, SESSION_MAX_TURNS, } from 'edsger-tools';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { getToolDeps } from '../../tools/bootstrap.js';
@@ -46,23 +54,44 @@ async function prepareSessionWorkspace(opts) {
     };
 }
 export async function runSessionTurnCommand(options) {
-    const { channelId, productId, repositoryIds = [], resumeSessionId, verbose = false, } = options;
+    const { channelId, productId, repositoryIds = [], resumeSessionId, runFinished, verbose = false, } = options;
     // Emit the SDK session id so the desktop can persist it for the next turn.
     const emitSessionId = (id) => {
         if (id) {
             process.stdout.write(`\n${SESSION_ID_MARKER}${id}\n`);
         }
     };
-    // 1. Load the pending human messages that triggered this turn.
-    const pendingResult = (await callMcpEndpoint('chat/messages/pending', {
-        channel_id: channelId,
-    }));
-    const messages = pendingResult.messages ?? [];
-    if (messages.length === 0) {
-        logInfo('No pending messages for this session — nothing to do.');
-        return;
+    // Emit a marker for every background cli_* run still in flight, so the
+    // desktop watcher can poll each to completion and re-engage the agent.
+    const emitActiveCliRuns = () => {
+        for (const run of listActiveCliRuns()) {
+            const payload = JSON.stringify({
+                run_id: run.run_id,
+                pid: run.pid,
+                log_path: run.log_path,
+                command: run.command,
+            });
+            process.stdout.write(`\n${CLI_RUN_MARKER}${payload}\n`);
+        }
+    };
+    // 1. Decide what drives this turn. A normal turn replays the channel's
+    //    pending human messages; a watcher-triggered follow-up replays a
+    //    synthetic prompt about the background run that just finished.
+    let messages = [];
+    if (runFinished) {
+        logInfo(`Reporting completion of background run ${runFinished.runId} for session ${channelId}`);
+    }
+    else {
+        const pendingResult = (await callMcpEndpoint('chat/messages/pending', {
+            channel_id: channelId,
+        }));
+        messages = pendingResult.messages ?? [];
+        if (messages.length === 0) {
+            logInfo('No pending messages for this session — nothing to do.');
+            return;
+        }
+        logInfo(`Processing ${messages.length} message(s) for session ${channelId}`);
     }
-    logInfo(`Processing ${messages.length} message(s) for session ${channelId}`);
     // 2. Clone the product's in-scope repositories into a local session
     //    directory so the agent's Read/Grep/Glob can inspect the real code.
     const { sessionDir, repoScopeNote } = await prepareSessionWorkspace({
@@ -89,7 +118,9 @@ export async function runSessionTurnCommand(options) {
         repoScopeNote,
         externalMcpNames: external.names,
     });
-    const userPrompt = buildSessionUserPrompt(messages);
+    const userPrompt = runFinished
+        ? buildRunFinishedPrompt(runFinished)
+        : buildSessionUserPrompt(messages);
     // 4. Run one SDK turn. Resume the prior SDK session when we have its id so
     //    the conversation (and prompt cache) carries across turns. Point the
     //    agent's cwd at the session directory so its read-only file tools resolve
@@ -137,6 +168,7 @@ export async function runSessionTurnCommand(options) {
             metadata: {},
         }).catch(() => undefined);
         emitSessionId(sdkSessionId);
+        emitActiveCliRuns();
         await markProcessed(messages);
         return;
     }
@@ -153,12 +185,27 @@ export async function runSessionTurnCommand(options) {
             logError(`Failed to post reply: ${e instanceof Error ? e.message : String(e)}`);
         });
     }
-    // 6. Mark the triggering messages processed so they aren't re-run.
+    // 6. Mark the triggering messages processed so they aren't re-run. (No-op for
+    //    a watcher follow-up, which has no triggering human messages.)
     await markProcessed(messages);
-    // 7. Emit the SDK session id so the desktop persists it for the next turn.
+    // 7. Emit the SDK session id so the desktop persists it for the next turn,
+    //    plus a marker for any background run launched this turn so the watcher
+    //    keeps following it to completion.
     emitSessionId(sdkSessionId);
+    emitActiveCliRuns();
     logSuccess('Session turn complete.');
 }
+/**
+ * The synthetic user prompt for a watcher-triggered follow-up turn. Steers the
+ * agent to inspect what the finished run produced and report it — explicitly
+ * NOT to ask the user whether it should check.
+ */
+function buildRunFinishedPrompt(runFinished) {
+    const which = runFinished.command
+        ? `the \`${runFinished.command}\` analysis (run ${runFinished.runId})`
+        : `a background analysis you launched earlier (run ${runFinished.runId})`;
+    return `${which} just finished. Inspect what it produced — call get_cli_run with run_id "${runFinished.runId}" for the log tail, then use the list_* / get_* tools (e.g. list_issues) to see the findings it filed. Summarize the results for the user via send_chat_message. Do not ask whether you should check — just report what you found. If nothing of note was produced, say so briefly.`;
+}
 async function markProcessed(messages) {
     for (const m of messages) {
         await callMcpEndpoint('chat/messages/mark_processed', {

package/dist/index.js

@@ -441,6 +441,8 @@ program
     .requiredOption('--product <productId>', 'Product the session is bound to')
     .option('--repos <ids>', 'Comma-separated repository IDs the agent may touch', '')
     .option('--resume <sessionId>', 'SDK session id from a previous turn to resume the same conversation')
+    .option('--run-finished <runId>', 'Follow-up turn: report the results of a background cli_* run that finished')
+    .option('--run-command <command>', 'The command name of the finished run (used with --run-finished)')
     .option('-v, --verbose', 'Verbose output')
     .action(async (channelId, opts) => {
     try {
@@ -452,6 +454,9 @@ program
                 .map((s) => s.trim())
                 .filter(Boolean),
             resumeSessionId: opts.resume,
+            runFinished: opts.runFinished
+                ? { runId: opts.runFinished, command: opts.runCommand }
+                : undefined,
             verbose: opts.verbose,
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"
@@ -51,7 +51,7 @@
     "cosmiconfig": "^9.0.0",
     "dotenv": "^16.4.5",
     "edsger-contract": "0.7.0",
-    "edsger-tools": "0.7.0",
+    "edsger-tools": "0.8.0",
     "gray-matter": "^4.0.3",
     "zod": "^4.0.0"
   },