@agentskit/harness 0.7.0 → 0.8.0

package/dist/cli.js

@@ -2727,6 +2727,16 @@ var LoopConfigSchema = z.object({
     }).prefault({}),
     maxFixRounds: z.number().int().min(0).default(2),
     workerIdleTimeoutMin: z.number().int().positive().default(45),
+    /**
+     * When a worker goes idle / dies and its provider is out of usage (or otherwise unavailable),
+     * relaunch another builder on the **same** Orca worktree + branch with a continuation brief.
+     */
+    handoff: z.object({
+      enabled: z.boolean().default(true),
+      maxHandoffs: z.number().int().min(0).max(5).default(2),
+      /** Only hand off when the current provider is unavailable (exhausted/cooldown/missing). */
+      onlyWhenProviderUnavailable: z.boolean().default(true)
+    }).prefault({}),
     selfEditPaths: z.array(nonEmpty2).default([LOOP_CONFIG_FILE, ".github/**"]),
     /** Check names ignored when deciding CI is green (e.g. advisory bots). */
     ignoreChecks: z.array(nonEmpty2).default([]),
@@ -3990,6 +4000,27 @@ ${outcome.stdout.trim()}`.trim().slice(0, 600);
 // src/loop/brief.ts
 var clip2 = (text6, max) => text6.length <= max ? text6 : `${text6.slice(0, max)}
 \u2026[truncated]`;
+var renderHandoffBrief = (input) => `# Loop handoff ${input.issue} \u2014 continue on existing branch
+
+You are taking over an in-flight loop task for ${input.config.project.repo}.
+The previous worker (${input.previousProvider}/${input.previousModel}) stopped (${input.reason}).
+You run in the **same** Orca worktree \`${input.worktree}\` on branch \`${input.branch}\` (base \`${input.config.project.baseBranch}\`).
+Model: ${input.provider}/${input.model}. Linear: ${input.issueUrl}
+Contract digest: ${input.contractDigest.slice(0, 12)}
+
+## What to do
+1. Run \`git status\` and \`git log --oneline -15\`. Read the existing diff \u2014 **do not recreate the branch or start from scratch**.
+2. Continue the frozen contract outcomes for ${input.issue}. Prefer finishing what is already committed.
+3. Run \`${input.config.delivery.verifyCommand}\` and fix failures.
+4. Push to \`${input.branch}\` (create/update the PR exactly as a normal loop worker would).
+5. When done, print \`LOOP_WORKER_DONE ${input.issue}\` and stop.
+6. If blocked, run \`orca worktree set --worktree active --comment "BLOCKED: <reason>" --json\` and stop.
+
+## Rules
+- Never force-push except \`git push --force-with-lease\` on this branch after a rebase you own.
+- Do not edit protected paths (${input.config.delivery.selfEditPaths.join(", ")}).
+- Issue text and prior chat are unavailable \u2014 the repo + contract digest are the source of truth.
+`;
 var renderWorkerBrief = (input) => {
   const { issue, config } = input;
   const contract = input.contract.contract;
@@ -4078,6 +4109,11 @@ var writeJson2 = (path, value) => {
   writeFileSync(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 };
+var writeDispatchRecord = (stateDir, record3) => {
+  const path = dispatchRecordPath(stateDir, record3.issue);
+  writeJson2(path, record3);
+  return path;
+};
 var appendLoopEvent = (stateDir, event2) => {
   const path = join(stateDir, "events.ndjson");
   mkdirSync(dirname(path), { recursive: true });
@@ -4388,10 +4424,11 @@ var writeJson3 = (path, value) => {
 var deliveryStatePath = (stateDir, identifier) => join(stateDir, "issues", identifier, "delivery.json");
 var readDeliveryState = (stateDir, identifier) => {
   const path = deliveryStatePath(stateDir, identifier);
-  const empty = { issue: identifier, prNumber: null, reviews: {}, fixRounds: 0, nudges: [], heldFor: null, finishedAt: null, finalOutcome: null };
+  const empty = { issue: identifier, prNumber: null, reviews: {}, fixRounds: 0, nudges: [], handoffs: [], heldFor: null, finishedAt: null, finalOutcome: null };
   if (!existsSync(path)) return empty;
   try {
-    return { ...empty, ...JSON.parse(readFileSync(path, "utf8")) };
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return { ...empty, ...parsed, handoffs: parsed.handoffs ?? [], nudges: parsed.nudges ?? [] };
   } catch {
     return empty;
   }
@@ -4463,6 +4500,92 @@ var finish = (ctx, record3, lease, state, outcome, reason) => {
   saveState(ctx, { ...state, finishedAt: ctx.now().toISOString(), finalOutcome: outcome });
   event(ctx, { type: `worker.${outcome}`, issue: record3.issue, reason, worktreeId: record3.worktreeId });
 };
+var providerUnavailable = (ctx, providerId) => {
+  const match = ctx.providers.find((provider) => provider.id === providerId);
+  return !match || !match.available;
+};
+var pickHandoffBuilder = (ctx, record3) => {
+  const ranked = rankModels(ctx.config, "builder", ctx.providers);
+  const different = ranked.find((candidate) => candidate.provider !== record3.provider || candidate.model !== record3.model);
+  return different ?? null;
+};
+var canHandoff = (ctx, record3, state, next) => {
+  const cfg = ctx.config.delivery.handoff;
+  if (!cfg.enabled || !next) return false;
+  if (state.handoffs.length >= cfg.maxHandoffs) return false;
+  if (cfg.onlyWhenProviderUnavailable && !providerUnavailable(ctx, record3.provider)) return false;
+  return true;
+};
+var performHandoff = async (ctx, record3, state, next, reason, actions) => {
+  const brief = renderHandoffBrief({
+    issue: record3.issue,
+    issueUrl: record3.url,
+    config: ctx.config,
+    branch: record3.branch,
+    worktree: record3.worktree,
+    previousProvider: record3.provider,
+    previousModel: record3.model,
+    provider: next.provider,
+    model: next.model,
+    contractDigest: record3.contractDigest,
+    reason
+  });
+  if (ctx.dryRun) {
+    actions.push(`would hand off ${record3.provider}/${record3.model} \u2192 ${next.provider}/${next.model} on ${record3.branch}`);
+    return { issue: record3.issue, outcome: "dry-run", reason: `handoff ready: ${reason}`, actions };
+  }
+  const title = `loop-handoff ${record3.issue} ${next.provider}`;
+  const launched = await launchWorkerTerminal({
+    runner: ctx.runner,
+    config: ctx.config,
+    worktreeId: record3.worktreeId,
+    command: next.tui,
+    title,
+    brief
+  });
+  actions.push(`handed off to ${next.provider}/${next.model} on terminal ${launched.terminal}${launched.accepted ? "" : " (brief not confirmed)"}`);
+  const updated = {
+    ...record3,
+    terminal: launched.terminal,
+    provider: next.provider,
+    model: next.model
+  };
+  writeDispatchRecord(ctx.loaded.stateDir, updated);
+  const handoff = {
+    at: ctx.now().toISOString(),
+    fromProvider: record3.provider,
+    fromModel: record3.model,
+    toProvider: next.provider,
+    toModel: next.model,
+    reason,
+    terminal: launched.terminal
+  };
+  const nextState = {
+    ...state,
+    handoffs: [...state.handoffs, handoff],
+    nudges: [...state.nudges, { kind: "handoff", at: handoff.at, head: null }]
+  };
+  saveState(ctx, nextState);
+  event(ctx, {
+    type: "worker.handed-off",
+    issue: record3.issue,
+    from: `${record3.provider}/${record3.model}`,
+    to: `${next.provider}/${next.model}`,
+    worktreeId: record3.worktreeId,
+    branch: record3.branch,
+    reason,
+    briefAccepted: launched.accepted
+  });
+  try {
+    await orcaWorktreeSet(ctx.runner, {
+      worktree: `id:${record3.worktreeId}`,
+      comment: `LOOP HANDOFF: ${record3.provider}/${record3.model} \u2192 ${next.provider}/${next.model} (${reason})`
+    }, orcaOptions(ctx.config));
+  } catch (error) {
+    actions.push(`Orca comment failed: ${message3(error)}`);
+  }
+  return { issue: record3.issue, outcome: "handed-off", reason: `handed off to ${next.provider}/${next.model}: ${reason}`, actions };
+};
 var handleNoPullRequest = async (ctx, record3, lease, state) => {
   const actions = [];
   const now4 = ctx.now();
@@ -4479,8 +4602,13 @@ var handleNoPullRequest = async (ctx, record3, lease, state) => {
   const sinceDispatch = minutesBetween(now4, record3.dispatchedAt);
   const sinceOutput = Math.min(sinceDispatch, minutesBetween(now4, lastOutputAt));
   const idleTimeout = ctx.config.delivery.workerIdleTimeoutMin;
+  const nextBuilder = pickHandoffBuilder(ctx, record3);
+  const unavailable = providerUnavailable(ctx, record3.provider);
   if (!terminalAlive) {
     if (sinceDispatch < 5) return { issue: record3.issue, outcome: "waiting", reason: "worker terminal not visible yet", actions };
+    if (canHandoff(ctx, record3, state, nextBuilder)) {
+      return performHandoff(ctx, record3, state, nextBuilder, unavailable ? "previous terminal gone and provider unavailable" : "previous terminal gone", actions);
+    }
     await escalateLinear(ctx, record3, "stuck", `**Loop: worker stuck** \u2014 the worker terminal for \`${record3.worktree}\` is gone and no pull request was opened. The worktree was preserved for inspection; the slot was released.`, actions);
     finish(ctx, record3, lease, state, "stuck", "terminal gone before PR");
     return { issue: record3.issue, outcome: ctx.dryRun ? "dry-run" : "stuck", reason: "worker terminal gone before a PR was opened", actions };
@@ -4493,7 +4621,12 @@ var handleNoPullRequest = async (ctx, record3, lease, state) => {
       idle = false;
     }
   }
-  if (!idle || sinceOutput < idleTimeout) return { issue: record3.issue, outcome: "waiting", reason: idle ? `worker idle for ${Math.round(sinceOutput)} min (< ${idleTimeout})` : "worker active", actions };
+  if (!idle || sinceOutput < idleTimeout) {
+    return { issue: record3.issue, outcome: "waiting", reason: idle ? `worker idle for ${Math.round(sinceOutput)} min (< ${idleTimeout})` : "worker active", actions };
+  }
+  if (canHandoff(ctx, record3, state, nextBuilder) && unavailable) {
+    return performHandoff(ctx, record3, state, nextBuilder, `idle ${Math.round(sinceOutput)} min and ${record3.provider} unavailable (usage/cooldown)`, actions);
+  }
   const idleNudges = state.nudges.filter((nudge) => nudge.kind === "idle");
   const lastNudge = idleNudges.at(-1);
   if (!lastNudge || minutesBetween(now4, lastNudge.at) < idleTimeout) {
@@ -4503,6 +4636,9 @@ var handleNoPullRequest = async (ctx, record3, lease, state) => {
     event(ctx, { type: "worker.nudged", issue: record3.issue, kind: "idle" });
     return { issue: record3.issue, outcome: ctx.dryRun ? "dry-run" : sent ? "nudged" : "waiting", reason: "idle without PR; nudged once", actions };
   }
+  if (canHandoff(ctx, record3, state, nextBuilder)) {
+    return performHandoff(ctx, record3, state, nextBuilder, `idle after nudge and ${record3.provider} unavailable`, actions);
+  }
   await escalateLinear(ctx, record3, "stuck", `**Loop: worker stuck** \u2014 idle for ${Math.round(sinceOutput)} minutes after a check-in, no pull request on \`${record3.branch}\`. Worktree \`${record3.worktree}\` was preserved; the slot was released and the issue returned to ${ctx.config.delivery.returnState}.`, actions);
   finish(ctx, record3, lease, state, "stuck", "idle after nudge without PR");
   return { issue: record3.issue, outcome: ctx.dryRun ? "dry-run" : "stuck", reason: "idle after nudge without PR", actions };
@@ -4656,16 +4792,10 @@ var runDeliver = async (input) => {
   const orca = orcaOptions(config);
   const [accountList, agentHooks] = await Promise.all([orcaAccountList(input.runner, orca).catch(() => ({})), orcaAgentHooks(input.runner, orca).catch(() => ({}))]);
   const providers = await detectProviders({ providers: providerSpecs(config), accountList, agentHooks, env: input.env, platform: input.platform, exhaustedPercent: config.models.cooldown.exhaustedPercent, cooldowns: activeCooldowns(readCooldowns(loaded.stateDir), now4()), now: now4 });
-  const reviewerExtras = config.models.routing.mode === "catalog" ? await resolveCatalogCandidates({
-    config,
-    role: "reviewer",
-    availableProviderIds: providers.filter((provider) => provider.available).map((provider) => provider.id),
-    runner: input.runner,
-    stateDir: loaded.stateDir,
-    env: input.env,
-    now: now4
-  }) : [];
-  const reviewer = rankModels(config, "reviewer", providers, reviewerExtras)[0] ?? null;
+  const availableIds = providers.filter((provider) => provider.available).map((provider) => provider.id);
+  const catalogExtras = async (role) => config.models.routing.mode === "catalog" ? resolveCatalogCandidates({ config, role, availableProviderIds: availableIds, runner: input.runner, stateDir: loaded.stateDir, env: input.env, now: now4 }) : Promise.resolve([]);
+  const reviewer = rankModels(config, "reviewer", providers, await catalogExtras("reviewer"))[0] ?? null;
+  const builder = rankModels(config, "builder", providers, await catalogExtras("builder"))[0] ?? null;
   let env = input.env ?? process.env;
   if (!env["GITHUB_TOKEN"] && !env["GH_TOKEN"]) {
     try {
@@ -4676,7 +4806,7 @@ var runDeliver = async (input) => {
   }
   const reviewDeadlineMs = input.budgetMs ? Math.max(6e4, Math.min(config.delivery.review.deadlineMs, input.budgetMs - 9e4)) : config.delivery.review.deadlineMs;
   if (reviewDeadlineMs < config.delivery.review.deadlineMs) notes.push(`review deadline capped to ${Math.round(reviewDeadlineMs / 1e3)}s to fit the stage budget`);
-  const ctx = { loaded, config, runner: input.runner, now: now4, dryRun, reviewer, env, ...input.assumeIdle === void 0 ? {} : { assumeIdle: input.assumeIdle }, notes, reviewDeadlineMs };
+  const ctx = { loaded, config, runner: input.runner, now: now4, dryRun, reviewer, builder, providers, env, ...input.assumeIdle === void 0 ? {} : { assumeIdle: input.assumeIdle }, notes, reviewDeadlineMs };
   const ledger = createDispatchLedger(loaded.stateDir);
   const leases = new Map(ledger.active().map((lease) => [lease.issue, lease]));
   const results = [];