@drisp/cli 0.7.10 → 0.7.12

package/dist/cli.js

@@ -10,8 +10,10 @@ import {
   ServiceNotEnabledError,
   approvalAnswer,
   attachRuntimeEventLoop,
+  attemptForecast,
   behindMain,
   bootstrapRuntimeConfig,
+  budgetCheck,
   buildApiKeyHelperSettings,
   buildPhaseFeedEvent,
   buildPlanSchema,
@@ -49,7 +51,6 @@ import {
   finalizePlan,
   fit,
   fitAnsi,
-  forecastOfCap,
   forgetRunner,
   formatClock,
   formatProbeCommand,
@@ -143,7 +144,7 @@ import {
   visualPositionToOffset,
   wrapText,
   writeIdentityOnce
-} from "./chunk-ISH6VEYL.js";
+} from "./chunk-UUUCDIHI.js";
 import {
   generateId as generateId2
 } from "./chunk-PQIB66SG.js";
@@ -202,7 +203,7 @@ import {
   workflowRegistryDir,
   writeGlobalConfig,
   writeProjectConfig
-} from "./chunk-FYXEDUQ6.js";
+} from "./chunk-SACVOS6T.js";
 import {
   __toESM
 } from "./chunk-G3PMV62Z.js";
@@ -210,10 +211,10 @@ import {
 // src/app/entry/cli.tsx
 import { render } from "ink";
 import meow from "meow";
-import fs12 from "fs";
+import fs13 from "fs";
 import { createRequire } from "module";
 import os5 from "os";
-import path12 from "path";
+import path13 from "path";
 import { fileURLToPath } from "url";
 
 // src/app/shell/sessionUiState.ts
@@ -5332,14 +5333,14 @@ function extractWebSearch(_input, response) {
   return { type: "text", content: extractTextContent(response), maxLines: 10 };
 }
 function extractNotebookEdit(input, _response) {
-  const path13 = typeof input["notebook_path"] === "string" ? input["notebook_path"] : "";
+  const path14 = typeof input["notebook_path"] === "string" ? input["notebook_path"] : "";
   const mode = typeof input["edit_mode"] === "string" ? input["edit_mode"] : "replace";
   const source = typeof input["new_source"] === "string" ? input["new_source"] : "";
-  if (!source) return { type: "text", content: `${mode} cell in ${path13}` };
+  if (!source) return { type: "text", content: `${mode} cell in ${path14}` };
   return {
     type: "code",
     content: source,
-    language: detectLanguage(path13),
+    language: detectLanguage(path14),
     maxLines: 10
   };
 }
@@ -5865,10 +5866,10 @@ function extractToolSubject(toolName, toolInput) {
       const parts = [];
       const pattern = str(input, "pattern");
       const glob = str(input, "glob");
-      const path13 = str(input, "path");
+      const path14 = str(input, "path");
       if (pattern) parts.push(`"${pattern}"`);
       if (glob) parts.push(glob);
-      if (path13) parts.push(`in ${path13}`);
+      if (path14) parts.push(`in ${path14}`);
       return parts.length > 0 ? parts.join("  ") : void 0;
     }
     case "Skill":
@@ -13099,7 +13100,7 @@ var thisMachine = (installationId) => ({
   os: `${platform()} ${release()}`.slice(0, 64),
   softwareVersion: runnerSoftwareVersion
 });
-var post = (origin, path13, body) => fetch(new URL(path13, origin), {
+var post = (origin, path14, body) => fetch(new URL(path14, origin), {
   method: "POST",
   headers: { "Content-Type": "application/json" },
   body: JSON.stringify(body)
@@ -13118,8 +13119,8 @@ async function alreadyConnected(existing, { forTeam, ownIdentity }) {
   const problem = own ? await credentialAccepted(own.config) ? void 0 : "lapsed" : forTeam(existing.orgId).length ? "other_runner" : "missing";
   const runner = { orgId: existing.orgId, runnerId: existing.runnerId, name: existing.name };
   if (own && problem === void 0) return { status: "already_connected", ...runner, path: own.path };
-  const path13 = (own ?? forTeam(existing.orgId)[0])?.path;
-  return { status: "identity_unusable", ...runner, problem, ...path13 ? { path: path13 } : {} };
+  const path14 = (own ?? forTeam(existing.orgId)[0])?.path;
+  return { status: "identity_unusable", ...runner, problem, ...path14 ? { path: path14 } : {} };
 }
 async function connectWithCode({
   code,
@@ -13191,20 +13192,20 @@ async function saveIdentity(origin, credential, { single, forTeam }, directory)
     name: credential.name
   });
   const replaced = [];
-  for (const { path: path14 } of forTeam(credential.orgId)) {
-    const aside = `${path14}.replaced-${Date.now()}`;
-    await rename(path14, aside);
+  for (const { path: path15 } of forTeam(credential.orgId)) {
+    const aside = `${path15}.replaced-${Date.now()}`;
+    await rename(path15, aside);
     replaced.push(aside);
   }
-  const path13 = single ?? teamIdentityPath(origin, credential.orgId, directory);
+  const path14 = single ?? teamIdentityPath(origin, credential.orgId, directory);
   try {
-    await writeIdentityOnce(path13, JSON.stringify(config, null, 2) + "\n");
+    await writeIdentityOnce(path14, JSON.stringify(config, null, 2) + "\n");
   } catch (error) {
     if (error.code === "EEXIST")
-      throw new Error(`Another Connect wrote a Runner identity for this Team at ${path13} meanwhile; it was left unchanged.`);
+      throw new Error(`Another Connect wrote a Runner identity for this Team at ${path14} meanwhile; it was left unchanged.`);
     throw error;
   }
-  return { status: "connected", config, path: path13, replaced };
+  return { status: "connected", config, path: path14, replaced };
 }
 function pathSegment(value) {
   const segment = encodeURIComponent(value);
@@ -13244,7 +13245,7 @@ async function refuseExisting(target) {
   throw new Error(`This machine already has a Runner${name ? ` (${name})` : ""} configured at ${target}.`);
 }
 async function disconnectRunner({
-  identity: { path: path13, config },
+  identity: { path: path14, config },
   serviceManager,
   othersRemain
 }) {
@@ -13277,7 +13278,7 @@ async function disconnectRunner({
     await restore();
     throw new Error(`The Hub refused to disconnect ${name} (${body.error ?? response.status}); it is still connected.`);
   }
-  await forgetRunner(path13);
+  await forgetRunner(path14);
   if (othersRemain) await restore();
   else await serviceManager?.remove();
   return result;
@@ -13430,18 +13431,18 @@ async function runRunnerCommandV2(input, options = {}) {
             `This machine is already connected to this Team as ${outcome.name}, but ${why}. ` + (code ? `The code was not used: connect a new Runner in its place with ${retry}. ` : `Connect a new Runner in its place with a Connect code from Settings \u2192 Runners: ${retry}. `) + `The old ${outcome.name} stays listed in Settings \u2192 Runners, offline.`
           );
         }
-        const { config, path: path13, replaced } = outcome;
+        const { config, path: path14, replaced } = outcome;
         for (const aside of replaced)
           process.stdout.write(
             `The Hub no longer recognised this machine's earlier identity for this Team; it was moved aside to ${aside}.
 `
           );
         process.stdout.write(
-          `Connected as ${config.name ?? config.runnerId}. Identity saved to ${path13}.
+          `Connected as ${config.name ?? config.runnerId}. Identity saved to ${path14}.
 `
         );
         if (services) {
-          const service = await ensureService(services, config, path13);
+          const service = await ensureService(services, config, path14);
           process.stdout.write(`${serviceStarted(service)}
 `);
           return 0;
@@ -13450,7 +13451,7 @@ async function runRunnerCommandV2(input, options = {}) {
           process.stdout.write(
             "No launchd or systemd here to run the Runner as a background service; running it in the foreground instead.\n"
           );
-        await runConfiguredRunner(path13, options.signal);
+        await runConfiguredRunner(path14, options.signal);
         return 0;
       }
       case "disconnect": {
@@ -13521,9 +13522,9 @@ async function runRunnerCommandV2(input, options = {}) {
               configured: true,
               // One entry per Team this machine serves; credentials are never printed.
               teams: identities.map(
-                ({ path: path13, config: { token: _token, ...config } }) => ({
+                ({ path: path14, config: { token: _token, ...config } }) => ({
                   ...config,
-                  path: path13
+                  path: path14
                 })
               ),
               service: service ? {
@@ -13872,9 +13873,9 @@ var DrispClient = class _DrispClient {
     if (!match) throw new Error("invalid_hub_url");
     return new _DrispClient(url.origin, decodeURIComponent(match[1]), async () => token);
   }
-  async request(path13, body) {
+  async request(path14, body) {
     const response = await fetch(
-      `${this.baseUrl}/v2/orgs/${encodeURIComponent(this.orgId)}${path13}`,
+      `${this.baseUrl}/v2/orgs/${encodeURIComponent(this.orgId)}${path14}`,
       {
         method: body === void 0 ? "GET" : "POST",
         headers: {
@@ -14206,8 +14207,15 @@ var buildStateSchema = external_exports.strictObject({
    * written before parses.
    */
   done: external_exports.array(external_exports.string()).optional(),
-  /** The merged issues the Orchestrator was already asked to repair in Linear, so it is asked once. */
-  repaired: external_exports.array(external_exports.string()).optional()
+  /**
+   * The merged issues the Orchestrator was asked to repair in Linear. No longer written since reconcile (DRI-277),
+   * still read so a state written before parses.
+   */
+  repaired: external_exports.array(external_exports.string()).optional(),
+  /** Additive (DRI-277): the `once` keys of the comments reconcile already asked for, so each is asked once. */
+  posted: external_exports.array(external_exports.string()).optional(),
+  /** Additive (DRI-277): reconcile ticks in a row; at `RECONCILE_PASSES` the tick goes on without one. */
+  reconcilePasses: external_exports.number().int().nonnegative().optional()
 });
 
 // src/core/build/childStart.ts
@@ -14265,11 +14273,14 @@ function outcomeOf(view) {
   return "failed";
 }
 function buildLimits(own, delegation) {
-  if (!delegation) return own;
+  if (!delegation) return { ...own, maxChildren: own.maxChildren ?? 1 };
   return {
     ...own,
-    maxChildren: Math.min(own.maxChildren, delegation.maxChildren),
-    tokenBudget: Math.min(own.tokenBudget, delegation.tokenBudget)
+    maxChildren: Math.min(
+      own.maxChildren ?? Infinity,
+      delegation.maxChildren ?? own.maxChildren ?? 1
+    ),
+    tokenBudget: delegation.tokenBudget
   };
 }
 function occupies(view) {
@@ -14314,8 +14325,8 @@ function assessTick(facts) {
       ].sort((a, b) => a.n - b.n);
     }
   }
-  for (const attempts of Object.values(state.attempts))
-    for (const attempt of attempts) {
+  for (const attempts2 of Object.values(state.attempts))
+    for (const attempt of attempts2) {
       const view = views.get(attempt.runId);
       if (view?.closed && !attempt.outcome) attempt.outcome = outcomeOf(view);
     }
@@ -14326,11 +14337,13 @@ function assessTick(facts) {
       state.needsPerson[entry.id] = BUILD_STRINGS.rebaseFailed(branchOf(entry));
   }
   const pullRequests = /* @__PURE__ */ new Map();
+  const byEntry = /* @__PURE__ */ new Map();
   const prsOf = (entry) => {
     const branch = attemptsOf(entry.id).at(-1)?.branch ?? issues.get(entry.id)?.branchName;
     if (!branch) return void 0;
     if (!pullRequests.has(branch))
       pullRequests.set(branch, facts.pullRequests(branch));
+    byEntry.set(entry.id, pullRequests.get(branch));
     return pullRequests.get(branch);
   };
   const status = /* @__PURE__ */ new Map();
@@ -14338,29 +14351,15 @@ function assessTick(facts) {
     const linear = issues.get(id)?.state.type;
     return linear === "completed" ? "done" : "blocked";
   };
-  const repair = [];
-  const repaired = new Set(state.repaired ?? []);
   for (const entry of entries) {
-    const attempts = attemptsOf(entry.id);
-    const newest = attempts.at(-1);
+    const attempts2 = attemptsOf(entry.id);
+    const newest = attempts2.at(-1);
     const view = newest && views.get(newest.runId);
     const linear = issues.get(entry.id)?.state.type;
     const statusOf = () => {
       if (linear === "completed" || linear === "canceled") return "done";
       const prs = entry.profile === "investigation" ? void 0 : prsOf(entry);
-      if (prs?.merged) {
-        if (!repaired.has(entry.id) && !(newest && occupies(view))) {
-          const prUrl = prs.mergedUrl ?? branchOf(entry);
-          repair.push({
-            id: entry.id,
-            identifier: entry.identifier,
-            prUrl,
-            comment: BUILD_STRINGS.repairComment(prUrl, orchestratorRunId)
-          });
-          repaired.add(entry.id);
-        }
-        return "done";
-      }
+      if (prs?.merged) return "done";
       if (newest && (!view || !view.closed)) return "live";
       const current = issues.get(entry.id);
       if (!current || eligibilityReason(current)) {
@@ -14373,8 +14372,8 @@ function assessTick(facts) {
       }
       if (newest?.outcome === "template_mismatch") return "replan";
       if (newest?.outcome === "completed")
-        state.needsPerson[entry.id] ??= entry.profile === "investigation" ? "The investigation ended without marking its accepted findings Done in Linear. Review its evidence." : BUILD_STRINGS.completedUnmerged;
-      if (state.needsPerson[entry.id] || newest && !mayRetry(attempts))
+        state.needsPerson[entry.id] ??= entry.profile === "investigation" ? "The investigation ended. Review its findings and evidence on the issue." : BUILD_STRINGS.completedUnmerged;
+      if (state.needsPerson[entry.id] || newest && !mayRetry(attempts2))
         return "needs_person";
       const blockers = [
         .../* @__PURE__ */ new Set([
@@ -14398,47 +14397,74 @@ function assessTick(facts) {
     if (status.get(entry.id) === "done" && state.needsPerson[entry.id] === BUILD_STRINGS.completedUnmerged)
       delete state.needsPerson[entry.id];
   }
-  if (repaired.size > 0) state.repaired = [...repaired];
-  let parkReason = facts.templateVersion !== state.templateVersion ? "template" : state.tickCount >= facts.limits.tickAllowance ? "budget" : void 0;
+  const tokenBudget = facts.limits.tokenBudget;
+  const attempts = [
+    ...facts.children.map((view) => ({
+      tokenCap: view.parent?.tokenCap ?? Number.NaN,
+      closed: view.closed,
+      ...view.usage ? { spent: view.usage.counted } : {}
+    })),
+    ...Object.values(state.attempts).flat().filter((attempt) => !views.has(attempt.runId)).map((attempt) => ({ tokenCap: attempt.tokenCap, closed: false }))
+  ];
+  let park = facts.templateVersion !== state.templateVersion ? { reason: "template", message: BUILD_STRINGS.templatePark } : state.tickCount >= facts.limits.tickAllowance ? {
+    reason: "ticks",
+    message: BUILD_STRINGS.tickPark(facts.limits.tickAllowance)
+  } : void 0;
   const occupying = entries.filter((entry) => {
     const newest = attemptsOf(entry.id).at(-1);
     return newest !== void 0 && occupies(views.get(newest.runId));
   }).length;
   const queue = [];
-  if (!parkReason) {
-    let committed = Object.values(state.attempts).flat().reduce((sum, attempt) => sum + forecastOfCap(attempt.tokenCap), 0);
+  if (!park) {
+    const admitted = [...attempts];
     for (const entry of entries) {
       if (status.get(entry.id) !== "ready") continue;
-      if (committed + forecastOfCap(entry.tokenCap) > facts.limits.tokenBudget) {
-        parkReason = "budget";
+      const next = attemptForecast(entry.tokenCap);
+      const check = budgetCheck({ tokenBudget, attempts: admitted, next });
+      if (!check.fits) {
+        park = {
+          reason: "tokens",
+          message: BUILD_STRINGS.tokenPark({
+            used: check.used,
+            tokenBudget,
+            identifier: entry.identifier,
+            forecast: next
+          })
+        };
         break;
       }
       queue.push(entry);
-      committed += forecastOfCap(entry.tokenCap);
+      admitted.push({ tokenCap: entry.tokenCap, closed: false });
     }
   }
   return {
     state,
     status,
-    repair,
+    pullRequests: byEntry,
     queue,
     slots: Math.max(0, facts.limits.maxChildren - occupying),
-    ...parkReason ? { parkReason } : {}
+    ...park ? { park } : {}
   };
 }
 function tickAction(input) {
   const live = input.children.filter((view) => !view.closed);
+  const questions = live.filter(
+    (view) => view.execution?.status === "awaiting_attention" && view.scheduling === "idle" && view.execution.interruption?.kind === "question" && view.execution.interruption.respondent === "orchestrator" && !view.cancellation
+  );
+  if (questions.length)
+    return {
+      action: "supervise",
+      children: questions.map((view) => ({
+        runId: view.runId,
+        message: view.execution.interruption.message
+      }))
+    };
   if (input.started > 0 || live.some((view) => occupies(view)))
     return { action: "wait" };
   const remaining = input.entries.some(
     (entry) => ["ready", "pending"].includes(input.status.get(entry.id))
   );
-  if (input.parkReason && remaining)
-    return {
-      action: "park",
-      reason: input.parkReason,
-      message: input.parkReason === "budget" ? BUILD_STRINGS.budgetPark : BUILD_STRINGS.templatePark
-    };
+  if (input.park && remaining) return { action: "park", ...input.park };
   if (live.length > 0) return { action: "wait" };
   const done = input.entries.filter(
     (entry) => input.status.get(entry.id) === "done"
@@ -14455,13 +14481,126 @@ function tickAction(input) {
   };
 }
 
+// src/core/build/reconcile.ts
+var RECONCILE_PASSES = 3;
+var WEB_QA = /* @__PURE__ */ new Set(["web", "both"]);
+var NOT_HUMAN = "waiting";
+function teamStatus(status, issue) {
+  const states = issue.teamStates;
+  if (!states) return status;
+  const type = status === "Todo" ? "unstarted" : status === "Released" ? "completed" : "started";
+  const names = status === "Review" || status === "QA" || status === "Ready" ? [status, "In Review", "Review", "In Progress"] : status === "Released" ? [status, "Done"] : [status];
+  for (const name of names) {
+    const match = states.find(
+      (s) => s.type === type && s.name.toLowerCase() === name.toLowerCase()
+    );
+    if (match) return match.name;
+  }
+  if (status === "Needs Input") return void 0;
+  if (issue.state.type === type && states.some((s) => s.name === issue.state.name))
+    return issue.state.name;
+  return states.find((s) => s.type === type)?.name;
+}
+function desired(entry, facts, views) {
+  const newest = facts.attempts[entry.id]?.at(-1);
+  const view = newest && views.get(newest.runId);
+  const live = newest !== void 0 && (!view || !view.closed);
+  const prs = facts.pullRequests.get(entry.id);
+  const interruption = view?.execution?.interruption;
+  if (facts.released?.(entry.id)) return { status: "Released", comments: [] };
+  if (live && view?.execution?.status === "awaiting_attention" && interruption && interruption.kind !== NOT_HUMAN && !(interruption.kind === "question" && interruption.respondent === "orchestrator")) {
+    const step = facts.step?.(view.runId);
+    return {
+      status: "Needs Input",
+      comments: [
+        {
+          body: BUILD_STRINGS.askComment({
+            message: interruption.message,
+            runId: view.runId,
+            ...step ? { step } : {}
+          }),
+          once: `ask:${view.runId}:${interruption.interruptionId}`
+        }
+      ]
+    };
+  }
+  if (prs?.merged) {
+    const pr = prComment(prs.mergedUrl);
+    if (!WEB_QA.has(entry.qa)) return { status: "Ready", comments: pr };
+    const results = facts.qa?.(entry.id) ?? [];
+    const last = results.at(-1);
+    if (!last) return { status: "QA", comments: pr };
+    if (last.passed) return { status: "Ready", comments: pr };
+    const failures = results.filter((result) => !result.passed).length;
+    return {
+      status: failures >= 2 ? "Needs Input" : "Todo",
+      comments: [...pr, { body: last.report, once: `qa:${last.runId}` }]
+    };
+  }
+  if (prs?.open) return { status: "Review", comments: prComment(prs.openUrl) };
+  if (live) return { status: "In Progress", comments: [] };
+  if (entry.profile === "investigation" && newest?.outcome === "completed")
+    return { status: "Review", comments: [] };
+  if (newest) return { status: "Todo", comments: [] };
+  return { comments: [] };
+}
+function prComment(url) {
+  return url ? [{ body: BUILD_STRINGS.prComment(url), once: `pr:${url}` }] : [];
+}
+var closedIssue = (issue) => issue.state.type === "completed" || issue.state.type === "canceled";
+function projectStatus(facts) {
+  const current = facts.project.status;
+  const issues = facts.issues.filter((issue) => !issue.external);
+  const completed = issues.length > 0 && issues.every(closedIssue);
+  const started = facts.entries.some(
+    (entry) => (facts.attempts[entry.id]?.length ?? 0) > 0
+  );
+  if (current === "Planned" && started) return "In Progress";
+  if (current === "In Progress" && completed) return "Completed";
+  if (current === "Completed" && !completed) return "In Progress";
+  return void 0;
+}
+function reconcile(facts) {
+  const views = new Map(facts.children.map((view) => [view.runId, view]));
+  const issues = new Map(facts.issues.map((issue) => [issue.id, issue]));
+  const posted = new Set(facts.posted);
+  const actions = [];
+  const asked = [];
+  for (const entry of facts.entries) {
+    const issue = issues.get(entry.id);
+    if (!issue || issue.external || closedIssue(issue) || issue.labels.includes("ready-for-human"))
+      continue;
+    const implied = desired(entry, facts, views);
+    const { comments } = implied;
+    const status = implied.status ?? (issue.state.name === "In Progress" ? "Todo" : void 0);
+    const target = status && teamStatus(status, issue);
+    if (target && target !== issue.state.name)
+      actions.push({ kind: "issue.state", issue: entry.id, state: target });
+    for (const comment of comments) {
+      if (posted.has(comment.once)) continue;
+      posted.add(comment.once);
+      asked.push(comment.once);
+      actions.push({ kind: "issue.comment", issue: entry.id, ...comment });
+    }
+  }
+  const project = projectStatus(facts);
+  if (project)
+    actions.push({
+      kind: "project.state",
+      project: facts.project.id,
+      state: project
+    });
+  return { actions, posted: asked };
+}
+
 // src/core/build/tick.ts
 var UNAVAILABLE_RETRY_MS = 2e3;
 var UNAVAILABLE_RETRY_FOR_MS = 3e4;
 var NEVER = (/* @__PURE__ */ new Date(0)).toISOString();
 var notStarted = () => ({
-  action: "complete",
-  message: BUILD_STRINGS.notStarted
+  action: "park",
+  reason: "attention",
+  message: "This Build has not been started. Review the plan and choose Start; no child work has completed."
 });
 var guidanceFile = (artifacts) => path7.join(artifacts, "input", "guidance.json");
 function replan(artifacts, guidance) {
@@ -14580,7 +14719,7 @@ async function runBuildTick(deps) {
     state: stored,
     children: children.runs,
     templateVersion,
-    // The approved plan's budget (the member's, once it is editable) narrowed by what the Hub enforces.
+    // The Hub Run's budget, read each tick (a member may change it); the plan's binds only a Run without delegation.
     limits: buildLimits(
       { ...ORCHESTRATOR_LIMITS, tokenBudget: plan.budget.tokenBudget },
       parent.delegation
@@ -14591,7 +14730,7 @@ async function runBuildTick(deps) {
     now: deps.now().toISOString()
   });
   const { state, status } = assessment;
-  let parkReason = assessment.parkReason;
+  let park = assessment.park;
   const record = () => {
     writeFile(statePath, json(state));
     const files = [path7.join(relativePlanDir, "build-state.json")];
@@ -14608,10 +14747,6 @@ async function runBuildTick(deps) {
     ))
       push(worktree.path, worktree.branch);
   };
-  if (assessment.repair.length > 0) {
-    record();
-    return { action: "repair", issues: assessment.repair };
-  }
   const deferred = [];
   const behind = [];
   let started = 0;
@@ -14689,7 +14824,13 @@ async function runBuildTick(deps) {
           reason: BUILD_STRINGS.hubUnreachable(entry.identifier)
         });
       else if (result.kind === "budget") {
-        parkReason = "budget";
+        park = {
+          reason: "tokens",
+          message: BUILD_STRINGS.tokenParkRefused(
+            entry.identifier,
+            attemptForecast(entry.tokenCap)
+          )
+        };
         break;
       } else {
         state.needsPerson[entry.id] = BUILD_STRINGS.startRefused(result.code);
@@ -14721,6 +14862,24 @@ async function runBuildTick(deps) {
     }
     if (installed) removeWorkflow(entry.workflowName);
   }
+  const linear = reconcile({
+    project: input.project,
+    entries,
+    issues: input.issues,
+    attempts: state.attempts,
+    children: children.runs,
+    pullRequests: assessment.pullRequests,
+    posted: state.posted ?? []
+  });
+  const passes = state.reconcilePasses ?? 0;
+  if (linear.actions.length > 0 && passes < RECONCILE_PASSES) {
+    state.reconcilePasses = passes + 1;
+    if (linear.posted.length > 0)
+      state.posted = [...state.posted ?? [], ...linear.posted];
+    record();
+    return { action: "reconcile", actions: linear.actions };
+  }
+  delete state.reconcilePasses;
   record();
   if (behind.length > 0) return { action: "rebase", items: behind };
   return tickAction({
@@ -14728,7 +14887,7 @@ async function runBuildTick(deps) {
     status,
     children: children.runs,
     started,
-    ...parkReason ? { parkReason } : {}
+    ...park ? { park } : {}
   });
 }
 function locate(deps, entry, branchName) {
@@ -15080,8 +15239,120 @@ function runBuildCheck(input) {
   return code;
 }
 
+// src/core/build/supervision.ts
+import { randomUUID as randomUUID3 } from "crypto";
+async function superviseChild(input) {
+  const { hub, parentId, operation } = input;
+  if (operation === "children") return hub.runs({ parent: parentId });
+  if (!input.childId) throw new BuildUsageError("A child Run id is required.");
+  const child = await hub.run(input.childId);
+  if (child.parent?.runId !== parentId)
+    throw new BuildUsageError(
+      "Only a direct child of this Build can be inspected or guided."
+    );
+  if (operation === "inspect") {
+    const after = input.after ?? 0;
+    if (!Number.isSafeInteger(after) || after < 0)
+      throw new BuildUsageError(
+        "The history cursor must be a nonnegative integer."
+      );
+    return { child, history: await hub.historyPage(child.runId, after) };
+  }
+  const text = input.text?.trim();
+  if (!text || text.length > 12e4)
+    throw new BuildUsageError("Guidance must contain 1\u2013120000 characters.");
+  if (child.closed || child.cancellation)
+    throw new BuildUsageError("The child is closed or cancelling.");
+  const interruption = child.execution?.interruption;
+  const message = `Orchestrator ${parentId} technical guidance (not a human approval):
+${text}`;
+  const { hubEpoch } = await hub.runs({ parent: parentId });
+  const base = {
+    commandId: randomUUID3(),
+    hubEpoch,
+    runId: child.runId,
+    expectedRecordRevision: child.recordRevision
+  };
+  if (child.execution?.status === "awaiting_attention") {
+    if (interruption?.kind !== "question" || interruption.respondent !== "orchestrator" || interruption.requestId)
+      throw new BuildUsageError(
+        "This interruption is reserved for a member. Inspect it and escalate the specific decision."
+      );
+    return hub.submit({
+      ...base,
+      intent: {
+        kind: "answer",
+        interruptionId: interruption.interruptionId,
+        expectedInterruptionRevision: interruption.revision,
+        answer: message
+      }
+    });
+  }
+  if (child.execution?.status !== "running")
+    throw new BuildUsageError(
+      "The child is not running; inspect its scheduling state before retrying."
+    );
+  return hub.submit({ ...base, intent: { kind: "steer", text: message } });
+}
+
+// src/core/build/evidenceCopy.ts
+import fs11 from "fs";
+import path11 from "path";
+function copyEvidence(cwd, source, name) {
+  if (!source || !name || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*\.(png|jpe?g|webp)$/i.test(name))
+    throw new BuildUsageError(
+      "Usage: drisp build evidence-copy <screenshot> <filename.png|jpg|webp>"
+    );
+  const root = fs11.realpathSync(cwd);
+  let directory = root;
+  for (const part of [".athena", "evidence"]) {
+    directory = path11.join(directory, part);
+    try {
+      fs11.mkdirSync(directory);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+    const stat = fs11.lstatSync(directory);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+      throw new BuildUsageError(
+        "Evidence directories must be real directories inside this worktree."
+      );
+  }
+  const sourcePath = path11.resolve(root, source);
+  const fd = fs11.openSync(
+    sourcePath,
+    fs11.constants.O_RDONLY | fs11.constants.O_NOFOLLOW
+  );
+  let bytes;
+  try {
+    const stat = fs11.fstatSync(fd);
+    if (!stat.isFile() || stat.size > 25 * 1024 * 1024)
+      throw new BuildUsageError(
+        "A screenshot must be a regular image file of at most 25 MiB."
+      );
+    bytes = fs11.readFileSync(fd);
+  } finally {
+    fs11.closeSync(fd);
+  }
+  const png = bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
+  const jpg = bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255;
+  const webp = bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP";
+  const extension = path11.extname(name).toLowerCase();
+  if (!(extension === ".png" && png || [".jpg", ".jpeg"].includes(extension) && jpg || extension === ".webp" && webp))
+    throw new BuildUsageError(
+      "The source must be a PNG, JPEG or WebP screenshot matching the destination extension."
+    );
+  const target = path11.join(directory, name);
+  fs11.writeFileSync(target, bytes, { flag: "wx" });
+  return { path: target };
+}
+
 // src/app/entry/buildCommand.ts
 var USAGE3 = `Usage: drisp build plan --input <path>
+       drisp build children
+       drisp build inspect <child-run-id> [history-cursor]
+       drisp build guide <child-run-id> "<technical guidance>"
+       drisp build evidence-copy <screenshot> <filename.png|jpg|webp>
        drisp build tick --input <path> [--rebase-failed <IDENTIFIER>]...
        drisp build checks
        drisp build step <n> [--qa none|web|macos|both] [--profile implementation|documentation|investigation]
@@ -15124,10 +15395,12 @@ function githubPullRequests(folder, branch) {
 function parsePullRequests(output) {
   const prs = JSON.parse(output);
   const merged = prs.find((pr) => pr.state === "MERGED");
+  const open = prs.find((pr) => pr.state === "OPEN");
   return {
-    open: prs.some((pr) => pr.state === "OPEN"),
+    open: open !== void 0,
     merged: merged !== void 0,
-    ...merged ? { mergedUrl: merged.url } : {}
+    ...merged ? { mergedUrl: merged.url } : {},
+    ...open ? { openUrl: open.url } : {}
   };
 }
 function hostCapabilities(folder) {
@@ -15199,6 +15472,31 @@ async function runBuildCommand(input) {
   try {
     let output;
     switch (input.subcommand) {
+      case "evidence-copy":
+        output = copyEvidence(
+          input.cwd,
+          input.positional?.[0],
+          input.positional?.[1]
+        );
+        break;
+      case "children":
+      case "inspect":
+      case "guide": {
+        const parentId = requireEnv(env2, "DRISP_RUN_ID");
+        const hub = input.supervisionHub ?? DrispClient.delegated(
+          requireEnv(env2, "DRISP_HUB_URL"),
+          requireEnv(env2, "DRISP_RUN_TOKEN")
+        );
+        output = await superviseChild({
+          hub,
+          parentId,
+          operation: input.subcommand,
+          childId: input.positional?.[0],
+          text: input.positional?.[1],
+          ...input.subcommand === "inspect" && input.positional?.[1] !== void 0 ? { after: Number(input.positional[1]) } : {}
+        });
+        break;
+      }
       case "plan": {
         const calibration = input.dependencies?.calibration ?? await measuredForecasts(env2);
         output = runBuildPlan({
@@ -15292,9 +15590,9 @@ import process7 from "process";
 
 // src/harnesses/claude/system/doctorEnvironment.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as os4 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 var MANAGED_POLICY_KEYS = [
   "forceLoginMethod",
   "forceLoginOrgUUID",
@@ -15398,8 +15696,8 @@ function collectEnvironment(options = {}) {
   const detectVersion = options.detectClaudeVersionFn ?? detectClaudeVersion;
   const runAuthStatus = options.runClaudeAuthStatusFn ?? runClaudeAuthStatus;
   const resolveForwarder = options.resolveHookForwarderCommandFn ?? resolveHookForwarderCommand;
-  const statFn = options.statFn ?? ((p) => fs11.statSync(p));
-  const readFileFn = options.readFileFn ?? ((p) => fs11.readFileSync(p, "utf8"));
+  const statFn = options.statFn ?? ((p) => fs12.statSync(p));
+  const readFileFn = options.readFileFn ?? ((p) => fs12.readFileSync(p, "utf8"));
   const settingsPaths = resolveClaudeSettingsSurfacePaths(
     homeDir,
     cwd,
@@ -15444,7 +15742,7 @@ function collectEnvironment(options = {}) {
   });
   let globalConfigPresent = false;
   try {
-    statFn(path11.join(homeDir, ".claude.json"));
+    statFn(path12.join(homeDir, ".claude.json"));
     globalConfigPresent = true;
   } catch {
     globalConfigPresent = false;
@@ -15924,13 +16222,13 @@ function runRunsCommand(input) {
 // src/app/entry/cli.tsx
 import { jsx as jsx24 } from "react/jsx-runtime";
 function resolvePackageJsonPath(entryUrl) {
-  let currentDir = path12.dirname(fileURLToPath(entryUrl));
+  let currentDir = path13.dirname(fileURLToPath(entryUrl));
   for (; ; ) {
-    const candidatePath = path12.join(currentDir, "package.json");
-    if (fs12.existsSync(candidatePath)) {
+    const candidatePath = path13.join(currentDir, "package.json");
+    if (fs13.existsSync(candidatePath)) {
       return candidatePath;
     }
-    const parentDir = path12.dirname(currentDir);
+    const parentDir = path13.dirname(currentDir);
     if (parentDir === currentDir) {
       throw new Error("Could not locate package.json for CLI metadata.");
     }
@@ -16100,6 +16398,10 @@ var cli = meow(
 			runner [sub]          Run the runner that connects this machine to a Team and executes its Runs
 			                      (no subcommand: foreground; connect [code] --hub <url> [--replace], disconnect [team], status, restart, recover, help)
 			build plan --input <path>  Plan a Build inside an Orchestrator Run (prints one JSON object)
+			build children             List this Build's children and their interruptions
+			build inspect <run> [cursor] Read a child's state and paged history
+			build guide <run> "<text>"  Guide a child or answer its delegated technical question
+			build evidence-copy <image> <name> Copy a screenshot into this worktree's evidence directory
 			build tick --input <path>  Run one step of a started Build (prints the next action; [--rebase-failed <ID>]...)
 			build checks               The merge gate's verdict on HEAD's GitHub runs (in a child's worktree)
 			build step <n>             Report the Run's current step: writes the step run artifact ([--qa none|web|macos|both], --profile, --merge you, --sign-off <sha>, --complete --evidence, --verify)
@@ -16292,7 +16594,7 @@ var cli = meow(
   }
 );
 async function main() {
-  const projectDir = path12.resolve(cli.flags.projectDir);
+  const projectDir = path13.resolve(cli.flags.projectDir);
   const [command, ...commandArgs] = cli.input;
   const isRunCommand = command === "run" || command === "exec";
   if (command && !KNOWN_COMMANDS.has(command)) {
@@ -16346,7 +16648,7 @@ Available commands: ${[...KNOWN_COMMANDS].join(", ")}`
         await exitWith(1);
         return;
       }
-      const { default: WorkflowInstallWizard } = await import("./WorkflowInstallWizard-FKASDA6N.js");
+      const { default: WorkflowInstallWizard } = await import("./WorkflowInstallWizard-VPBOZJY5.js");
       const { waitUntilExit } = render(
         /* @__PURE__ */ jsx24(
           WorkflowInstallWizard,
@@ -16526,8 +16828,8 @@ Available commands: ${[...KNOWN_COMMANDS].join(", ")}`
   const showSetup = isRunCommand ? false : shouldShowSetup({
     cliInput: cli.input,
     setupComplete: globalConfig.setupComplete,
-    globalConfigExists: fs12.existsSync(
-      path12.join(os5.homedir(), ".config", "athena", "config.json")
+    globalConfigExists: fs13.existsSync(
+      path13.join(os5.homedir(), ".config", "athena", "config.json")
     )
   });
   let runtimeConfig;