@kubitnodes/stellaris 0.3.25 → 0.3.27

package/dist/cli/index.js

@@ -2,12 +2,12 @@
 
 // apps/cli/dist/index.js
 import { readFile as readFile5 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 import { Command } from "commander";
 
 // packages/board-core/dist/board.js
-import { chmod as chmod2, cp, mkdir as mkdir4, readdir as readdir4, readFile as readFile4, rename as rename3, rm as rm2, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path7 from "node:path";
+import { chmod as chmod2, cp, mkdir as mkdir5, readdir as readdir4, readFile as readFile4, rename as rename3, rm as rm3, stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
+import path8 from "node:path";
 import { decodeTime, monotonicFactory } from "ulid";
 import { z as z16 } from "zod";
 
@@ -1190,6 +1190,7 @@ var BOARD_EVENT_TYPES = [
   "project.configured",
   "project.archived",
   "project.placed",
+  "project.moved",
   "agent.added",
   "agent.configured",
   "agent.placed",
@@ -1370,6 +1371,11 @@ var RunnerHelloSchema = z9.object({
   quotaReads: z9.boolean().default(false),
   /** Whether the runner reads an image a turn running there uploads; one from before never does. */
   imageReads: z9.boolean().default(false),
+  /**
+   * Whether the runner carries a project's repository out to another runner and in from one, and
+   * removes its copy once the project has moved; one from before never does.
+   */
+  projectMoves: z9.boolean().default(false),
   capabilities: z9.array(z9.string()).default([]),
   /**
    * What the runner's account lacks of the git identity citizens' own commits carry, checked
@@ -1471,6 +1477,11 @@ var TurnJobSchema = z9.object({
   session: z9.string().min(1).nullable(),
   /** The running total the session reported after its last turn, which a resumed session starts from. */
   costSoFarUsd: z9.number().nonnegative(),
+  /**
+   * The session's running usage after its last turn, which a resumed session's own usage is
+   * measured from. Absent when the board holds none for the session, and from a server from before.
+   */
+  usageSoFar: UsageSchema.optional(),
   /** The rendered charter, norms, memory core, and skills index, with `PATH_TOKENS` for places. */
   instructions: z9.string(),
   prompt: z9.string(),
@@ -1499,6 +1510,17 @@ var TurnOutcomeSchema = z9.object({
   costUsd: z9.number().nonnegative(),
   /** The session's running total after this turn, for CLIs that report one. */
   sessionCostUsd: z9.number().nonnegative().optional(),
+  /**
+   * The session's running usage after this turn, for CLIs that report one, else the job's
+   * `usageSoFar`. A runner from before never sends it.
+   */
+  sessionUsage: UsageSchema.optional(),
+  /**
+   * The whole input of the turn's latest model call in the session's own thread, cached or not:
+   * how large the session had grown. Sub-agents' calls are left out. A turn that made no call,
+   * and a runner from before, never send it.
+   */
+  contextTokens: z9.number().int().nonnegative().optional(),
   /**
    * The session the CLI used, which differs from the job's for CLIs that assign their own ids. A
    * turn whose CLI never started, because it failed or was stopped first, reports the job's own,
@@ -1658,6 +1680,43 @@ var HeldWorkspaceSchema = z9.object({
 });
 var HeldWorkspacesSchema = z9.object({ workspaces: z9.array(HeldWorkspaceSchema) });
 var SweepResultSchema = z9.object({ kept: z9.array(HeldWorkspaceSchema) });
+var MOVE_PACK_LIMIT_BYTES = 256 * 1024 * 1024;
+var RepoRefsSchema = z9.record(z9.string().regex(/^refs\/(heads|tags)\/\S+$/), z9.string().regex(/^[0-9a-f]{40}([0-9a-f]{24})?$/));
+var ProjectExportSchema = z9.object({ move: UlidSchema, repo: ProjectRepoSchema });
+var HeldWorkSchema = z9.object({
+  agent: NameSchema,
+  conversation: WorkspaceConversationSchema.nullable(),
+  uncommitted: z9.number().int().nonnegative(),
+  onNoBranch: z9.number().int().nonnegative()
+});
+var ProjectExportedSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    refs: RepoRefsSchema,
+    bytes: z9.number().int().nonnegative()
+  }),
+  z9.object({
+    ok: z9.literal(false),
+    held: z9.array(HeldWorkSchema),
+    bytes: z9.number().int().nonnegative()
+  })
+]);
+var ProjectImportSchema = z9.object({
+  move: UlidSchema,
+  repo: ProjectRepoSchema,
+  pullRequests: z9.boolean()
+});
+var ProjectImportedSchema = z9.object({ refs: RepoRefsSchema });
+var ProjectReleaseSchema = z9.object({ slug: NameSchema });
+var ProjectReleasedSchema = z9.object({
+  worktrees: z9.number().int().nonnegative(),
+  clone: z9.boolean()
+});
+var ProjectMovedSchema = z9.object({
+  project: ProjectSchema,
+  carried: z9.number().int().nonnegative().nullable(),
+  released: z9.object({ ok: z9.boolean(), detail: z9.string() }).nullable()
+});
 var TurnSteerSchema = z9.object({ id: z9.uuid(), text: z9.string().min(1) });
 var RunnerMessageSchema = z9.discriminatedUnion("type", [
   z9.object({ type: z9.literal("turn"), job: TurnJobSchema }),
@@ -1694,6 +1753,19 @@ var RunnerMessageSchema = z9.discriminatedUnion("type", [
   }),
   /** Answered with whether the turn was there to stop; it ends `stopped`. */
   z9.object({ type: z9.literal("stop"), request: z9.string().min(1), turnId: UlidSchema }),
+  /**
+   * Answered with a `ProjectExported`. Sent only to runners whose hello says `projectMoves`, as are
+   * the import and the release.
+   */
+  z9.object({ type: z9.literal("export"), request: z9.string().min(1), export: ProjectExportSchema }),
+  /** Answered with a `ProjectImported`. */
+  z9.object({ type: z9.literal("import"), request: z9.string().min(1), import: ProjectImportSchema }),
+  /** Answered with a `ProjectReleased`. */
+  z9.object({
+    type: z9.literal("release"),
+    request: z9.string().min(1),
+    release: ProjectReleaseSchema
+  }),
   /**
    * A conversation ended: the runner removes every citizen's workspace for it but those a turn
    * still uses, and answers with a `SweepResult` naming those it kept for holding work on no branch.
@@ -1808,6 +1880,16 @@ var TurnRecordSchema = z10.object({
    * resumed session starts from it, so the next turn's own cost is measured from here.
    */
   sessionCostUsd: z10.number().nonnegative().optional(),
+  /**
+   * The running usage the CLI reported for the session after this turn, when the runner reports
+   * one. A resumed session's next turn measures its own usage from here.
+   */
+  sessionUsage: UsageSchema.optional(),
+  /**
+   * The whole input of the turn's latest model call in the session's own thread, as the runner
+   * reported it: how large the session had grown. Absent for a turn that made no call.
+   */
+  contextTokens: z10.number().int().nonnegative().optional(),
   toolCalls: z10.number().int().nonnegative().default(0),
   /** The model the CLI reported for this turn, else the model configured for the agent, else null. */
   model: z10.string().nullable().default(null),
@@ -1821,7 +1903,10 @@ var TurnRecordSchema = z10.object({
   transient: z10.boolean().optional(),
   /** How many turns in a row, this one included, could not resume the session for a `retry`. */
   resumeRetries: z10.number().int().positive().optional(),
-  /** Whether the server dropped the conversation's session after this turn, which the next starts anew. */
+  /**
+   * Whether the server dropped the conversation's session after this turn, which the next starts
+   * anew: one its CLI could not resume, or a society role's home after a reflection completed.
+   */
   sessionDropped: z10.boolean().optional(),
   /** The crons whose fire started the turn, which record how it ended. */
   crons: z10.array(UlidSchema).optional()
@@ -2034,11 +2119,17 @@ var TokenUseSchema = z12.object({
 // packages/shared/dist/config.js
 import { z as z13 } from "zod";
 var LogLevelSchema = z13.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
+var AppleAppIdSchema = z13.string().regex(/^[A-Z0-9]{10}\.[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*$/, "not <team id>.<bundle id>");
 var GithubSignInSchema = z13.object({
   clientId: z13.string().min(1),
   clientSecret: z13.string().min(1),
   /** Logins, lowercased; GitHub logins are case-insensitive. */
-  users: z13.array(z13.string().min(1)).min(1)
+  users: z13.array(z13.string().min(1)).min(1),
+  /**
+   * The iOS app that may sign in, which Apple's association file names so that only it can take the
+   * board's `https` landing; null when no app signs in.
+   */
+  appleAppId: AppleAppIdSchema.nullable()
 });
 var ServerConfigSchema = z13.object({
   dataDir: z13.string().min(1),
@@ -2084,7 +2175,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.25";
+var STELLARIS_VERSION = "0.3.27";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2776,6 +2867,41 @@ function filesOf(lines, status) {
   return [...files.values()];
 }
 
+// packages/board-core/dist/moves.js
+import { mkdir as mkdir4, rm as rm2 } from "node:fs/promises";
+import path5 from "node:path";
+import { execa as execa2 } from "execa";
+var MoveRepos = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  /** Makes the move's empty repository, which checks every object a push brings, and answers its path. */
+  async open(dir) {
+    await mkdir4(this.root, { recursive: true });
+    await git2(["init", "--quiet", "--bare", dir], this.root);
+    await git2(["config", "receive.fsckObjects", "true"], dir);
+    return dir;
+  }
+  async drop(dir) {
+    await rm2(path5.resolve(this.root, dir), { recursive: true, force: true });
+  }
+  /** Removes every move's repository, as the server starts: a move never survives a restart. */
+  async clear() {
+    await rm2(this.root, { recursive: true, force: true });
+  }
+};
+async function git2(args, cwd) {
+  const result = await execa2("git", args, {
+    cwd,
+    reject: false,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`git ${args[0] ?? ""} failed: ${result.stderr.trim()}`);
+  }
+}
+
 // packages/board-core/dist/mentions.js
 import vm from "node:vm";
 var MENTION_PARSE_MS = 500;
@@ -3189,121 +3315,121 @@ var Mutex = class {
 };
 
 // packages/board-core/dist/paths.js
-import path5 from "node:path";
+import path6 from "node:path";
 var BoardPaths = class {
   dataDir;
   constructor(dataDir) {
-    this.dataDir = path5.resolve(dataDir);
+    this.dataDir = path6.resolve(dataDir);
   }
   // Board projection, also the storage of record; only the core library writes it.
   get board() {
-    return path5.join(this.dataDir, "board");
+    return path6.join(this.dataDir, "board");
   }
   get society() {
-    return path5.join(this.board, "society");
+    return path6.join(this.board, "society");
   }
   societyFile() {
-    return path5.join(this.society, "society.md");
+    return path6.join(this.society, "society.md");
   }
   societyChannels() {
-    return path5.join(this.society, "channels");
+    return path6.join(this.society, "channels");
   }
   societyChannel(name) {
-    return path5.join(this.societyChannels(), name);
+    return path6.join(this.societyChannels(), name);
   }
   /** Threads whose channel is a society channel; project channels' threads live under the project. */
   societyThreads() {
-    return path5.join(this.society, "threads");
+    return path6.join(this.society, "threads");
   }
   societyKnowledge() {
-    return path5.join(this.society, "knowledge");
+    return path6.join(this.society, "knowledge");
   }
   societyKnowledgeFile(topic) {
-    return path5.join(this.societyKnowledge(), `${topic}.md`);
+    return path6.join(this.societyKnowledge(), `${topic}.md`);
   }
   /** Skills promoted to the society, one directory per skill holding SKILL.md. */
   societySkills() {
-    return path5.join(this.society, "skills");
+    return path6.join(this.society, "skills");
   }
   societySkill(name) {
-    return path5.join(this.societySkills(), name);
+    return path6.join(this.societySkills(), name);
   }
   societySkillFile(name) {
-    return path5.join(this.societySkill(name), "SKILL.md");
+    return path6.join(this.societySkill(name), "SKILL.md");
   }
   roles() {
-    return path5.join(this.society, "roles");
+    return path6.join(this.society, "roles");
   }
   role(name) {
-    return path5.join(this.roles(), `${name}.md`);
+    return path6.join(this.roles(), `${name}.md`);
   }
   proposals() {
-    return path5.join(this.society, "proposals");
+    return path6.join(this.society, "proposals");
   }
   proposal(id) {
-    return path5.join(this.proposals(), `${id}.md`);
+    return path6.join(this.proposals(), `${id}.md`);
   }
   /** A skill proposal's folder, as the board took it from its proposer's home. */
   proposalFiles(id) {
-    return path5.join(this.proposals(), id);
+    return path6.join(this.proposals(), id);
   }
   decisions() {
-    return path5.join(this.society, "decisions");
+    return path6.join(this.society, "decisions");
   }
   decision(id) {
-    return path5.join(this.decisions(), `${id}.md`);
+    return path6.join(this.decisions(), `${id}.md`);
   }
   runners() {
-    return path5.join(this.society, "runners");
+    return path6.join(this.society, "runners");
   }
   runner(name) {
-    return path5.join(this.runners(), `${name}.md`);
+    return path6.join(this.runners(), `${name}.md`);
   }
   members() {
-    return path5.join(this.society, "members");
+    return path6.join(this.society, "members");
   }
   /** Crons, one file each with its note as the body; ended ones stay. */
   crons() {
-    return path5.join(this.society, "crons");
+    return path6.join(this.society, "crons");
   }
   cron(id) {
-    return path5.join(this.crons(), `${id}.md`);
+    return path6.join(this.crons(), `${id}.md`);
   }
   member(name) {
-    return path5.join(this.members(), `${name}.md`);
+    return path6.join(this.members(), `${name}.md`);
   }
   projects() {
-    return path5.join(this.board, "projects");
+    return path6.join(this.board, "projects");
   }
   project(slug) {
-    return path5.join(this.projects(), slug);
+    return path6.join(this.projects(), slug);
   }
   projectFile(slug) {
-    return path5.join(this.project(slug), "project.md");
+    return path6.join(this.project(slug), "project.md");
   }
   projectChannels(slug) {
-    return path5.join(this.project(slug), "channels");
+    return path6.join(this.project(slug), "channels");
   }
   projectChannel(slug, name) {
-    return path5.join(this.projectChannels(slug), name);
+    return path6.join(this.projectChannels(slug), name);
   }
   threads(slug) {
-    return path5.join(this.project(slug), "threads");
+    return path6.join(this.project(slug), "threads");
   }
   tasks(slug) {
-    return path5.join(this.project(slug), "tasks");
+    return path6.join(this.project(slug), "tasks");
   }
   task(slug, id) {
-    return path5.join(this.tasks(slug), `${id}.md`);
+    return path6.join(this.tasks(slug), `${id}.md`);
   }
   projectKnowledge(slug) {
-    return path5.join(this.project(slug), "knowledge");
+    return path6.join(this.project(slug), "knowledge");
   }
   projectKnowledgeFile(slug, topic) {
-    return path5.join(this.projectKnowledge(slug), `${topic}.md`);
+    return path6.join(this.projectKnowledge(slug), `${topic}.md`);
   }
   dashboard(slug) {
-    return path5.join(this.project(slug), "dashboard.md");
+    return path6.join(this.project(slug), "dashboard.md");
   }
   channelDir(ref) {
     const parsed = parseChannelRef(ref);
@@ -3316,57 +3442,57 @@ var BoardPaths = class {
   }
   /** A thread's record, `<id>.md`, beside the directory of its messages, `<id>/`. */
   threadFile(threads, id) {
-    return path5.join(threads, `${id}.md`);
+    return path6.join(threads, `${id}.md`);
   }
   threadMessages(threads, id) {
-    return path5.join(threads, id);
+    return path6.join(threads, id);
   }
   messageFile(dir, id, author) {
-    return path5.join(dir, `${id}-${author}.md`);
+    return path6.join(dir, `${id}-${author}.md`);
   }
   // Agent homes: authored by the agent, source of truth on the board server.
   agents() {
-    return path5.join(this.dataDir, "agents");
+    return path6.join(this.dataDir, "agents");
   }
   agent(name) {
-    return path5.join(this.agents(), name);
+    return path6.join(this.agents(), name);
   }
   agentFile(name) {
-    return path5.join(this.agent(name), "agent.json");
+    return path6.join(this.agent(name), "agent.json");
   }
   agentRole(name) {
-    return path5.join(this.agent(name), "role.md");
+    return path6.join(this.agent(name), "role.md");
   }
   agentProfile(name) {
-    return path5.join(this.agent(name), "profile.md");
+    return path6.join(this.agent(name), "profile.md");
   }
   agentMemory(name) {
-    return path5.join(this.agent(name), "memory");
+    return path6.join(this.agent(name), "memory");
   }
   agentMemoryCore(name) {
-    return path5.join(this.agentMemory(name), "core.md");
+    return path6.join(this.agentMemory(name), "core.md");
   }
   /** Transcripts of the agent's finished turns, one JSON line per step. */
   agentTurns(name) {
-    return path5.join(this.agent(name), "turns");
+    return path6.join(this.agent(name), "turns");
   }
   agentTranscript(name, turnId) {
-    return path5.join(this.agentTurns(name), `${turnId}.jsonl`);
+    return path6.join(this.agentTurns(name), `${turnId}.jsonl`);
   }
   agentSkills(name) {
-    return path5.join(this.agent(name), "skills");
+    return path6.join(this.agent(name), "skills");
   }
   agentSkill(name, skill2) {
-    return path5.join(this.agentSkills(name), skill2);
+    return path6.join(this.agentSkills(name), skill2);
   }
   agentSkillFile(name, skill2) {
-    return path5.join(this.agentSkill(name, skill2), "SKILL.md");
+    return path6.join(this.agentSkill(name, skill2), "SKILL.md");
   }
   agentProjects(name) {
-    return path5.join(this.agent(name), "projects");
+    return path6.join(this.agent(name), "projects");
   }
   agentProject(name, slug) {
-    return path5.join(this.agentProjects(name), slug);
+    return path6.join(this.agentProjects(name), slug);
   }
   /**
    * A thread's, a channel's, or, in the society scope, a project's conversation's session and last
@@ -3374,46 +3500,56 @@ var BoardPaths = class {
    */
   agentConversation(name, slug, part) {
     if (part.startsWith("#")) {
-      return path5.join(this.agentProject(name, slug), "channels", part.slice(1));
+      return path6.join(this.agentProject(name, slug), "channels", part.slice(1));
     }
-    return part.startsWith("~") ? path5.join(this.agentProject(name, slug), "places", part.slice(1)) : path5.join(this.agentProject(name, slug), "threads", part);
+    return part.startsWith("~") ? path6.join(this.agentProject(name, slug), "places", part.slice(1)) : path6.join(this.agentProject(name, slug), "threads", part);
   }
   agentCursors(name) {
-    return path5.join(this.agent(name), "cursors.json");
+    return path6.join(this.agent(name), "cursors.json");
   }
   events() {
-    return path5.join(this.dataDir, "events");
+    return path6.join(this.dataDir, "events");
   }
   eventLog() {
-    return path5.join(this.events(), "log.jsonl");
+    return path6.join(this.events(), "log.jsonl");
   }
   /** Images citizens uploaded, by id: outside the projection, which every runner mirrors. */
   images() {
-    return path5.join(this.dataDir, "images");
+    return path6.join(this.dataDir, "images");
   }
   image(id) {
-    return path5.join(this.images(), id);
+    return path6.join(this.images(), id);
+  }
+  /**
+   * The repositories projects travel through between runners, one per move while it runs:
+   * outside the projection, which every runner mirrors, and served only to the move's runners.
+   */
+  moves() {
+    return path6.join(this.dataDir, "moves");
+  }
+  move(id) {
+    return path6.join(this.moves(), `${id}.git`);
   }
   state() {
-    return path5.join(this.dataDir, "state");
+    return path6.join(this.dataDir, "state");
   }
   pausedFile() {
-    return path5.join(this.state(), "paused.json");
+    return path6.join(this.state(), "paused.json");
   }
   /** Removed knowledge topics, set aside outside the projection, by scope. */
   removedKnowledge(scope) {
-    return path5.join(this.state(), "removed-knowledge", scope);
+    return path6.join(this.state(), "removed-knowledge", scope);
   }
   /** Skills removed from the society, set aside outside the projection, one directory per removal. */
   removedSkills() {
-    return path5.join(this.state(), "removed-skills");
+    return path6.join(this.state(), "removed-skills");
   }
 };
 
 // packages/board-core/dist/skill-folder.js
 import { constants } from "node:fs";
 import { lstat, open as open2, readdir as readdir3, readlink, realpath } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 var SKILL_TEXT_LIMIT_CHARS = 1e5;
 var SKILL_TEXT_LIMIT_BYTES = SKILL_TEXT_LIMIT_CHARS * 4;
 function skillFileText(bytes) {
@@ -3424,8 +3560,8 @@ function skillFileText(bytes) {
   };
 }
 function inside(root, file) {
-  const relative = path6.relative(root, file);
-  return relative !== ".." && !relative.startsWith(`..${path6.sep}`) && !path6.isAbsolute(relative);
+  const relative = path7.relative(root, file);
+  return relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
 }
 async function handleInside(root, handle) {
   if (process.platform !== "linux") {
@@ -3435,7 +3571,7 @@ async function handleInside(root, handle) {
   return file !== null && inside(root, file);
 }
 async function walk(root, prefix, found) {
-  const entries = await readdir3(path6.join(root, ...prefix === "" ? [] : prefix.split("/")), {
+  const entries = await readdir3(path7.join(root, ...prefix === "" ? [] : prefix.split("/")), {
     withFileTypes: true
   }).catch(() => []);
   for (const entry of entries.toSorted((a, b) => a.name < b.name ? -1 : 1)) {
@@ -3456,7 +3592,7 @@ async function walk(root, prefix, found) {
 async function readEntry(root, relative) {
   let real;
   try {
-    real = await realpath(path6.join(root, ...relative.split("/")));
+    real = await realpath(path7.join(root, ...relative.split("/")));
   } catch {
     return null;
   }
@@ -3772,9 +3908,11 @@ var Board = class _Board {
   signIns = /* @__PURE__ */ new Map();
   files = new FileTree();
   homes;
+  moves;
   constructor(dataDir, options) {
     this.paths = new BoardPaths(dataDir);
-    this.homes = new HomeRepos(path7.join(this.paths.state(), "home-hooks"));
+    this.homes = new HomeRepos(path8.join(this.paths.state(), "home-hooks"));
+    this.moves = new MoveRepos(this.paths.moves());
     this.leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.events = new EventLog(this.paths.eventLog(), () => this.newId(), this.now);
@@ -3800,6 +3938,7 @@ var Board = class _Board {
     await board.loadRunnerTokens();
     await board.loadSignIns();
     await board.homes.installHooks();
+    await board.moves.clear();
     return board;
   }
   /**
@@ -3809,7 +3948,7 @@ var Board = class _Board {
    */
   async applyAlignments() {
     const alignments = [];
-    const file = path7.join(this.paths.state(), "alignments.json");
+    const file = path8.join(this.paths.state(), "alignments.json");
     const { applied } = await exists(file) ? await readJson(file, AlignmentsSchema) : { applied: [] };
     const pending = alignments.filter(({ name }) => !applied.includes(name));
     if (pending.length === 0) {
@@ -4017,7 +4156,7 @@ ${charter.purpose}
     });
   }
   signInsFile() {
-    return path7.join(this.paths.state(), "sign-ins.json");
+    return path8.join(this.paths.state(), "sign-ins.json");
   }
   async readSignIns() {
     const file = this.signInsFile();
@@ -4114,7 +4253,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.tasks(project2));
     const tasks = [];
     for (const file of files) {
-      const doc = await readMarkdown(path7.join(this.paths.tasks(project2), file), TaskFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(this.paths.tasks(project2), file), TaskFrontmatterSchema);
       tasks.push({ ...doc.data, body: doc.body });
     }
     return tasks;
@@ -4133,7 +4272,7 @@ ${charter.purpose}
     const files = await listFiles(this.paths.proposals());
     const proposals = [];
     for (const file of files) {
-      const doc = await readMarkdown(path7.join(this.paths.proposals(), file), ProposalFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(this.paths.proposals(), file), ProposalFrontmatterSchema);
       proposals.push({ ...doc.data, body: doc.body });
     }
     return proposals;
@@ -4160,7 +4299,7 @@ ${charter.purpose}
   async listMembers() {
     const members = [];
     for (const file of await listFiles(this.paths.members())) {
-      const doc = await readMarkdown(path7.join(this.paths.members(), file), MemberSchema);
+      const doc = await readMarkdown(path8.join(this.paths.members(), file), MemberSchema);
       members.push({ ...doc.data, profile: doc.body });
     }
     return members;
@@ -4179,7 +4318,7 @@ ${charter.purpose}
     const dir = project2 === null ? this.paths.societyKnowledge() : this.paths.projectKnowledge(project2);
     const topics = [];
     for (const file of await listFiles(dir)) {
-      topics.push(await this.knowledgeAt(path7.join(dir, file), project2, file.replace(/\.md$/, "")));
+      topics.push(await this.knowledgeAt(path8.join(dir, file), project2, file.replace(/\.md$/, "")));
     }
     return topics;
   }
@@ -4209,7 +4348,7 @@ ${charter.purpose}
     const aside = this.paths.removedKnowledge(project2 ?? SOCIETY_SCOPE);
     let highest = 0;
     for (const file of (await listFiles(aside)).filter((name) => name.startsWith(`${topic}.`))) {
-      const copy = await this.knowledgeAt(path7.join(aside, file), project2, topic);
+      const copy = await this.knowledgeAt(path8.join(aside, file), project2, topic);
       highest = Math.max(highest, copy.revision);
     }
     return highest;
@@ -4225,7 +4364,7 @@ ${charter.purpose}
   async listSkillsIn(dir, scope) {
     const skills = [];
     for (const entry of await listDirs(dir)) {
-      const file = path7.join(dir, entry, "SKILL.md");
+      const file = path8.join(dir, entry, "SKILL.md");
       if (!await exists(file)) {
         continue;
       }
@@ -4315,7 +4454,7 @@ ${charter.purpose}
         if (!wanted.delete(file.slice(0, 26))) {
           continue;
         }
-        const { data } = await readMarkdown(path7.join(dir, file), MessageFrontmatterSchema);
+        const { data } = await readMarkdown(path8.join(dir, file), MessageFrontmatterSchema);
         found.push(MessageRefSchema.parse(data));
       }
       if (wanted.size === 0) {
@@ -4347,7 +4486,7 @@ ${charter.purpose}
         if (!file.endsWith(".md")) {
           continue;
         }
-        const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+        const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
         if (doc.data.state !== "open") {
           continue;
         }
@@ -4374,7 +4513,7 @@ ${charter.purpose}
     const all = [];
     for (const threads of await this.threadScopes()) {
       for (const file of await listFiles(threads)) {
-        const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+        const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
         const messages = await listFiles(this.paths.threadMessages(threads, doc.data.id));
         const last = messages.at(-1);
         all.push({
@@ -4969,7 +5108,7 @@ ${task2.body}`;
         }
       }
       for (const file of await listFiles(this.paths.projectKnowledge(project2))) {
-        const content = await readFile4(path7.join(this.paths.projectKnowledge(project2), file), "utf8");
+        const content = await readFile4(path8.join(this.paths.projectKnowledge(project2), file), "utf8");
         if (content.toLowerCase().includes(needle)) {
           hits.push({
             kind: "knowledge",
@@ -4990,7 +5129,7 @@ ${task2.body}`;
       shared.push({
         kind: "knowledge",
         ref: `society/knowledge/${file}`,
-        file: path7.join(this.paths.societyKnowledge(), file)
+        file: path8.join(this.paths.societyKnowledge(), file)
       });
     }
     for (const skill2 of await this.listSocietySkills()) {
@@ -5003,7 +5142,7 @@ ${task2.body}`;
       shared.push({
         kind: "memory",
         ref: `memory/${file}`,
-        file: path7.join(this.paths.agentMemory(actor.name), file)
+        file: path8.join(this.paths.agentMemory(actor.name), file)
       });
     }
     for (const entry of shared) {
@@ -5092,8 +5231,8 @@ ${current.body}`);
         removedAt: this.now().toISOString()
       });
       const aside = this.paths.removedKnowledge(args.project ?? SOCIETY_SCOPE);
-      await mkdir4(aside, { recursive: true });
-      await rename3(file, path7.join(aside, `${args.topic}.${removed.removedAt.replaceAll(":", "-")}.md`));
+      await mkdir5(aside, { recursive: true });
+      await rename3(file, path8.join(aside, `${args.topic}.${removed.removedAt.replaceAll(":", "-")}.md`));
       await this.events.append("knowledge.removed", actor.name, {
         topic: args.topic,
         project: args.project
@@ -5140,8 +5279,8 @@ ${current.body}`);
         removedAt: this.now().toISOString()
       });
       const aside = this.paths.removedSkills();
-      await mkdir4(aside, { recursive: true });
-      await rename3(this.paths.societySkill(args.name), path7.join(aside, `${args.name}.${removed.removedAt.replaceAll(":", "-")}`));
+      await mkdir5(aside, { recursive: true });
+      await rename3(this.paths.societySkill(args.name), path8.join(aside, `${args.name}.${removed.removedAt.replaceAll(":", "-")}`));
       await this.events.append("skill.removed", actor.name, {
         name: args.name,
         reason: args.reason
@@ -5218,7 +5357,7 @@ ${current.body}`);
         type,
         size: bytes.byteLength
       });
-      const name = path7.basename(args.path).replaceAll(/[[\]\\\r\n]/g, "");
+      const name = path8.basename(args.path).replaceAll(/[[\]\\\r\n]/g, "");
       return {
         id,
         type,
@@ -5244,7 +5383,7 @@ ${current.body}`);
   async listCrons() {
     const crons = [];
     for (const file of await listFiles(this.paths.crons())) {
-      crons.push(await this.readCronFile(path7.join(this.paths.crons(), file)));
+      crons.push(await this.readCronFile(path8.join(this.paths.crons(), file)));
     }
     return crons;
   }
@@ -5591,7 +5730,7 @@ ${current.body}`);
   async openThreadIds(dir, keep) {
     const ids = /* @__PURE__ */ new Set();
     for (const file of await listFiles(dir)) {
-      const doc = await readMarkdown(path7.join(dir, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(dir, file), ThreadFrontmatterSchema);
       if (doc.data.state === "open" && keep({ ...doc.data, body: doc.body })) {
         ids.add(doc.data.id);
       }
@@ -5599,12 +5738,12 @@ ${current.body}`);
     return ids;
   }
   /**
-   * Refuses to archive a project while a turn runs in it, in a citizen's conversation of its
-   * channels in the society scope, or in a thread its archive closes.
+   * Refuses to archive or move a project while a turn runs in it, in a citizen's conversation of
+   * its channels in the society scope, or in one of its open threads.
    */
-  async assertProjectQuiet(actor, slug) {
+  async assertProjectQuiet(actor, slug, what = `project ${slug} cannot be archived`) {
     const threads = await this.openThreadIds(this.paths.threads(slug), () => true);
-    this.assertNoTurnCut(actor, `project ${slug} cannot be archived`, (turn2) => turn2.scope === slug || turn2.place === slug || turn2.thread !== void 0 && threads.has(turn2.thread));
+    this.assertNoTurnCut(actor, what, (turn2) => turn2.scope === slug || turn2.place === slug || turn2.thread !== void 0 && threads.has(turn2.thread));
   }
   async closeThread(actor, input) {
     const args = VerbInputs.close_thread.parse(input);
@@ -6571,7 +6710,7 @@ ${rationale}`}`);
     return part === void 0 ? this.paths.agentProject(agent2, scope) : this.paths.agentConversation(agent2, scope, part);
   }
   async readSessions(agent2, project2, part) {
-    const file = path7.join(this.sessionDir(agent2, project2, part), "sessions.json");
+    const file = path8.join(this.sessionDir(agent2, project2, part), "sessions.json");
     return await exists(file) ? readJson(file, SessionsFileSchema) : {};
   }
   /**
@@ -6582,7 +6721,7 @@ ${rationale}`}`);
     await this.mutex.run(async () => {
       const dir = this.sessionDir(agent2, project2, part);
       await ensureDir(dir);
-      const file = path7.join(dir, "sessions.json");
+      const file = path8.join(dir, "sessions.json");
       const current = await exists(file) ? await readJson(file, SessionsFileSchema) : {};
       const kept = current.runner === void 0 || current.runner === runner2 ? current : {};
       await writeJson(file, { ...kept, [cli]: sessionId, runner: runner2 });
@@ -6594,7 +6733,7 @@ ${rationale}`}`);
    */
   async dropSession(agent2, project2, cli, sessionId, part) {
     return this.mutex.run(async () => {
-      const file = path7.join(this.sessionDir(agent2, project2, part), "sessions.json");
+      const file = path8.join(this.sessionDir(agent2, project2, part), "sessions.json");
       if (!await exists(file)) {
         return false;
       }
@@ -6609,7 +6748,7 @@ ${rationale}`}`);
   }
   /** The last turn of one conversation: the scope's home, a channel's, a project's, or a thread's. */
   async readLastTurn(agent2, project2, part) {
-    const file = path7.join(this.sessionDir(agent2, project2, part), "last-turn.json");
+    const file = path8.join(this.sessionDir(agent2, project2, part), "last-turn.json");
     return await exists(file) ? readJson(file, TurnRecordSchema) : null;
   }
   /** The latest turn a citizen took in a scope, in any of its conversations there. */
@@ -6617,9 +6756,9 @@ ${rationale}`}`);
     let latest = await this.readLastTurn(agent2, project2);
     const place = this.paths.agentProject(agent2, project2);
     const parts = [
-      ...await listDirs(path7.join(place, "threads")),
-      ...(await listDirs(path7.join(place, "channels"))).map((name) => `#${name}`),
-      ...(await listDirs(path7.join(place, "places"))).map((name) => `~${name}`)
+      ...await listDirs(path8.join(place, "threads")),
+      ...(await listDirs(path8.join(place, "channels"))).map((name) => `#${name}`),
+      ...(await listDirs(path8.join(place, "places"))).map((name) => `~${name}`)
     ];
     for (const part of parts) {
       const turn2 = await this.readLastTurn(agent2, project2, part);
@@ -6685,6 +6824,7 @@ ${rationale}`}`);
         exitReason: parsed.exitReason,
         costUsd: parsed.costUsd,
         ...parsed.usage === null ? {} : { usage: parsed.usage },
+        ...parsed.contextTokens === void 0 ? {} : { contextTokens: parsed.contextTokens },
         toolCalls: parsed.toolCalls,
         model: parsed.model,
         summary: parsed.status?.summary ?? null,
@@ -6885,11 +7025,11 @@ ${rationale}`}`);
   }
   /** Small named state files under data/state, for cursors the scheduler must keep across restarts. */
   async readState(name, schema, fallback) {
-    const file = path7.join(this.paths.state(), `${name}.json`);
+    const file = path8.join(this.paths.state(), `${name}.json`);
     return await exists(file) ? readJson(file, schema) : fallback;
   }
   async writeState(name, value) {
-    await this.mutex.run(() => writeJson(path7.join(this.paths.state(), `${name}.json`), value));
+    await this.mutex.run(() => writeJson(path8.join(this.paths.state(), `${name}.json`), value));
   }
   /** The project's dashboard, empty at revision 0 when it has none. */
   async readDashboard(slug) {
@@ -6920,7 +7060,7 @@ ${rationale}`}`);
   async listRunners() {
     const runners = [];
     for (const file of await listFiles(this.paths.runners())) {
-      runners.push((await readMarkdown(path7.join(this.paths.runners(), file), RunnerSchema)).data);
+      runners.push((await readMarkdown(path8.join(this.paths.runners(), file), RunnerSchema)).data);
     }
     return runners;
   }
@@ -6972,7 +7112,7 @@ ${rationale}`}`);
     return this.runnerTokens.get(hashToken(token)) ?? null;
   }
   runnerTokensFile() {
-    return path7.join(this.paths.state(), "runners.json");
+    return path8.join(this.paths.state(), "runners.json");
   }
   async readRunnerTokens() {
     const file = this.runnerTokensFile();
@@ -6986,7 +7126,8 @@ ${rationale}`}`);
   }
   /**
    * Places a project on the runner that will hold its repository, unless it already lives on one,
-   * and returns where it lives. Placement is once: every later turn of the project goes there.
+   * and returns where it lives. Placement is once: every later turn of the project goes there,
+   * until the user moves the project (`recordProjectMove`).
    */
   async placeProject(slug, runner2) {
     return this.mutex.run(async () => {
@@ -7028,12 +7169,12 @@ ${rationale}`}`);
         }
         const relative = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
         if (entry.isDirectory()) {
-          await walk2(path7.join(dir, entry.name), relative);
+          await walk2(path8.join(dir, entry.name), relative);
           continue;
         }
         const file = entry.isFile() ? conflictCopyOf(relative) : null;
         if (file !== null) {
-          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path7.join(home, relative)).catch(() => null))?.mtime.toISOString();
+          const since = await this.homes.changedAt(home, relative) ?? (await stat3(path8.join(home, relative)).catch(() => null))?.mtime.toISOString();
           if (since !== void 0) {
             found.push({ path: relative, file, since });
           }
@@ -7107,6 +7248,74 @@ ${rationale}`}`);
       return next;
     });
   }
+  /**
+   * The board's half of moving a project to another runner, which only the user does, checked
+   * before anything travels and while the hub holds the project's turns: the project is active and
+   * lives on a runner other than `to`, which the board knows; no task there is landing, since its
+   * landing runs on the old runner; and no turn runs in the project. Tasks in play move with their
+   * branches, so the answer lists them for the capabilities the new runner must offer.
+   */
+  async prepareProjectMove(actor, slug, to) {
+    this.assertUser(actor, "only the user may move a project to another runner");
+    const runner2 = NameSchema.parse(to);
+    return this.mutex.run(async () => {
+      const project2 = await this.readActiveProject(slug);
+      const from = project2.runner;
+      if (from === void 0) {
+        throw new BoardError("INVALID_STATE", `project ${slug} lives on no runner yet; its first turn places it`);
+      }
+      if (from === runner2) {
+        throw new BoardError("INVALID_STATE", `project ${slug} already lives on ${runner2}`);
+      }
+      await this.readRunner(runner2);
+      const inPlay = (await this.listTasks(slug)).filter((task2) => task2.status === "open" || task2.status === "claimed");
+      const landing = inPlay.filter((task2) => task2.completing);
+      if (landing.length > 0) {
+        throw new BoardError("INVALID_STATE", `project ${slug} cannot be moved while ${landing.length} task(s) land on ${from} (${landing.map((task2) => task2.id).join(", ")}); move it once they have landed`);
+      }
+      await this.assertProjectQuiet(actor, slug, `project ${slug} cannot be moved`);
+      return { project: { ...project2, runner: from }, inPlay };
+    });
+  }
+  /**
+   * Records that a project moved, once its new runner holds every branch its old one had, or with
+   * nothing carried when the user moved it while the old runner was away: every later turn of
+   * the project goes to `to`. Refused when the project was archived or moved meanwhile.
+   */
+  async recordProjectMove(actor, move) {
+    this.assertUser(actor, "only the user may move a project to another runner");
+    return this.mutex.run(async () => {
+      const current = await this.readActiveProject(move.slug);
+      if (current.runner !== move.from) {
+        throw new BoardError("INVALID_STATE", `project ${move.slug} no longer lives on ${move.from}, so this move no longer applies`);
+      }
+      await this.readRunner(move.to);
+      const project2 = await this.updateProject(move.slug, (each) => ({ ...each, runner: move.to }));
+      await this.events.append("project.moved", actor.name, {
+        slug: move.slug,
+        from: move.from,
+        to: move.to,
+        carried: move.carried
+      });
+      return project2;
+    });
+  }
+  /**
+   * Makes the repository a move carries a project through, for the server's git route to serve,
+   * and answers the move's id, which names it; `dropMoveRepo` removes it when the move ends.
+   */
+  async openMoveRepo() {
+    const id = this.newId();
+    await this.moves.open(this.paths.move(id));
+    return id;
+  }
+  async dropMoveRepo(id) {
+    await this.moves.drop(this.paths.move(UlidSchema.parse(id)));
+  }
+  /** Where the moves' repositories live, which the server's git route serves from. */
+  get moveRepos() {
+    return this.paths.moves();
+  }
   /** The projection a runner mirrors for its agents to read, by relative path, with hashes. */
   async boardManifest() {
     return this.files.manifest(this.paths.board, () => true);
@@ -7117,7 +7326,7 @@ ${rationale}`}`);
   async writeTurnRecord(record) {
     const dir = this.sessionDir(record.agent, record.project, conversationPart(record));
     await ensureDir(dir);
-    await writeJson(path7.join(dir, "last-turn.json"), record);
+    await writeJson(path8.join(dir, "last-turn.json"), record);
   }
   // ---------------------------------------------------------------------------------------------
   // Internals
@@ -7236,8 +7445,8 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
   async ensureAgentProject(name, slug) {
     const dir = this.paths.agentProject(name, slug);
     await ensureDir(dir);
-    if (!await exists(path7.join(dir, "sessions.json"))) {
-      await writeJson(path7.join(dir, "sessions.json"), {});
+    if (!await exists(path8.join(dir, "sessions.json"))) {
+      await writeJson(path8.join(dir, "sessions.json"), {});
     }
   }
   /**
@@ -7479,11 +7688,11 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     const file = this.paths.societySkillFile(skill2.name);
     const replaced = await exists(file);
     const taken = proposal2.skillFiles;
-    const staged = path7.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
+    const staged = path8.join(this.paths.proposalFiles(proposal2.id), "SKILL.md");
     if (taken === void 0 || !await exists(staged)) {
       throw new BoardError("INVALID_STATE", `proposal ${proposal2.id} holds no skill files`);
     }
-    await rm2(dir, { recursive: true, force: true });
+    await rm3(dir, { recursive: true, force: true });
     await cp(this.paths.proposalFiles(proposal2.id), dir, { recursive: true });
     const { body } = await readLooseMarkdown(file);
     await writeMarkdown(file, {
@@ -7536,10 +7745,10 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       return `the frontmatter of ${folder}/SKILL.md in ${proposal2.proposedBy}'s home does not parse (${manual.error})`;
     }
     const dir = this.paths.proposalFiles(proposal2.id);
-    await rm2(dir, { recursive: true, force: true });
+    await rm3(dir, { recursive: true, force: true });
     for (const entry of taken.files) {
-      const target = path7.join(dir, ...entry.path.split("/"));
-      await ensureDir(path7.dirname(target));
+      const target = path8.join(dir, ...entry.path.split("/"));
+      await ensureDir(path8.dirname(target));
       await writeFile4(target, contents.get(entry.path) ?? Buffer.alloc(0));
       await chmod2(target, entry.executable ? 493 : 420);
     }
@@ -7630,7 +7839,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       if (!isSafeRelativePath(entry.path)) {
         continue;
       }
-      const bytes = await readFile4(path7.join(dir, ...entry.path.split("/"))).catch(() => null);
+      const bytes = await readFile4(path8.join(dir, ...entry.path.split("/"))).catch(() => null);
       files.push({
         ...entry,
         ...bytes === null ? { text: null, truncated: false } : skillFileText(bytes)
@@ -7779,7 +7988,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     this.assertNoTurnCut(actor, `${ref} cannot be archived`, (turn2) => turn2.channel === channel && turn2.scope === scope || turn2.thread !== void 0 && closing.has(turn2.thread));
     const threadsClosed = [];
     for (const file of await listFiles(threads)) {
-      const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
       if (doc.data.channel !== ref || doc.data.state !== "open") {
         continue;
       }
@@ -7911,7 +8120,7 @@ ${charter.purpose}
     const threads = this.paths.threads(slug);
     const threadsClosed = [];
     for (const file of await listFiles(threads)) {
-      const doc = await readMarkdown(path7.join(threads, file), ThreadFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(threads, file), ThreadFrontmatterSchema);
       if (doc.data.state !== "open") {
         continue;
       }
@@ -7986,10 +8195,10 @@ ${charter.purpose}
         ...project2,
         members: project2.members.filter((member) => member !== name)
       }));
-      const sessions = path7.join(this.paths.agentProject(name, slug), "sessions.json");
+      const sessions = path8.join(this.paths.agentProject(name, slug), "sessions.json");
       if (await exists(sessions)) {
         const archived = `sessions.archived.${ts.replace(/[:.]/g, "-")}.json`;
-        await rename3(sessions, path7.join(this.paths.agentProject(name, slug), archived));
+        await rename3(sessions, path8.join(this.paths.agentProject(name, slug), archived));
       }
     }
     this.tokenIndex.delete(current.tokenHash);
@@ -8330,7 +8539,7 @@ ${charter.purpose}
       if (since !== null && id <= since || upto !== void 0 && id > upto) {
         continue;
       }
-      const doc = await readMarkdown(path7.join(dir, file), MessageFrontmatterSchema);
+      const doc = await readMarkdown(path8.join(dir, file), MessageFrontmatterSchema);
       messages.push({ ...doc.data, body: doc.body });
     }
     return messages;
@@ -8852,7 +9061,7 @@ knowledge.command("show <topic>").description("Print a knowledge topic").option(
 });
 knowledge.command("write <topic>").description("Write a knowledge topic as the user, from a file or standard input").requiredOption("--revision <n>", "the revision it replaces, as knowledge list shows it; 0 for a new topic").option("--project <slug>", "the project's topic instead of the society's").option("--file <path>", "read the body from this file instead of standard input").option("--as <agent>", "act as this agent instead of the user").action(async (topic, opts) => {
   const board = await open3();
-  const body = opts.file === void 0 ? await readStdin() : await readFile5(path8.resolve(opts.file), "utf8");
+  const body = opts.file === void 0 ? await readStdin() : await readFile5(path9.resolve(opts.file), "utf8");
   const written = await board.writeKnowledge(await actorFor(board, opts.as), {
     project: opts.project ?? null,
     topic,