@glrs-dev/cli 0.3.1 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @glrs-dev/cli
 
+## 1.0.1
+
+### Patch Changes
+
+- [#33](https://github.com/iceglober/glrs/pull/33) [`b3a79cc`](https://github.com/iceglober/glrs/commit/b3a79cc0a9ad2f6247c4d889ee9a08a3cf0f8b41) Thanks [@iceglober](https://github.com/iceglober)! - Rewrite `packages/cli/README.md` as the single source of truth for CLI documentation. Document the bare-`glrs wt` interactive picker behavior (previously undocumented). Content for `glrs.dev/cli/` is now generated from this README via the docs-site custom content loader; there is no longer a separate site overview page to drift from.
+
+## 1.0.0
+
+### Patch Changes
+
+- [#27](https://github.com/iceglober/glrs/pull/27) [`cf74f2d`](https://github.com/iceglober/glrs/commit/cf74f2dca60ee099a92a500d90de1c1886b6aed0) Thanks [@iceglober](https://github.com/iceglober)! - chore(changesets): move @glrs-dev/cli and @glrs-dev/harness-plugin-opencode from `linked` to `fixed`
+
+  The `linked` group synchronizes versions only among packages that are ALREADY being bumped — it does not force a package into a release. A changeset that named only the harness (as most of our changesets do) would ship a new harness on npm without republishing the CLI, even though the CLI vendors the harness `dist/` at build time (`packages/cli/scripts/vendor-harness.ts`). End users running `glrs oc ...` would keep getting the old vendored harness until somebody remembered to write a no-op CLI changeset.
+
+  Moving the pair to `fixed` guarantees any harness publish drags the CLI along at a matching version, so a fresh CLI tarball always re-vendors the latest harness `dist/`. The trade-off — CLI-only changesets now also force a no-op harness republish — is cheap because CLI-only changes are rare in this repo.
+
 ## 0.3.1
 
 ### Patch Changes

package/README.md

@@ -6,33 +6,44 @@ Unified CLI for the [@glrs-dev](https://www.npmjs.com/org/glrs-dev) ecosystem. O
 npm i -g @glrs-dev/cli
 ```
 
+Requires [Bun](https://bun.sh) ≥ 1.2.0 on PATH at runtime.
+
+## `glrs oc` — OpenCode agent harness
+
+Dispatches to [`@glrs-dev/harness-plugin-opencode`](https://www.npmjs.com/package/@glrs-dev/harness-plugin-opencode) (bundled as a dependency). Resolves the bin via `require.resolve` → reads the `bin` field → spawns with argv forwarded.
+
 ```bash
-glrs oc install       # → OpenCode harness install
-glrs wt new feature   # create a worktree
-glrs wt list          # list worktrees across repos
-glrs wt switch        # interactive picker
+glrs oc install       # install the OpenCode harness
+glrs oc --help        # full harness help
 ```
 
-Requires [Bun](https://bun.sh) on PATH at runtime.
-
 The `harness-opencode` bin remains available directly for power users who prefer the untagged entry point.
 
-## How it works
+## `glrs wt` — worktree management
+
+Five named subcommands:
+
+```bash
+glrs wt new <name>    # create a new git worktree
+glrs wt list          # list all worktrees for this repo
+glrs wt switch        # switch to a worktree by name
+glrs wt delete <name> # delete a worktree
+glrs wt cleanup       # remove stale worktrees
+```
 
-The `glrs` binary has two subcommands:
+**Bare invocation:** running `glrs wt` with no arguments in a TTY drops into an interactive picker — select a worktree to switch to without typing its name.
 
-- **`glrs oc <args>`** — dispatches to [`@glrs-dev/harness-plugin-opencode`](../harness-opencode/) (bundled as a dependency). Resolves the bin via `require.resolve(<package>/package.json)` → reads the `bin` field → spawns with argv forwarded.
-- **`glrs wt <args>`** — worktree management, handled natively. Commands: `new`, `list`, `switch`, `delete`, `cleanup`. Worktrees are stored in `~/.glorious/worktrees/<repo>/<name>/`.
+Worktrees are stored in `~/.glorious/worktrees/<repo>/<name>/`.
 
 ## Philosophy
 
 - **Don't duplicate CLI logic.** `glrs oc` is a thin spawn wrapper around `harness-opencode`.
 - **One install, one thing to remember** for the harness + worktree workflow.
-- **Separate concerns stay separate.** The SSO credential tool [`@glrs-dev/assume`](../assume/) is a standalone Rust binary installed separately.
+- **Separate concerns stay separate.** The SSO credential tool [`@glrs-dev/assume`](https://www.npmjs.com/package/@glrs-dev/assume) is a standalone Rust binary installed separately.
 
 ## Docs
 
-[glrs.dev](https://glrs.dev) — full ecosystem docs.
+Full docs at [glrs.dev/cli/](https://glrs.dev/cli/) — generated from this README via the docs-site custom content loader.
 
 ## License
 

package/dist/vendor/harness-opencode/dist/agents/prompts/pilot-builder.md

@@ -80,7 +80,7 @@ If `task.prompt` says "add lodash to handle deep merging", install it. If the ta
 
 If a verify failure clearly points to an environmental issue — `Cannot find module 'X'` where `X` is a workspace/monorepo dep, `node_modules` absent despite a lockfile committed to the repo, a stale build artifact a typecheck depends on — you ARE expected to run the obvious install command BEFORE giving up with STOP.
 
-Recognise these canonical bootstrap commands: `pnpm install`, `bun install`, `npm install`, `npm ci`, `cargo fetch`, `cargo build`. If the plan declared a `setup:` block, treat that block as the canonical list — run those commands verbatim.
+Recognise these canonical bootstrap commands: `pnpm install`, `bun install`, `npm install`, `npm ci`, `cargo fetch`, `cargo build`.
 
 The plugin deny list does not block any of these; they are not task-level dependency additions and they do not require lockfile edits.
 
@@ -111,7 +111,22 @@ If the fix prompt names `touchesViolators`: revert your edits to those files. Us
 - Plan. The plan is `pilot.yaml`. Each task in it was already designed by the pilot-planner agent. You are not a co-author.
 - Refactor unrelated code. The task names a scope; respect it. If you see a glaring issue elsewhere, ignore it — that's a separate task for the human.
 - Add observability/logging beyond what the task asks for. If the task didn't say "add structured logs", don't add structured logs.
-- Run the verify commands yourself. The worker runs them after you stop. Running them yourself wastes turns and can leave residue (test artifacts, cached state) that messes up the worker's run.
 - Apologize, hedge, or narrate. Each turn is a billable opencode session call; chat preamble buys you nothing.
+- **Write TODO, FIXME, HACK, or XXX comments.** Many repos have pre-commit hooks that reject these annotations. The worker commits your work automatically after verify passes; if the commit is blocked by a hook, the task fails. If you need to note future work, put it in the task's output summary, not in a code comment.
 
-You're a focused, fast, pessimistic implementer. Make the change. Stop. The worker will tell you if anything is wrong.
+# Self-verification — run the tests BEFORE you stop
+
+**You SHOULD run the task's verify commands yourself during your work session.** The worker runs them formally after you stop, but you should iterate locally first:
+
+1. Write the code.
+2. Run the verify command(s) listed in the task's `verify:` field.
+3. If they fail, fix the code and re-run. Iterate until they pass.
+4. THEN stop.
+
+This is faster and cheaper than the worker's retry loop (which requires a full session round-trip per attempt). The worker's formal verify is a gate, not your development loop — arrive at the gate already passing.
+
+**How to find the verify commands:** They're in the task kickoff prompt under "Verify commands". Run them exactly as written via bash. They execute in the repo root (cwd).
+
+**Exception:** If a verify command requires infrastructure you can't reach (e.g., a running server on a specific port), note that in your output and stop. The worker will handle it.
+
+You're a focused, fast, pessimistic implementer. Make the change. Verify it passes. Stop.

package/dist/vendor/harness-opencode/dist/agents/prompts/pilot-planner.md

@@ -45,13 +45,13 @@ Use Serena and grep to map out:
 - Existing tests that already cover related code (the verify commands will likely be variations of those).
 - Existing patterns the change should match.
 - Any module boundaries that suggest natural task splits.
-- **Tooling footprint** — lockfiles, docker-compose services, migration tooling, UI/API/DB test frameworks. You'll use these in Section 3 to propose a `setup:` block and per-surface verify patterns.
+- **Tooling footprint** — lockfiles, docker-compose services, migration tooling, UI/API/DB test frameworks. Understanding these informs your per-surface verify patterns in Section 3.
 
 Be thorough here. A planner who shipped a sloppy plan because they only skimmed the codebase wastes hours of pilot-builder time chasing bad scope.
 
 ## 3. Apply the planning methodology
 
-The `pilot-planning` skill carries the ten rules. Apply them:
+The `pilot-planning` skill carries the nine rules. Apply them:
 
 1. First-principles task framing.
 2. Decomposition into right-sized tasks.
@@ -61,8 +61,7 @@ The `pilot-planning` skill carries the ten rules. Apply them:
 6. Optional milestone grouping.
 7. Self-review.
 8. Per-task `context:` population (rationale, code pointers, acceptance shorthand).
-9. **Setup-block authoring** — detect lockfiles (pnpm, bun, npm, yarn, Cargo), docker-compose services, and migration tooling (prisma, drizzle-kit, knex, flyway), then propose specific setup commands to the user for confirmation.
-10. **QA-expectations establishment** — detect per-surface test frameworks and propose concrete verify patterns:
+9. **QA-expectations establishment** — detect per-surface test frameworks and propose concrete verify patterns:
     - **UI**: Playwright, Cypress, or Vitest browser mode for visual/interaction assertions
     - **API**: curl against local endpoints or OpenAPI-based contract tests
     - **DB**: Postgres readiness checks and migration verification (prisma migrate, drizzle-kit push)
@@ -70,7 +69,9 @@ The `pilot-planning` skill carries the ten rules. Apply them:
     - **Browser-based component**: Storybook or Chromatic visual tests
     - **CLI**: bin/ smoke tests or `--help` verification
 
-Rules 9 and 10 typically involve ONE bundled `question` tool call to the user — combine setup proposals and per-surface verify proposals into a single round (respecting "talk to the user — once" guidance).
+Rule 9 typically involves ONE bundled `question` tool call to the user for QA verify patterns (respecting "talk to the user — once" guidance).
+
+Note: The `setup:` field was removed in the cwd-mode rollback. Plans assume the user's dev stack is already running (install, compose, migrate, seed) before `pilot build` is invoked. Remind the user of this at hand-off.
 
 ## 4. Write the YAML
 
@@ -80,10 +81,6 @@ Required schema (see `src/pilot/plan/schema.ts` for the canonical Zod definition
 
 ```yaml
 name: <human-readable plan name>
-setup:                          # optional — run once per worktree before any task
-  - pnpm install --frozen-lockfile
-  - docker compose up -d postgres
-  - pnpm prisma migrate dev
 defaults:                       # optional, override per-task as needed
   agent: pilot-builder          # default
   model: anthropic/claude-sonnet-4-6
@@ -114,6 +111,17 @@ tasks:
     touches:
       - src/api/**
       - test/api/**
+    tolerate:                   # optional — files that may appear in
+                                # the diff but aren't part of the task's
+                                # scope (project-specific codegen,
+                                # framework side-effects beyond the
+                                # built-in defaults like next-env.d.ts).
+                                # Common entries: prisma/client/**,
+                                # graphql/generated/**, schema.graphql.
+                                # Built-in defaults already cover
+                                # next-env.d.ts, .next/types/**,
+                                # *.tsbuildinfo, __snapshots__/**.
+      - prisma/client/**
     verify:
       - bun test test/api
     depends_on: [ ]              # other task ids
@@ -154,6 +162,8 @@ Don't elaborate. Don't summarize the plan in chat. The user can read it.
 
 - **Asking the human to clarify mid-build.** Don't write tasks whose prompts contain things like "ask the user about X". Pilot is unattended. If you don't know X, either ASK NOW (during the planning session) or design the task to discover X via reading code.
 
+- **YAML quoting errors in titles/prompts.** If a string contains double quotes, wrap it in single quotes: `title: '"Test rule set" UI + hook'`. If it contains single quotes, use double quotes with escaped inner quotes: `title: "it's a \"test\""`. NEVER write `title: "word" more words` — YAML closes the scalar at the second `"`. Run `pilot validate` after saving; it catches these.
+
 # What "done" looks like
 
 A plan that:

package/dist/vendor/harness-opencode/dist/chunk-57EOY72Y.js

@@ -0,0 +1,174 @@
+// src/pilot/state/tasks.ts
+function upsertFromPlan(db, runId, plan) {
+  const stmt = db.prepare(
+    `INSERT OR IGNORE INTO tasks (run_id, task_id, status) VALUES (?, ?, 'pending')`
+  );
+  const tx = db.transaction(() => {
+    for (const t of plan.tasks) {
+      stmt.run(runId, t.id);
+    }
+  });
+  tx();
+}
+function markReady(db, runId, taskId) {
+  requireStatus(db, runId, taskId, ["pending"], "ready");
+  db.run(
+    "UPDATE tasks SET status='ready' WHERE run_id=? AND task_id=?",
+    [runId, taskId]
+  );
+}
+function markRunning(db, args) {
+  requireStatus(db, args.runId, args.taskId, ["ready"], "running");
+  const now = args.now ?? Date.now();
+  db.run(
+    `UPDATE tasks
+     SET status='running',
+         attempts = attempts + 1,
+         session_id = ?,
+         branch = ?,
+         worktree_path = ?,
+         started_at = COALESCE(started_at, ?)
+     WHERE run_id=? AND task_id=?`,
+    [args.sessionId, args.branch, args.worktreePath, now, args.runId, args.taskId]
+  );
+}
+function markSucceeded(db, runId, taskId, now = Date.now()) {
+  requireStatus(db, runId, taskId, ["running"], "succeeded");
+  db.run(
+    `UPDATE tasks
+     SET status='succeeded', finished_at=?, last_error=NULL
+     WHERE run_id=? AND task_id=?`,
+    [now, runId, taskId]
+  );
+}
+function markFailed(db, runId, taskId, reason, now = Date.now()) {
+  requireStatus(db, runId, taskId, ["running", "ready"], "failed");
+  db.run(
+    `UPDATE tasks
+     SET status='failed', finished_at=?, last_error=?
+     WHERE run_id=? AND task_id=?`,
+    [now, reason, runId, taskId]
+  );
+}
+function markBlocked(db, runId, taskId, reason) {
+  requireStatus(db, runId, taskId, ["pending", "ready"], "blocked");
+  db.run(
+    `UPDATE tasks
+     SET status='blocked', last_error=?
+     WHERE run_id=? AND task_id=?`,
+    [reason, runId, taskId]
+  );
+}
+function markAborted(db, runId, taskId, reason, now = Date.now()) {
+  requireStatus(db, runId, taskId, ["running", "ready"], "aborted");
+  db.run(
+    `UPDATE tasks
+     SET status='aborted', finished_at=?, last_error=?
+     WHERE run_id=? AND task_id=?`,
+    [now, reason, runId, taskId]
+  );
+}
+function markPending(db, runId, taskId) {
+  const cur = getTask(db, runId, taskId);
+  if (!cur) {
+    throw new Error(
+      `markPending: task ${JSON.stringify(taskId)} not found in run ${JSON.stringify(runId)}`
+    );
+  }
+  db.run(
+    `UPDATE tasks
+     SET status='pending',
+         session_id=NULL,
+         branch=NULL,
+         worktree_path=NULL,
+         started_at=NULL,
+         finished_at=NULL,
+         last_error=NULL
+     WHERE run_id=? AND task_id=?`,
+    [runId, taskId]
+  );
+}
+function setCostUsd(db, runId, taskId, costUsd) {
+  if (!Number.isFinite(costUsd) || costUsd < 0) {
+    throw new RangeError(`setCostUsd: invalid cost ${costUsd}`);
+  }
+  db.run(
+    "UPDATE tasks SET cost_usd=? WHERE run_id=? AND task_id=?",
+    [costUsd, runId, taskId]
+  );
+}
+function getTask(db, runId, taskId) {
+  return db.query("SELECT * FROM tasks WHERE run_id=? AND task_id=?").get(runId, taskId);
+}
+function listTasks(db, runId) {
+  return db.query("SELECT * FROM tasks WHERE run_id=? ORDER BY task_id").all(runId);
+}
+function readyTasks(db, runId) {
+  return db.query("SELECT * FROM tasks WHERE run_id=? AND status='ready' ORDER BY task_id").all(runId);
+}
+function countByStatus(db, runId) {
+  const rows = db.query("SELECT status, COUNT(*) as n FROM tasks WHERE run_id=? GROUP BY status").all(runId);
+  const out = {
+    pending: 0,
+    ready: 0,
+    running: 0,
+    succeeded: 0,
+    failed: 0,
+    blocked: 0,
+    aborted: 0
+  };
+  for (const r of rows) out[r.status] = r.n;
+  return out;
+}
+function resetTasksForResume(db, runId) {
+  const rows = listTasks(db, runId);
+  const resettable = rows.filter((r) => r.status !== "succeeded");
+  if (resettable.length === 0) return [];
+  const stmt = db.prepare(
+    `UPDATE tasks
+     SET status='pending',
+         attempts=0,
+         session_id=NULL,
+         last_error=NULL,
+         started_at=NULL,
+         finished_at=NULL,
+         branch=NULL,
+         worktree_path=NULL
+     WHERE run_id=? AND task_id=? AND status != 'succeeded'`
+  );
+  const tx = db.transaction(() => {
+    for (const r of resettable) stmt.run(runId, r.task_id);
+  });
+  tx();
+  return resettable.map((r) => r.task_id);
+}
+function requireStatus(db, runId, taskId, expected, intended) {
+  const row = getTask(db, runId, taskId);
+  if (!row) {
+    throw new Error(
+      `task ${JSON.stringify(taskId)} not found in run ${JSON.stringify(runId)}`
+    );
+  }
+  if (!expected.includes(row.status)) {
+    throw new Error(
+      `cannot move task ${JSON.stringify(taskId)} from ${row.status} to ${intended} (expected one of: ${expected.join(", ")})`
+    );
+  }
+}
+
+export {
+  upsertFromPlan,
+  markReady,
+  markRunning,
+  markSucceeded,
+  markFailed,
+  markBlocked,
+  markAborted,
+  markPending,
+  setCostUsd,
+  getTask,
+  listTasks,
+  readyTasks,
+  countByStatus,
+  resetTasksForResume
+};

package/dist/vendor/harness-opencode/dist/chunk-5TAMY7P6.js

@@ -0,0 +1,67 @@
+// src/pilot/state/runs.ts
+import { ulid } from "ulid";
+function createRun(db, args) {
+  const id = ulid();
+  const now = args.now ?? Date.now();
+  db.run(
+    `INSERT INTO runs (id, plan_path, plan_slug, started_at, status)
+     VALUES (?, ?, ?, ?, 'pending')`,
+    [id, args.planPath, args.slug, now]
+  );
+  void args.plan;
+  return id;
+}
+function markRunRunning(db, runId) {
+  const cur = getRun(db, runId);
+  if (!cur) throw new Error(`markRunRunning: run ${JSON.stringify(runId)} not found`);
+  if (cur.status === "running") return;
+  if (cur.status !== "pending") {
+    throw new Error(
+      `markRunRunning: cannot move run ${JSON.stringify(runId)} from ${cur.status} to running`
+    );
+  }
+  db.run("UPDATE runs SET status='running' WHERE id=?", [runId]);
+}
+function markRunFinished(db, runId, status, now = Date.now()) {
+  if (status !== "completed" && status !== "aborted" && status !== "failed") {
+    throw new Error(
+      `markRunFinished: ${JSON.stringify(status)} is not a terminal status`
+    );
+  }
+  const cur = getRun(db, runId);
+  if (!cur) {
+    throw new Error(`markRunFinished: run ${JSON.stringify(runId)} not found`);
+  }
+  db.run("UPDATE runs SET status=?, finished_at=? WHERE id=?", [status, now, runId]);
+}
+function markRunResumed(db, runId) {
+  const cur = getRun(db, runId);
+  if (!cur) throw new Error(`markRunResumed: run ${JSON.stringify(runId)} not found`);
+  if (cur.status === "completed") {
+    throw new Error(
+      `markRunResumed: run ${JSON.stringify(runId)} is already completed; nothing to resume`
+    );
+  }
+  db.run("UPDATE runs SET status='running', finished_at=NULL WHERE id=?", [runId]);
+}
+function getRun(db, runId) {
+  const row = db.query("SELECT * FROM runs WHERE id=?").get(runId);
+  return row;
+}
+function listRuns(db, limit = 100) {
+  return db.query("SELECT * FROM runs ORDER BY started_at DESC LIMIT ?").all(limit);
+}
+function latestRun(db) {
+  const row = db.query("SELECT * FROM runs ORDER BY started_at DESC LIMIT 1").get();
+  return row;
+}
+
+export {
+  createRun,
+  markRunRunning,
+  markRunFinished,
+  markRunResumed,
+  getRun,
+  listRuns,
+  latestRun
+};

package/dist/vendor/harness-opencode/dist/chunk-BKTFWXLG.js

@@ -0,0 +1,204 @@
+// src/pilot/paths.ts
+import { promises as fs2 } from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+
+// src/plan-paths.ts
+import { execFile } from "child_process";
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function execFileP(file, args, opts = {}) {
+  const { cwd, timeoutMs = 5e3 } = opts;
+  return new Promise((resolve2, reject) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    execFile(
+      file,
+      args,
+      { signal: controller.signal, cwd, encoding: "utf8" },
+      (err, stdout) => {
+        clearTimeout(timer);
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve2(stdout ?? "");
+      }
+    );
+  });
+}
+function expandTilde(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+async function getRepoFolder(worktreeDir) {
+  let stdout;
+  try {
+    stdout = await execFileP(
+      "git",
+      ["rev-parse", "--git-common-dir"],
+      { cwd: worktreeDir }
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error running `git rev-parse --git-common-dir`";
+    throw new Error(
+      `getRepoFolder: failed to resolve git-common-dir for ${worktreeDir}: ${msg}`
+    );
+  }
+  const gitCommonDir = stdout.trim();
+  if (!gitCommonDir) {
+    throw new Error(
+      `getRepoFolder: \`git rev-parse --git-common-dir\` returned empty for ${worktreeDir}`
+    );
+  }
+  const absCommonDir = path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(worktreeDir, gitCommonDir);
+  const repoRoot = path.dirname(absCommonDir);
+  return path.basename(repoRoot);
+}
+async function getPlanDir(worktreeDir) {
+  const override = process.env.GLORIOUS_PLAN_DIR;
+  const base = override ? expandTilde(override) : path.join(os.homedir(), ".glorious", "opencode");
+  const repoFolder = await getRepoFolder(worktreeDir);
+  const planDir = path.join(base, repoFolder, "plans");
+  await fs.mkdir(planDir, { recursive: true });
+  return planDir;
+}
+async function migratePlans(worktreeDir, planDir) {
+  const oldDir = path.join(worktreeDir, ".agent", "plans");
+  const marker = path.join(oldDir, ".migrated");
+  try {
+    await fs.stat(oldDir);
+  } catch {
+    return;
+  }
+  try {
+    await fs.stat(marker);
+    return;
+  } catch {
+  }
+  let entries;
+  try {
+    entries = await fs.readdir(oldDir);
+  } catch {
+    return;
+  }
+  const planFiles = entries.filter(
+    (name) => name.endsWith(".md") && !name.startsWith(".")
+  );
+  await fs.mkdir(planDir, { recursive: true });
+  for (const name of planFiles) {
+    const src = path.join(oldDir, name);
+    const dst = path.join(planDir, name);
+    let dstExists = false;
+    try {
+      await fs.stat(dst);
+      dstExists = true;
+    } catch {
+      dstExists = false;
+    }
+    if (!dstExists) {
+      await fs.rename(src, dst);
+      continue;
+    }
+    const [srcBuf, dstBuf] = await Promise.all([
+      fs.readFile(src),
+      fs.readFile(dst)
+    ]);
+    if (srcBuf.equals(dstBuf)) {
+      await fs.unlink(src);
+      continue;
+    }
+    process.stderr.write(
+      `[harness-opencode] migratePlans: conflict on ${name} \u2014 destination ${dst} exists with different content; leaving source ${src} in place. Resolve manually.
+`
+    );
+  }
+  await fs.writeFile(marker, "");
+}
+
+// src/pilot/paths.ts
+function expandTilde2(p) {
+  if (p === "~") return os2.homedir();
+  if (p.startsWith("~/")) return path2.join(os2.homedir(), p.slice(2));
+  return p;
+}
+function resolveBaseDir() {
+  const pilotEnv = process.env.GLORIOUS_PILOT_DIR;
+  if (pilotEnv) return expandTilde2(pilotEnv);
+  const planEnv = process.env.GLORIOUS_PLAN_DIR;
+  if (planEnv) {
+    return path2.dirname(expandTilde2(planEnv));
+  }
+  return path2.join(os2.homedir(), ".glorious", "opencode");
+}
+async function getPilotDir(cwd) {
+  const base = resolveBaseDir();
+  const repoFolder = await getRepoFolder(cwd);
+  const dir = path2.join(base, repoFolder, "pilot");
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getPlansDir(cwd) {
+  const pilot = await getPilotDir(cwd);
+  const dir = path2.join(pilot, "plans");
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getRunDir(cwd, runId) {
+  if (!isSafeRunId(runId)) {
+    throw new Error(
+      `getRunDir: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
+    );
+  }
+  const pilot = await getPilotDir(cwd);
+  const dir = path2.join(pilot, "runs", runId);
+  await fs2.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function getStateDbPath(cwd, runId) {
+  const runDir = await getRunDir(cwd, runId);
+  return path2.join(runDir, "state.db");
+}
+async function getWorkerJsonlPath(cwd, runId, n) {
+  const runDir = await getRunDir(cwd, runId);
+  const workersDir = path2.join(runDir, "workers");
+  await fs2.mkdir(workersDir, { recursive: true });
+  const padded = n.toString().padStart(2, "0");
+  return path2.join(workersDir, `${padded}.jsonl`);
+}
+async function getTaskJsonlPath(cwd, runId, taskId) {
+  if (!isSafeRunId(runId)) {
+    throw new Error(
+      `getTaskJsonlPath: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
+    );
+  }
+  if (!isSafeTaskId(taskId)) {
+    throw new Error(
+      `getTaskJsonlPath: taskId ${JSON.stringify(taskId)} is not a safe filesystem segment`
+    );
+  }
+  const runDir = await getRunDir(cwd, runId);
+  const taskDir = path2.join(runDir, "tasks", taskId);
+  await fs2.mkdir(taskDir, { recursive: true });
+  return path2.join(taskDir, "session.jsonl");
+}
+function isSafeRunId(runId) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(runId);
+}
+function isSafeTaskId(taskId) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(taskId);
+}
+
+export {
+  getPlanDir,
+  migratePlans,
+  resolveBaseDir,
+  getPilotDir,
+  getPlansDir,
+  getRunDir,
+  getStateDbPath,
+  getWorkerJsonlPath,
+  getTaskJsonlPath
+};