orchestrar 0.3.2 → 0.3.4

package/orchestrator.js

@@ -50,23 +50,23 @@ async function runWorkInstance(createOpencode, docs, root) {
     const sessionID = extractSessionID(session, "session.create (work instance)");
     const promptPaths = buildPromptPaths(docs, root);
 
-    await sendPrompt(
+    const workMessageID = await sendPrompt(
       client,
       sessionID,
       buildMilestonePrompt(promptPaths),
       root
     );
-    await waitForSessionIdle(client, sessionID, root);
+    await waitForMessageComplete(client, sessionID, workMessageID, root);
 
-    await runReviewLoop(createOpencode, client, sessionID, root);
+    await runReviewLoop(client, sessionID, root);
 
-    await sendPrompt(
+    const markTasksMessageID = await sendPrompt(
       client,
       sessionID,
       buildMarkTasksPrompt(promptPaths.plan),
       root
     );
-    await waitForSessionIdle(client, sessionID, root);
+    await waitForMessageComplete(client, sessionID, markTasksMessageID, root);
   } finally {
     await disposeInstance(client, server, root);
   }
@@ -86,7 +86,7 @@ async function runCommitInstance(createOpencode, root) {
     );
 
     const sessionID = extractSessionID(session, "session.create (commit instance)");
-    await sendPrompt(
+    const commitMessageID = await sendPrompt(
       client,
       sessionID,
       buildCommitPrompt(),
@@ -94,13 +94,13 @@ async function runCommitInstance(createOpencode, root) {
       COMMIT_MODEL,
       COMMIT_AGENT
     );
-    await waitForSessionIdle(client, sessionID, root);
+    await waitForMessageComplete(client, sessionID, commitMessageID, root);
   } finally {
     await disposeInstance(client, server, root);
   }
 }
 
-async function runReviewLoop(createOpencode, client, sessionID, root) {
+async function runReviewLoop(client, sessionID, root) {
   const maxIterations = parseNumber(
     process.env.ORCHESTRATOR_MAX_REVIEW_ITERATIONS,
     DEFAULT_MAX_REVIEW_ITERATIONS
@@ -108,7 +108,7 @@ async function runReviewLoop(createOpencode, client, sessionID, root) {
 
   for (let iteration = 1; iteration <= maxIterations; iteration += 1) {
     logStep(`Running review (${iteration}/${maxIterations})`);
-    const reviewResult = await runReviewCommand(createOpencode, root);
+    const reviewResult = await runReviewCommand(client, root);
     if (isFindingsEmpty(reviewResult)) {
       logStep("Review clean; no findings.");
       return;
@@ -118,13 +118,13 @@ async function runReviewLoop(createOpencode, client, sessionID, root) {
       ? reviewResult.findings.length
       : "unknown";
     logStep(`Review found ${findingsCount} issues; requesting fixes.`);
-    await sendPrompt(
+    const fixMessageID = await sendPrompt(
       client,
       sessionID,
       buildFindingsPrompt(reviewResult),
       root
     );
-    await waitForSessionIdle(client, sessionID, root);
+    await waitForMessageComplete(client, sessionID, fixMessageID, root);
   }
 
   throw new Error(
@@ -132,7 +132,7 @@ async function runReviewLoop(createOpencode, client, sessionID, root) {
   );
 }
 
-async function runReviewCommand(createOpencode, root) {
+async function runReviewCommand(client, root) {
   const commandName =
     process.env.ORCHESTRATOR_REVIEW_COMMAND || DEFAULT_REVIEW_COMMAND_NAME;
   const commandArguments =
@@ -142,58 +142,56 @@ async function runReviewCommand(createOpencode, root) {
     process.env.ORCHESTRATOR_REVIEW_TIMEOUT_MS,
     DEFAULT_REVIEW_TIMEOUT_MS
   );
+  const session = await unwrap(
+    client.session.create({
+      query: { directory: root },
+      body: { title: "Review" },
+    }),
+    "session.create"
+  );
 
-  const { client, server } = await createOpencode({
-    config: buildConfig(DEFAULT_MODEL),
-  });
+  const sessionID = extractSessionID(session, "session.create (review instance)");
+  const commandResult = await unwrap(
+    client.session.command({
+      path: { id: sessionID },
+      query: { directory: root },
+      body: {
+        command: commandName,
+        arguments: commandArguments,
+        agent: DEFAULT_AGENT,
+        model: DEFAULT_MODEL,
+      },
+    }),
+    "session.command"
+  );
 
-  try {
-    const session = await unwrap(
-      client.session.create({
-        query: { directory: root },
-        body: { title: "Review" },
-      }),
-      "session.create"
-    );
+  const commandMessageID = extractMessageID(commandResult);
+  await waitForMessageComplete(
+    client,
+    sessionID,
+    commandMessageID,
+    root,
+    timeoutMs
+  );
 
-    const sessionID = extractSessionID(session, "session.create (review instance)");
-    const commandResult = await unwrap(
-      client.session.command({
-        path: { id: sessionID },
+  let parts = commandResult?.parts ?? [];
+  const messageID = extractMessageID(commandResult);
+  if (messageID) {
+    const message = await unwrap(
+      client.session.message({
+        path: { id: sessionID, messageID },
         query: { directory: root },
-        body: {
-          command: commandName,
-          arguments: commandArguments,
-          agent: DEFAULT_AGENT,
-          model: DEFAULT_MODEL,
-        },
       }),
-      "session.command"
+      "session.message"
     );
+    parts = message?.parts ?? parts;
+  }
 
-    await waitForSessionIdle(client, sessionID, root, timeoutMs);
-
-    let parts = commandResult?.parts ?? [];
-    const messageID = commandResult?.info?.id;
-    if (messageID) {
-      const message = await unwrap(
-        client.session.message({
-          path: { id: sessionID, messageID },
-          query: { directory: root },
-        }),
-        "session.message"
-      );
-      parts = message?.parts ?? parts;
-    }
-
-    const output = collectCommandOutput(parts);
-    if (!output.trim()) {
-      throw new Error("Review command produced no output.");
-    }
-    return extractReviewJson(output);
-  } finally {
-    await disposeInstance(client, server, root);
+  const output = collectCommandOutput(parts);
+  if (!output.trim()) {
+    throw new Error("Review command produced no output.");
   }
+  return extractReviewJson(output);
 }
 
 async function sendPrompt(
@@ -205,7 +203,7 @@ async function sendPrompt(
   agentSpec = DEFAULT_AGENT
 ) {
   const model = parseModelSpec(modelSpec);
-  await unwrap(
+  const response = await unwrap(
     client.session.prompt({
       path: { id: sessionID },
       query: { directory: root },
@@ -217,6 +215,8 @@ async function sendPrompt(
     }),
     "session.prompt"
   );
+
+  return extractMessageID(response);
 }
 
 async function waitForSessionIdle(client, sessionID, root, timeoutOverrideMs) {
@@ -232,26 +232,79 @@ async function waitForSessionIdle(client, sessionID, root, timeoutOverrideMs) {
   );
 
   const start = Date.now();
+  let lastKnownSessions = [];
   while (Date.now() - start < timeoutMs) {
     const statusMap = await unwrap(
       client.session.status({ query: { directory: root } }),
       "session.status"
     );
+    if (statusMap && typeof statusMap === "object") {
+      lastKnownSessions = Object.keys(statusMap);
+    }
     const status = statusMap?.[sessionID];
     if (!status) {
-      const knownSessions = statusMap ? Object.keys(statusMap) : [];
-      const knownList = knownSessions.length ? knownSessions.join(", ") : "none";
+      await delay(pollIntervalMs);
+      continue;
+    }
+    if (status.type === "idle") {
+      return;
+    }
+    await delay(pollIntervalMs);
+  }
+
+  const knownList = lastKnownSessions.length
+    ? lastKnownSessions.join(", ")
+    : "none";
+  throw new Error(
+    `Timed out waiting for session ${sessionID} to go idle. Known sessions: ${knownList}.`
+  );
+}
+
+async function waitForMessageComplete(
+  client,
+  sessionID,
+  messageID,
+  root,
+  timeoutOverrideMs
+) {
+  if (!messageID) {
+    await waitForSessionIdle(client, sessionID, root, timeoutOverrideMs);
+    return;
+  }
+
+  const timeoutMs =
+    timeoutOverrideMs ??
+    parseNumber(
+      process.env.ORCHESTRATOR_SESSION_TIMEOUT_MS,
+      DEFAULT_SESSION_TIMEOUT_MS
+    );
+  const pollIntervalMs = parseNumber(
+    process.env.ORCHESTRATOR_STATUS_POLL_INTERVAL_MS,
+    DEFAULT_STATUS_POLL_INTERVAL_MS
+  );
+
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const message = await unwrap(
+      client.session.message({
+        path: { id: sessionID, messageID },
+        query: { directory: root },
+      }),
+      "session.message"
+    );
+    const info = message?.info ?? message;
+    if (info?.error) {
       throw new Error(
-        `Session status missing for ${sessionID}. Known sessions: ${knownList}.`
+        `Session message ${messageID} failed: ${formatError(info.error)}`
       );
     }
-    if (status.type === "idle") {
+    if (info?.time?.completed || info?.finish) {
       return;
     }
     await delay(pollIntervalMs);
   }
 
-  throw new Error(`Timed out waiting for session ${sessionID} to go idle.`);
+  throw new Error(`Timed out waiting for message ${messageID} to complete.`);
 }
 
 async function resolveDocs(root) {
@@ -506,6 +559,33 @@ function extractSessionID(session, context) {
   );
 }
 
+function extractMessageID(message) {
+  if (!message || typeof message !== "object") {
+    return;
+  }
+
+  const candidates = [
+    message.info?.id,
+    message.info?.messageID,
+    message.id,
+    message.messageID,
+    message.data?.info?.id,
+    message.data?.info?.messageID,
+    message.data?.id,
+    message.data?.messageID,
+    message.properties?.info?.id,
+    message.properties?.info?.messageID,
+    message.properties?.id,
+    message.properties?.messageID,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate;
+    }
+  }
+}
+
 function safeStringify(value, maxLength = 1000) {
   try {
     const json = JSON.stringify(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestrar",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "OpenCode milestone orchestrator",
   "license": "MIT",
   "type": "commonjs",