toyon 0.8.0 → 0.8.1

package/dist/cli.js

@@ -5158,7 +5158,7 @@ function parseVersion(v) {
 // package.json
 var package_default = {
   name: "toyon",
-  version: "0.8.0",
+  version: "0.8.1",
   description: "Toyon is where coding agents work on your web app while you check each change by using it. Every chat gets its own running copy with a live preview.",
   license: "MIT",
   type: "module",
@@ -6181,6 +6181,19 @@ function policyLines(m, daemon) {
   }
   return lines;
 }
+function agentLines(agents) {
+  const level = agents.filter((a) => a.installed === a.pinned);
+  const lines = [];
+  if (level.length > 0)
+    lines.push(line(true, "agents", level.map((a) => `${a.id} ${a.installed}`).join(", ")));
+  for (const a of agents) {
+    if (a.installed === a.pinned)
+      continue;
+    const why = a.error ? `: ${a.error}` : "; it may still be installing";
+    lines.push(line(false, "agents", a.installed === null ? `${a.id} ${a.pinned} is not installed${why}` : `${a.id} runs ${a.installed}, not the pinned ${a.pinned}${why}. \`toyon restart\` tries again`));
+  }
+  return lines;
+}
 async function doctor() {
   const lines = [];
   lines.push(line(true, "cli", `toyon ${package_default.version}, bun ${Bun.version}, ${process.platform} ${process.arch}`));
@@ -6209,6 +6222,8 @@ async function doctor() {
       const { total, running } = h.worktrees;
       lines.push(line(true, "running", `${running} of ${total} worktrees started; the rest start when opened`));
     }
+    if (h.agents)
+      lines.push(...agentLines(h.agents));
     if (version !== package_default.version) {
       lines.push(line(false, "version", `cli is ${package_default.version} and the daemon is ${version}; \`toyon restart\` brings them level`));
     }

package/dist/daemon.js

@@ -6469,7 +6469,7 @@ var PAIR_TTL_MS = 120000;
 var pairLink = (host, code) => `https://${host}/#pair=${code}`;
 
 // ../shared/src/protocol/limits.ts
-var PROTOCOL_VERSION = 82;
+var PROTOCOL_VERSION = 83;
 var FILE_MAX_CHARS = 5000000;
 var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 var IMAGE_MAX_EDGE = 2576;
@@ -7882,15 +7882,6 @@ function installCommand(method, version) {
     return ["bun", "add", "-g", `toyon@${version}`];
   return null;
 }
-function registryHost(registry) {
-  if (registry === null || registry === "")
-    return "the npm registry";
-  try {
-    return new URL(registry).host;
-  } catch {
-    return registry;
-  }
-}
 function newer(a, b) {
   const pa = parseVersion(a);
   const pb = parseVersion(b);
@@ -8163,7 +8154,7 @@ function safeUser() {
 // ../daemon/package.json
 var package_default = {
   name: "@toyon/daemon",
-  version: "0.8.0",
+  version: "0.8.1",
   private: true,
   type: "module",
   main: "src/index.ts",
@@ -13667,6 +13658,19 @@ class AgentRegistry {
       await this.install(id);
     }
   }
+  adapters() {
+    const out = [];
+    for (const spec of this.list()) {
+      if (spec.run.kind === "command" || !this.packageName(spec))
+        continue;
+      const installed = this.installed(spec) ? this.installedVersion(spec) : null;
+      const error = this.installErrors.get(spec.id);
+      if (spec.onDemand && installed === null && !error)
+        continue;
+      out.push({ id: spec.id, installed, pinned: spec.run.version, ...error ? { error } : {} });
+    }
+    return out;
+  }
   infos() {
     return this.list().map((spec) => {
       const reason = this.unavailable(spec);
@@ -14145,6 +14149,9 @@ function backgroundStart(input, output) {
   const m = STARTED.exec(output);
   return m ? { taskId: m[1], file: m[2] } : null;
 }
+function spawnDetached(output) {
+  return output.includes("Async agent launched successfully");
+}
 function claudeConfigDir() {
   return process.env.CLAUDE_CONFIG_DIR || join7(homedir4(), ".claude");
 }
@@ -14466,7 +14473,8 @@ function spawnOf(meta) {
   const claude = asRecord(asRecord(meta).claudeCode);
   const parentToolId = typeof claude.parentToolUseId === "string" ? claude.parentToolUseId : undefined;
   const codex = asRecord(asRecord(meta).codex).subagent;
-  const subagent = claude.subagent === true || Object.keys(asRecord(codex)).length > 0;
+  const spawns = claude.toolName === "Agent" || claude.toolName === "Task";
+  const subagent = spawns || claude.subagent === true || Object.keys(asRecord(codex)).length > 0;
   return { ...parentToolId ? { parentToolId } : {}, ...subagent ? { subagent: true } : {} };
 }
 function asRecord(v) {
@@ -14556,7 +14564,8 @@ function mapUpdate(update, memos, tag, sink, background) {
         rawOutput: update.rawOutput,
         ended: false,
         writing: isWrittenKind(head.kind) && emptyInput(input),
-        ...spawn.parentToolId ? { parent: spawn.parentToolId } : {}
+        ...spawn.parentToolId ? { parent: spawn.parentToolId } : {},
+        ...spawn.subagent ? { spawns: true } : {}
       };
       memos.set(update.toolCallId, memo);
       out.push({
@@ -14586,7 +14595,8 @@ function mapUpdate(update, memos, tag, sink, background) {
           content: [],
           ended: false,
           writing: isWrittenKind(update.kind ?? undefined) && emptyInput(input),
-          ...spawn.parentToolId ? { parent: spawn.parentToolId } : {}
+          ...spawn.parentToolId ? { parent: spawn.parentToolId } : {},
+          ...spawn.subagent ? { spawns: true } : {}
         };
         memos.set(update.toolCallId, memo);
         out.push({
@@ -14664,14 +14674,23 @@ function endOf(toolId, memo, status, sink, background) {
       return { type: "tool-update", toolId, background: true };
   }
   const images = sink ? toolImages(memo.content, sink) : [];
+  const detached = status === "completed" && !!memo.spawns && spawnDetached(wholeText(memo.content, memo.rawOutput));
   return {
     type: "tool-end",
     toolId,
     output,
     isError: status === "failed" || exitCodeOf(memo.rawOutput) > 0,
+    ...detached ? { detached: true } : {},
     ...images.length ? { images } : {}
   };
 }
+function wholeText(content, rawOutput) {
+  const parts = content.flatMap((c) => c.type === "content" && c.content.type === "text" ? [c.content.text] : []);
+  if (typeof rawOutput === "string")
+    parts.push(rawOutput);
+  return parts.join(`
+`);
+}
 function toolImages(content, sink) {
   const out = [];
   for (const c of content) {
@@ -15267,7 +15286,8 @@ class AcpSession {
           sessionId,
           cwd: this.d.cwd,
           mcpServers: [],
-          additionalDirectories
+          additionalDirectories,
+          ...conn.spec.systemPrompt === "meta-append" ? { _meta: { systemPrompt: { append: SYSTEM_APPEND } } } : {}
         });
         modes = r.modes;
         configOptions = r.configOptions;
@@ -26123,8 +26143,8 @@ var handlers = {
   "update-now"(_msg, _ctx, s) {
     return s.update.updateNow();
   },
-  "check-update"(_msg, _ctx, s) {
-    return s.update.checkNow();
+  async "check-update"(_msg, ctx, s) {
+    ctx.reply({ t: "update-checked", check: await s.update.checkNow() });
   },
   async commit(msg, ctx, s) {
     const result = await s.worktrees.commit(msg.worktreeId, msg.message);
@@ -26695,6 +26715,7 @@ function startServer(opts) {
     },
     costs: s.idle.costs(),
     updates: s.update.status(),
+    agents: s.agents.adapters(),
     sockets: [...sockets].map((ws) => ({ subs: [...ws.data.subs], sent: ws.data.sent, bytes: ws.data.bytes }))
   });
   let statusesInFlight = false;
@@ -27295,16 +27316,20 @@ class UpdateService {
   async check() {
     if (this.d.method === "none" || this.d.managedBy)
       return;
+    await this.ask();
+  }
+  async ask() {
     const answer = await this.d.latest();
     this.registryName = answer.registry;
     if (answer.version === null) {
       this.unreachable = answer.registry;
-      return;
+      return { registry: answer.registry, latest: null };
     }
     this.unreachable = null;
     this.latest = newer(answer.version, this.d.running) ? answer.version : null;
     this.announce();
     await this.auto();
+    return { registry: answer.registry, latest: answer.version };
   }
   async updateNow() {
     this.refuseManaged();
@@ -27321,14 +27346,17 @@ class UpdateService {
   async checkNow() {
     this.refuseManaged();
     if (this.d.method === "none") {
-      throw new UserError(`Toyon ${this.d.running} runs from a checkout, which does not update itself`);
+      const answer = await this.d.latest();
+      return { registry: answer.registry, latest: answer.version };
     }
-    await this.check();
-    if (this.unreachable)
-      throw new UserError(`Could not reach ${this.unreachable}`);
-    if (this.target() === null) {
-      throw new UserError(`Toyon ${this.d.running} is the newest version ${registryHost(this.registryName)} lists`);
+    const answer = await this.ask();
+    const target = this.target();
+    if (target !== null && !this.wanted && !(this.needsInstall() && this.d.command(target) === null)) {
+      this.failed = null;
+      this.wanted = true;
+      fireAndForget("update", this.proceed(), "update");
     }
+    return answer;
   }
   install() {
     return this.d.method;
@@ -27983,9 +28011,14 @@ class LandingService {
     d.hub.on("agentStatus", (id, status) => {
       this.note(id, status);
       if (status === "working")
-        this.clear(id);
+        this.turnStarts(id);
     });
   }
+  turnStarts(worktreeId) {
+    if (!this.d.state.worktree(worktreeId)?.landing?.ready)
+      return this.clear(worktreeId);
+    this.judging.delete(worktreeId);
+  }
   note(worktreeId, status) {
     if (status === "working" || status === "waiting")
       this.busy.add(worktreeId);
@@ -28011,14 +28044,69 @@ class LandingService {
     const wt = this.d.state.worktree(worktreeId);
     if (!wt || !canLand(wt))
       return;
-    if (turn.end !== "done")
-      return this.clear(worktreeId);
+    const held = await this.standing(wt);
+    if (turn.end !== "done") {
+      if (!held)
+        this.clear(worktreeId);
+      return;
+    }
     if (!await this.hasWork(wt)) {
       this.clear(worktreeId);
       return this.recapAnswer(wt, turn);
     }
+    if (held)
+      return this.reword(wt, turn, held);
     await this.run(wt, { at: turn.at, ask: true, quiet: false });
   }
+  async standing(wt) {
+    const l = wt.landing;
+    if (!l?.ready)
+      return;
+    return l.fingerprint === await treeFingerprint(wt.path) ? l : undefined;
+  }
+  async reword(wt, turn, held) {
+    if (!this.d.judge)
+      return;
+    const worktreeId = wt.id;
+    const repo = this.d.state.requireRepo(wt.repoId);
+    this.judging.set(worktreeId, turn.at);
+    const started = Date.now();
+    const entries = this.d.transcript(worktreeId);
+    const prompt = landPrompt({
+      title: wt.title,
+      firstAsk: firstAskOf(entries),
+      turns: turnsSince(entries, 0),
+      diffStat: await diffSummary(wt.path, baseOf(repo)),
+      recentSubjects: await recentSubjects(wt.path, baseOf(repo))
+    });
+    let verdict = null;
+    try {
+      verdict = await this.d.judge(wt, prompt);
+    } catch (e) {
+      log.warn(worktreeId, "landing verdict kept its words: the question went unanswered", e);
+    }
+    if (this.stopping || this.judging.get(worktreeId) !== turn.at)
+      return;
+    this.judging.delete(worktreeId);
+    const row = this.d.state.worktree(worktreeId);
+    const now = row?.landing;
+    if (!verdict || !row || !now?.ready || now.fingerprint !== held.fingerprint)
+      return;
+    const { why: _was, stale: _moved, ...rest } = now;
+    const caveat = await this.sharedMigration(wt, repo);
+    const doubt = [!verdict.ready && verdict.why ? verdict.why : "", caveat ?? ""].filter(Boolean).join(". ");
+    const landing = { ...rest, at: turn.at, ...doubt ? { why: doubt } : {} };
+    if (!landing.subject && verdict.subject) {
+      landing.subject = verdict.subject;
+      if (verdict.body)
+        landing.body = verdict.body;
+      delete landing.unanswered;
+    }
+    if (row.lastTurn?.at === turn.at && verdict.recap)
+      row.lastTurn.recap = { at: Date.now(), text: verdict.recap };
+    log.info(worktreeId, `landing: tree unchanged, check not run again${doubt ? ", doubted" : ""}, ${Date.now() - started}ms`);
+    this.d.worktrees.setLanding(worktreeId, landing);
+  }
   async recapAnswer(wt, turn) {
     if (!this.d.recap)
       return;
@@ -28742,9 +28830,12 @@ function overwritten(text) {
   }
   return files;
 }
+var listed = (files) => files.length > 3 ? `${files.slice(0, 3).join(", ")} and ${files.length - 3} more` : files.join(", ");
 function inTheWay(defaultBr, what, files) {
-  const shown = files.length > 3 ? `${files.slice(0, 3).join(", ")} and ${files.length - 3} more` : files.join(", ");
-  return `${defaultBr} has uncommitted files the ${what} would overwrite (${shown}): commit or stash them there first`;
+  return `${defaultBr} has uncommitted files the ${what} would overwrite (${listed(files)}): commit or stash them there first`;
+}
+function untrackedInTheWay(defaultBr, files) {
+  return `${defaultBr} has files that are untracked here (${listed(files)}): move or delete them, then sync`;
 }
 async function requireMainReady(repoPath, defaultBr, clean) {
   const current = await git(repoPath, "branch", "--show-current");
@@ -28756,18 +28847,75 @@ async function requireMainReady(repoPath, defaultBr, clean) {
   }
   return null;
 }
-async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED) {
-  const cErr = await requireClean(worktreePath);
-  if (cErr)
-    return cErr;
+var CARRIED = "refs/worktree/toyon/carried";
+async function setAside(worktreePath) {
+  const head = await git(worktreePath, "rev-parse", "HEAD");
+  const made = await git(worktreePath, "stash", "create");
+  if (!head.ok || !made.ok) {
+    return { ok: false, message: `could not set the uncommitted changes aside: ${made.err.slice(0, 200)}` };
+  }
+  if (!made.out)
+    return null;
+  const kept = await git(worktreePath, "update-ref", CARRIED, made.out);
+  const cleared = kept.ok ? await git(worktreePath, "reset", "--hard", "-q") : kept;
+  if (!cleared.ok) {
+    return { ok: false, message: `could not set the uncommitted changes aside: ${cleared.err.slice(0, 200)}` };
+  }
+  return { sha: made.out, head: head.out };
+}
+async function putBack(worktreePath, defaultBr, aside, taken) {
+  let clash = null;
+  if (taken.ok) {
+    const applied = await git(worktreePath, "stash", "apply", aside.sha);
+    if (applied.ok) {
+      await git(worktreePath, "update-ref", "-d", CARRIED);
+      return taken;
+    }
+    const unmerged = await git(worktreePath, "diff", "--name-only", "--diff-filter=U");
+    clash = unmerged.out.split(`
+`).filter(Boolean);
+    await git(worktreePath, "reset", "--hard", "-q", aside.head);
+  }
+  const back = await git(worktreePath, "stash", "apply", "--index", aside.sha);
+  if (!back.ok) {
+    return {
+      ok: false,
+      message: `sync stopped with the uncommitted changes set aside: git stash apply ${CARRIED} in the worktree brings them back`
+    };
+  }
+  await git(worktreePath, "update-ref", "-d", CARRIED);
+  if (!clash)
+    return taken;
+  const named = clash.length ? ` (${listed(clash)})` : "";
+  return {
+    ok: false,
+    message: `the uncommitted changes here conflict with ${defaultBr}${named}: commit them first, then sync`
+  };
+}
+async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED, carry = false) {
+  if (!carry) {
+    const cErr = await requireClean(worktreePath);
+    if (cErr)
+      return cErr;
+  }
   const { behind } = await aheadBehind(worktreePath, defaultBr);
   if (behind === 0)
     return { ok: true, message: `already up to date with ${defaultBr}` };
+  const aside = carry ? await setAside(worktreePath) : null;
+  if (aside && "message" in aside)
+    return aside;
+  const taken = await bringIn(worktreePath, defaultBr, own, behind, w);
+  return aside ? putBack(worktreePath, defaultBr, aside, taken) : taken;
+}
+async function bringIn(worktreePath, defaultBr, own, behind, w) {
   if (own) {
     w.step(`rebasing onto ${defaultBr}`);
     const r = await w.git(worktreePath, ["rebase", defaultBr]);
     if (!r.ok) {
       await git(worktreePath, "rebase", "--abort");
+      const files = overwritten(r.text);
+      if (files.length)
+        return { ok: false, message: untrackedInTheWay(defaultBr, files) };
       const ask = `rebase onto ${defaultBr} conflicts: ask the agent to bring ${defaultBr} in and resolve them`;
       return {
         ok: false,
@@ -28780,6 +28928,9 @@ async function takeMainIn(worktreePath, defaultBr, own, w = UNWATCHED) {
   w.step(`merging ${defaultBr} in`);
   const m = await w.git(worktreePath, ["merge", "--no-edit", defaultBr]);
   if (!m.ok) {
+    const files = overwritten(m.text);
+    if (files.length)
+      return { ok: false, message: untrackedInTheWay(defaultBr, files) };
     return mergeFailure(worktreePath, m, `sync conflicts with ${defaultBr}: ask the agent to merge ${defaultBr} and resolve them`);
   }
   return { ok: true, message: `synced ${behind} commit(s) from ${defaultBr}` };
@@ -30706,12 +30857,24 @@ ${wt.landing.body}` : s;
     const { wt, repo } = this.landable(worktreeId, "land");
     const out = await this.ship(wt.id, "land", async () => {
       await this.followBranch(wt);
+      const moved = await this.movedMidTurn(wt);
+      if (moved)
+        return { result: moved };
       return this.landOp(wt, repo, message);
     });
     if (out.result.ok && out.archiveIds)
       this.noteLanded(wt, out.result.message, out.archiveIds);
     return out;
   }
+  async movedMidTurn(wt) {
+    const status = this.d.runtime.agentFor(wt.id)?.status;
+    if (status !== "working" && status !== "waiting")
+      return null;
+    const l = wt.landing;
+    if (!l || l.fingerprint === await treeFingerprint(wt.path))
+      return null;
+    return { ok: false, message: "the agent has changed files since the check: land once its turn ends" };
+  }
   noteLanded(wt, message, archiveIds) {
     this.d.runtime.ensureAgent(wt).agent.note({ type: "landed", message, archiveIds, ts: Date.now() });
   }
@@ -30983,6 +31146,10 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
       throw new UserError(`${r.name} is held by another tool`);
     const repo = this.d.state.requireRepo(r.repoId);
     const own = r.wt ? hasOwnBranch(r.wt) : false;
+    const carry = !!r.wt;
+    const status = this.d.runtime.agentFor(worktreeId)?.status;
+    if (carry && (status === "working" || status === "waiting") && (await statusFiles(r.path)).length > 0)
+      throw new UserError(`${r.name}'s agent is mid-turn with uncommitted changes: sync when it is done`);
     const w = r.wt ? this.landWatch(r.wt) : UNWATCHED;
     const result = await this.ship(worktreeId, "sync-main", async () => {
       if (r.wt) {
@@ -30990,7 +31157,7 @@ ${wt.landing.body}` : wt.landing.subject : undefined;
         if (!fetched.ok)
           return fetched;
       }
-      const taken = await withRepoLock(repo.path, () => takeMainIn(r.path, r.base, own, w));
+      const taken = await withRepoLock(repo.path, () => takeMainIn(r.path, r.base, own, w, carry));
       if (taken.ok) {
         this.headMoved(worktreeId);
         if (r.wt)