@titan-design/active-work 0.2.0 → 0.3.0

package/dist/{chunk-FM2KVFDO.js → chunk-HSGZOWS3.js}

@@ -30,30 +30,24 @@ function getInitiativeDir(slug) {
 function getLockPath(slug) {
   return path.join(getInitiativeDir(slug), ".lock");
 }
-
-// src/registry/json-envelope.ts
-function successEnvelope(data, warnings) {
-  if (warnings && warnings.length > 0) {
-    return { ok: true, data, warnings };
-  }
-  return { ok: true, data };
-}
-function errorEnvelope(error, code) {
-  return { ok: false, error, code };
+function getMinerRoot() {
+  return path.join(getActiveRoot(), ".miner");
 }
 
+// src/registry/index.ts
+import { createRegistry } from "@titan-design/registry";
+
 // src/registry/types.ts
+import { defineCommand as pkgDefineCommand } from "@titan-design/registry";
 function defineCommand(cmd) {
-  return cmd;
+  return pkgDefineCommand(cmd);
 }
 
 // src/registry/index.ts
-var registry = /* @__PURE__ */ new Map();
+import { successEnvelope, errorEnvelope } from "@titan-design/registry";
+var registry = createRegistry();
 function register(cmd) {
-  if (registry.has(cmd.name)) {
-    throw new Error(`Command already registered: ${cmd.name}`);
-  }
-  registry.set(cmd.name, cmd);
+  registry.register(cmd);
 }
 
 // src/errors.ts
@@ -125,9 +119,39 @@ function formatError(err) {
   return { message: String(err), code: EXIT.GENERIC };
 }
 
-// src/commands/open.ts
-import path14 from "path";
-import { z as z8 } from "zod";
+// src/launcher-args.ts
+function mergeChannels(defaultChannels, briefChannels) {
+  const merged = [...defaultChannels ?? [], ...briefChannels ?? []];
+  return [...new Set(merged)];
+}
+function buildChannelArgs(channels) {
+  if (!channels || channels.length === 0) return [];
+  const targets = channels.map((raw) => /^(server|plugin):/.test(raw) ? raw : `server:${raw}`);
+  const plugins = targets.filter((t) => t.startsWith("plugin:"));
+  const servers = targets.filter((t) => !t.startsWith("plugin:"));
+  return [
+    ...plugins.length > 0 ? ["--channels", ...plugins] : [],
+    ...servers.length > 0 ? ["--dangerously-load-development-channels", ...servers] : []
+  ];
+}
+function buildClaudeArgs(prompt, channels) {
+  return [...buildChannelArgs(channels), "--", prompt];
+}
+var ADHOC_FLAGS = ["--adhoc", "--ad-hoc"];
+function parseLauncherFlags(args) {
+  const known = /* @__PURE__ */ new Set(["--pick", ...ADHOC_FLAGS]);
+  const positional = args.filter((a) => !known.has(a));
+  return {
+    pick: args.includes("--pick"),
+    adhoc: args.some((a) => ADHOC_FLAGS.includes(a)),
+    positional,
+    usageError: positional.some((a) => a.startsWith("-")) || positional.length > 1
+  };
+}
+
+// src/commands/_open-helpers.ts
+import { promises as fs11 } from "fs";
+import path11 from "path";
 
 // src/schemas/brief.ts
 import { z } from "zod";
@@ -161,7 +185,9 @@ var BriefFrontmatterSchema = z.object({
   // High-water mark for task ids: the largest numeric suffix ever issued
   // for this initiative's task_prefix. Optional so pre-existing brief.md
   // files (written before this field existed) keep validating; task.add
-  // falls back to scanning on-disk task files when it's absent.
+  // falls back to scanning on-disk task files when it's absent. Only
+  // task.delete writes this field (AW-94) — and only when removing the
+  // current highest id — so task.add itself never rewrites brief.md.
   task_seq: TaskSeqSchema.optional()
 }).superRefine((value, ctx) => {
   if (value.state === "focused" && value.rank === void 0) {
@@ -434,8 +460,8 @@ async function writeArtifactsFile(initiativeDir, artifacts) {
 }
 
 // src/bootstrap/prompt.ts
-import { promises as fs11 } from "fs";
-import path11 from "path";
+import { promises as fs10 } from "fs";
+import path10 from "path";
 
 // src/schemas/task.ts
 import { z as z3 } from "zod";
@@ -528,7 +554,13 @@ var SessionFrontmatterSchema = z4.object({
   resolves: z4.array(SessionResolveSchema).default([]),
   // Written only by `wrap --no-loops`. An empty ledger alone cannot say
   // whether nothing was hanging or nothing was filed; this marker does.
-  no_loops: z4.literal(true).optional()
+  no_loops: z4.literal(true).optional(),
+  // The session that spawned this one (AW-26). Set for agent-chat peers,
+  // whose parentage is known only to the spawning hook — a peer runs as its
+  // own `claude` process, so nothing in its transcript records who asked for
+  // it. Built-in subagents are linked in the miner index instead, where the
+  // relationship *is* derivable from the transcript tree.
+  parent_session_id: SessionIdSchema.optional()
 }).superRefine((value, ctx) => {
   const started = new Date(value.started).getTime();
   const ended = new Date(value.ended).getTime();
@@ -983,9 +1015,9 @@ async function writeNoteFile(initiativeDir, frontmatter, body) {
 }
 
 // src/sessions/lease.ts
-import { promises as fs10, unlinkSync } from "fs";
+import { promises as fs9, unlinkSync } from "fs";
 import { randomBytes as randomBytes2 } from "crypto";
-import path9 from "path";
+import path8 from "path";
 
 // src/schemas/lease.ts
 import { z as z7 } from "zod";
@@ -1006,95 +1038,47 @@ var LeaseSchema = z7.object({
   mode: LeaseModeSchema,
   /** Present only for `launcher` leases — the `aw` process to probe. */
   pid: z7.number().int().positive().optional(),
+  /**
+   * `pid`'s command name (e.g. `node`) at the moment the lease was written.
+   * Lets liveness checking tell "still the same process" apart from "the OS
+   * recycled this pid onto something unrelated" — `kill(pid, 0)` alone can't.
+   * Best-effort: absent when the lookup failed, in which case liveness falls
+   * back to the pid check alone.
+   */
+  pid_comm: z7.string().min(1).optional(),
   started: iso86012,
   /** Human/role hint carried for future use (e.g. an agent-chat name). */
   label: z7.string().min(1).optional()
 });
 
 // src/server/lifecycle.ts
-import { promises as fs9 } from "fs";
-import path8 from "path";
-function pidPath() {
-  return path8.join(getStateRoot(), "daemon.pid");
-}
-function metaPath() {
-  return path8.join(getStateRoot(), "daemon.meta.json");
-}
-async function ensureStateDir() {
-  await fs9.mkdir(getStateRoot(), { recursive: true });
-}
-async function writePidFile(pid, meta) {
-  await ensureStateDir();
-  await fs9.writeFile(pidPath(), String(pid), "utf8");
-  await fs9.writeFile(metaPath(), JSON.stringify(meta, null, 2), "utf8");
+import {
+  daemonPaths,
+  probeHealth as pkgProbeHealth,
+  readPidFile as pkgReadPidFile,
+  removePidFile as pkgRemovePidFile,
+  writePidFile as pkgWritePidFile
+} from "@titan-design/daemon";
+import { DEFAULT_DAEMON_PORT, getProcessCommand, isProcessAlive } from "@titan-design/daemon";
+function paths2() {
+  return daemonPaths(getStateRoot());
 }
 async function readPidFile() {
-  let pidRaw;
-  try {
-    pidRaw = await fs9.readFile(pidPath(), "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
-  }
-  const pid = Number.parseInt(pidRaw.trim(), 10);
-  if (!Number.isFinite(pid)) return null;
-  let metaRaw;
-  try {
-    metaRaw = await fs9.readFile(metaPath(), "utf8");
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-  const meta = metaRaw ? JSON.parse(metaRaw) : { port: 0, version: "unknown", started: "" };
-  return { pid, meta };
+  return pkgReadPidFile(paths2());
 }
 async function removePidFile(expectedPid) {
-  const current = await readPidFile();
-  if (current === null) return false;
-  if (current.pid !== expectedPid) return false;
-  for (const p of [pidPath(), metaPath()]) {
-    try {
-      await fs9.unlink(p);
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
-  }
-  return true;
+  return pkgRemovePidFile(paths2(), expectedPid);
 }
-var DEFAULT_DAEMON_PORT = 7400;
 function resolveDaemonPort() {
   const envPort = process.env.AW_PORT;
   if (envPort) {
     const n = Number.parseInt(envPort, 10);
     if (Number.isFinite(n)) return n;
   }
-  return DEFAULT_DAEMON_PORT;
+  return 7400;
 }
-var HEALTH_TIMEOUT_MS = 500;
 async function probeHealth(port) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/health`, {
-      signal: controller.signal
-    });
-    if (!res.ok) return null;
-    return await res.json();
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function isProcessAlive(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    const code = err.code;
-    if (code === "EPERM") return true;
-    return false;
-  }
+  return await pkgProbeHealth(port);
 }
 
 // src/sessions/lease.ts
@@ -1102,25 +1086,36 @@ var ONESHOT_TTL_MS = 90 * 6e4;
 var LAUNCHER_MAX_AGE_MS = 36 * 60 * 6e4;
 var LEASE_DIR_NAME = ".sessions";
 function leaseDir(activeRoot, slug) {
-  return path9.join(activeRoot, LEASE_DIR_NAME, slug);
+  return path8.join(activeRoot, LEASE_DIR_NAME, slug);
 }
 function leasePath(activeRoot, slug, leaseId) {
-  return path9.join(leaseDir(activeRoot, slug), `${leaseId}.json`);
+  return path8.join(leaseDir(activeRoot, slug), `${leaseId}.json`);
 }
 async function acquireLease(input) {
-  const { activeRoot, slug, cwd, mode, pid, label, now = /* @__PURE__ */ new Date() } = input;
+  const {
+    activeRoot,
+    slug,
+    cwd,
+    mode,
+    pid,
+    label,
+    now = /* @__PURE__ */ new Date(),
+    getComm = getProcessCommand
+  } = input;
   const leaseId = randomBytes2(8).toString("hex");
+  const pidComm = mode === "launcher" && pid !== void 0 ? getComm(pid) : null;
   const lease = LeaseSchema.parse({
     lease_id: leaseId,
     slug,
     cwd,
     mode,
     ...mode === "launcher" && pid !== void 0 ? { pid } : {},
+    ...pidComm ? { pid_comm: pidComm } : {},
     started: now.toISOString(),
     ...label ? { label } : {}
   });
-  await fs10.mkdir(leaseDir(activeRoot, slug), { recursive: true });
-  await fs10.writeFile(leasePath(activeRoot, slug, leaseId), JSON.stringify(lease, null, 2), "utf8");
+  await fs9.mkdir(leaseDir(activeRoot, slug), { recursive: true });
+  await fs9.writeFile(leasePath(activeRoot, slug, leaseId), JSON.stringify(lease, null, 2), "utf8");
   return {
     leaseId,
     release: () => releaseLease(activeRoot, slug, leaseId)
@@ -1132,7 +1127,7 @@ function isIgnorableUnlinkError(err) {
 }
 async function releaseLease(activeRoot, slug, leaseId) {
   try {
-    await fs10.unlink(leasePath(activeRoot, slug, leaseId));
+    await fs9.unlink(leasePath(activeRoot, slug, leaseId));
   } catch (err) {
     if (!isIgnorableUnlinkError(err)) throw err;
   }
@@ -1143,12 +1138,14 @@ function releaseLeaseSync(activeRoot, slug, leaseId) {
   } catch {
   }
 }
-function isLive(lease, now, isAlive) {
+function isLive(lease, now, isAlive, getComm) {
   const ageMs = now.getTime() - new Date(lease.started).getTime();
   if (lease.mode === "oneshot") return ageMs < ONESHOT_TTL_MS;
   if (lease.pid === void 0) return false;
   if (ageMs >= LAUNCHER_MAX_AGE_MS) return false;
-  return isAlive(lease.pid);
+  if (!isAlive(lease.pid)) return false;
+  if (lease.pid_comm === void 0) return true;
+  return getComm(lease.pid) === lease.pid_comm;
 }
 function toSibling(lease) {
   return {
@@ -1162,7 +1159,7 @@ function toSibling(lease) {
 }
 async function readOneLease(file) {
   try {
-    const raw = await fs10.readFile(file, "utf8");
+    const raw = await fs9.readFile(file, "utf8");
     const parsed = LeaseSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : null;
   } catch {
@@ -1171,26 +1168,33 @@ async function readOneLease(file) {
 }
 async function unlinkQuietly(file) {
   try {
-    await fs10.unlink(file);
+    await fs9.unlink(file);
   } catch {
   }
 }
 async function readLiveLeases(input) {
-  const { activeRoot, slug, now = /* @__PURE__ */ new Date(), excludeLeaseId, isAlive = isProcessAlive } = input;
+  const {
+    activeRoot,
+    slug,
+    now = /* @__PURE__ */ new Date(),
+    excludeLeaseId,
+    isAlive = isProcessAlive,
+    getComm = getProcessCommand
+  } = input;
   try {
     const dir = leaseDir(activeRoot, slug);
     let entries;
     try {
-      entries = await fs10.readdir(dir);
+      entries = await fs9.readdir(dir);
     } catch {
       return [];
     }
     const live = [];
     for (const name of entries) {
       if (!name.endsWith(".json")) continue;
-      const file = path9.join(dir, name);
+      const file = path8.join(dir, name);
       const lease = await readOneLease(file);
-      if (!lease || !isLive(lease, now, isAlive)) {
+      if (!lease || !isLive(lease, now, isAlive, getComm)) {
         await unlinkQuietly(file);
         continue;
       }
@@ -1203,10 +1207,10 @@ async function readLiveLeases(input) {
   }
 }
 async function sweepAllLeases(activeRoot, options = {}) {
-  const root = path9.join(activeRoot, LEASE_DIR_NAME);
+  const root = path8.join(activeRoot, LEASE_DIR_NAME);
   let slugs;
   try {
-    const entries = await fs10.readdir(root, { withFileTypes: true });
+    const entries = await fs9.readdir(root, { withFileTypes: true });
     slugs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   } catch (err) {
     const code = err.code;
@@ -1217,7 +1221,7 @@ async function sweepAllLeases(activeRoot, options = {}) {
   let before = 0;
   for (const slug of slugs) {
     try {
-      const names = await fs10.readdir(leaseDir(activeRoot, slug));
+      const names = await fs9.readdir(leaseDir(activeRoot, slug));
       before += names.filter((n) => n.endsWith(".json")).length;
       live += (await readLiveLeases({ activeRoot, slug, ...options })).length;
     } catch (err) {
@@ -1229,7 +1233,7 @@ async function sweepAllLeases(activeRoot, options = {}) {
 
 // src/utils/git-gh.ts
 import { spawn } from "child_process";
-import path10 from "path";
+import path9 from "path";
 var DEFAULT_TIMEOUT_MS = 1e4;
 var defaultRunner = (bin, args, opts = {}) => new Promise((resolve, reject) => {
   const child = spawn(bin, args, {
@@ -1281,7 +1285,7 @@ function looksLikeOrgRepo(repo) {
 }
 function resolveLocalRepoPath(repo) {
   if (looksLikeOrgRepo(repo)) return null;
-  return path10.resolve(expandTilde(repo));
+  return path9.resolve(expandTilde(repo));
 }
 async function deriveOrgRepoFromPath(repoPath) {
   try {
@@ -1324,7 +1328,7 @@ var MS_PER_HOUR = 1e3 * 60 * 60;
 var MS_PER_DAY2 = MS_PER_HOUR * 24;
 var FRONTMATTER_DELIM2 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 async function readMarkdownWithSchema(filePath, schema) {
-  const raw = await fs11.readFile(filePath, "utf8");
+  const raw = await fs10.readFile(filePath, "utf8");
   const match = FRONTMATTER_DELIM2.exec(raw);
   let frontmatterText = "";
   let body = raw;
@@ -1352,10 +1356,10 @@ function describe2(err) {
   return err instanceof Error ? err.message : String(err);
 }
 async function loadTasks(initiativeDir) {
-  const tasksDir = path11.join(initiativeDir, "tasks");
+  const tasksDir = path10.join(initiativeDir, "tasks");
   let entries;
   try {
-    entries = await fs11.readdir(tasksDir);
+    entries = await fs10.readdir(tasksDir);
   } catch {
     return { tasks: [], malformed: [] };
   }
@@ -1363,7 +1367,7 @@ async function loadTasks(initiativeDir) {
   const tasks = [];
   const malformed = [];
   for (const filename of ymlFiles) {
-    const fullPath = path11.join(tasksDir, filename);
+    const fullPath = path10.join(tasksDir, filename);
     try {
       tasks.push(await readYaml(fullPath, TaskSchema));
     } catch (err) {
@@ -1376,7 +1380,7 @@ function isMissingFile(err) {
   return err?.code === "ENOENT";
 }
 async function loadArtifacts(initiativeDir) {
-  const artifactsPath = path11.join(initiativeDir, "artifacts.yml");
+  const artifactsPath = path10.join(initiativeDir, "artifacts.yml");
   const empty = { branches: [], stashes: [], worktrees: [] };
   try {
     return { artifacts: await readYaml(artifactsPath, ArtifactsSchema) };
@@ -1879,7 +1883,7 @@ function renderBriefState(brief, now) {
 ${lines.join("\n")}`;
 }
 async function loadBrief(initiativeDir, slug) {
-  const briefPath = path11.join(initiativeDir, "brief.md");
+  const briefPath = path10.join(initiativeDir, "brief.md");
   try {
     return await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
   } catch (err) {
@@ -1902,7 +1906,7 @@ async function assembleBootstrap(input) {
     siblingProbe = readLiveLeases,
     ownLeaseId
   } = input;
-  const initiativeDir = path11.join(activeRoot, slug);
+  const initiativeDir = path10.join(activeRoot, slug);
   const { frontmatter: brief, body: briefBody } = await loadBrief(initiativeDir, slug);
   const [loaded, loadedTasks, loadedArtifacts, notes] = await Promise.all([
     loadSessionsNewestFirst(initiativeDir),
@@ -1919,7 +1923,7 @@ async function assembleBootstrap(input) {
   const narrativeSession = latestCanonical ?? sessions[0];
   const usedFallbackTrack = !latestCanonical && narrativeSession !== void 0;
   const parallelBody = renderParallelSessions(selectParallelSessions(sessions, narrativeSession));
-  const briefExcerpt = truncateLines(briefBody, BRIEF_BODY_MAX_LINES, path11.join(initiativeDir, "brief.md")) || "_(no brief body)_";
+  const briefExcerpt = truncateLines(briefBody, BRIEF_BODY_MAX_LINES, path10.join(initiativeDir, "brief.md")) || "_(no brief body)_";
   const { body: tasksBody, count: openTaskCount } = renderTopTasks(tasks, topNTasks, slug);
   const { body: recentlyDoneBody, count: recentlyDoneCount } = renderRecentlyDone(
     tasks,
@@ -1971,7 +1975,7 @@ ${briefExcerpt}`);
     const sessionExcerpt = truncateLines(
       narrativeSession.body,
       SESSION_BODY_MAX_LINES,
-      path11.join(initiativeDir, "sessions", `${narrativeSession.sessionFile}.md`)
+      path10.join(initiativeDir, "sessions", `${narrativeSession.sessionFile}.md`)
     ) || "_(empty session body)_";
     const ended = endedDate(narrativeSession.frontmatter.ended);
     const trackLabel = usedFallbackTrack ? ` (${narrativeSession.frontmatter.track})` : "";
@@ -2001,7 +2005,7 @@ Moved ${archivedTaskIds.length} stale done task(s) to tasks/archive/: ${archived
   const notesBody = renderDurableNotes(notes, slug);
   if (notesBody) sections.push(notesBody);
   if (artifactsError) {
-    const artifactsPath = path11.join(initiativeDir, "artifacts.yml");
+    const artifactsPath = path10.join(initiativeDir, "artifacts.yml");
     sections.push(
       `# Open artifacts
 _${artifactsPath} exists but could not be read (${artifactsError}). Branch and stash context is MISSING from this bootstrap \u2014 do not treat the working tree as clean. Run \`active-work doctor\`._`
@@ -2045,54 +2049,11 @@ ${contextLines.join("\n")}`);
   return { prompt, metadata };
 }
 
-// src/bootstrap/archive-tasks.ts
-import { promises as fsp } from "fs";
-import path12 from "path";
-var MS_PER_DAY3 = 864e5;
-async function archiveStaleTasks(initiativeDir, opts) {
-  if (!(opts.retentionDays > 0)) return [];
-  const tasksDir = path12.join(initiativeDir, "tasks");
-  let entries;
-  try {
-    entries = await fsp.readdir(tasksDir);
-  } catch {
-    return [];
-  }
-  const ymlFiles = entries.filter((n) => n.endsWith(".yml") || n.endsWith(".yaml"));
-  const cutoffMs = opts.now.getTime() - opts.retentionDays * MS_PER_DAY3;
-  const archiveDir = path12.join(tasksDir, "archive");
-  const archived = [];
-  for (const filename of ymlFiles) {
-    const fullPath = path12.join(tasksDir, filename);
-    let doneAt;
-    let id;
-    try {
-      const task = await readYaml(fullPath, TaskSchema);
-      if (task.status !== "done" || !task.done_at) continue;
-      doneAt = task.done_at;
-      id = task.id;
-    } catch {
-      continue;
-    }
-    const doneMs = new Date(doneAt).getTime();
-    if (Number.isNaN(doneMs) || doneMs > cutoffMs) continue;
-    try {
-      await fsp.mkdir(archiveDir, { recursive: true });
-      await fsp.rename(fullPath, path12.join(archiveDir, filename));
-      archived.push(id);
-    } catch {
-    }
-  }
-  return archived.sort();
-}
-
 // src/commands/_open-helpers.ts
-import { promises as fs12 } from "fs";
-import path13 from "path";
 async function listInitiativeSlugs(activeRoot) {
   let entries;
   try {
-    entries = await fs12.readdir(activeRoot, { withFileTypes: true });
+    entries = await fs11.readdir(activeRoot, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -2111,15 +2072,23 @@ async function resolveSlug(activeRoot, input) {
   }
   throw new NotFoundError(`No initiative matches '${input}'. Known: ${slugs.join(", ")}`);
 }
+function resolveLaunchCwd(activeRoot, slug) {
+  return path11.join(activeRoot, slug);
+}
+async function resolveCwdHint(activeRoot, slug) {
+  const registered = await readRegisteredWorktrees(path11.join(activeRoot, slug));
+  const preferred = defaultWorktreePath(registered);
+  return preferred === null ? path11.join(activeRoot, slug) : expandTilde(preferred);
+}
 function isInside(child, parent) {
-  const rel = path13.relative(parent, child);
-  return rel === "" || !rel.startsWith("..") && !path13.isAbsolute(rel);
+  const rel = path11.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path11.isAbsolute(rel);
 }
 async function canonicalize(p) {
   try {
-    return await fs12.realpath(p);
+    return await fs11.realpath(p);
   } catch {
-    return path13.resolve(p);
+    return path11.resolve(p);
   }
 }
 async function resolveSlugFromCwd(activeRoot, cwd) {
@@ -2128,16 +2097,16 @@ async function resolveSlugFromCwd(activeRoot, cwd) {
   let best = null;
   let tiedAtBest = false;
   for (const slug of slugs) {
-    const briefPath = path13.join(activeRoot, slug, "brief.md");
+    const briefPath = path11.join(activeRoot, slug, "brief.md");
     try {
       await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
     } catch {
       continue;
     }
-    const registered = await readRegisteredWorktrees(path13.join(activeRoot, slug));
+    const registered = await readRegisteredWorktrees(path11.join(activeRoot, slug));
     for (const entry of registered) {
       const displayPath = expandTilde(entry.path);
-      if (!path13.isAbsolute(displayPath)) continue;
+      if (!path11.isAbsolute(displayPath)) continue;
       const canonical = await canonicalize(displayPath);
       if (!isInside(resolvedCwd, canonical)) continue;
       const depth = canonical.length;
@@ -2153,57 +2122,131 @@ async function resolveSlugFromCwd(activeRoot, cwd) {
   return { slug: best.slug, worktreePath: best.worktreePath };
 }
 
+// src/commands/open.ts
+import path14 from "path";
+import { z as z9 } from "zod";
+
+// src/bootstrap/archive-tasks.ts
+import { promises as fsp } from "fs";
+import path12 from "path";
+var MS_PER_DAY3 = 864e5;
+async function archiveStaleTasks(initiativeDir, opts) {
+  if (!(opts.retentionDays > 0)) return [];
+  const tasksDir = path12.join(initiativeDir, "tasks");
+  let entries;
+  try {
+    entries = await fsp.readdir(tasksDir);
+  } catch {
+    return [];
+  }
+  const ymlFiles = entries.filter((n) => n.endsWith(".yml") || n.endsWith(".yaml"));
+  const cutoffMs = opts.now.getTime() - opts.retentionDays * MS_PER_DAY3;
+  const archiveDir = path12.join(tasksDir, "archive");
+  const archived = [];
+  for (const filename of ymlFiles) {
+    const fullPath = path12.join(tasksDir, filename);
+    let doneAt;
+    let id;
+    try {
+      const task = await readYaml(fullPath, TaskSchema);
+      if (task.status !== "done" || !task.done_at) continue;
+      doneAt = task.done_at;
+      id = task.id;
+    } catch {
+      continue;
+    }
+    const doneMs = new Date(doneAt).getTime();
+    if (Number.isNaN(doneMs) || doneMs > cutoffMs) continue;
+    try {
+      await fsp.mkdir(archiveDir, { recursive: true });
+      await fsp.rename(fullPath, path12.join(archiveDir, filename));
+      archived.push(id);
+    } catch {
+    }
+  }
+  return archived.sort();
+}
+
+// src/utils/global-config.ts
+import { promises as fs12 } from "fs";
+import path13 from "path";
+import { z as z8 } from "zod";
+var GlobalConfigSchema = z8.object({
+  channels: z8.array(channelTarget).optional()
+});
+var FALLBACK_DEFAULT_CHANNELS = ["plugin:agent-chat@agent-chat-local"];
+async function readGlobalConfig(configRoot = getConfigRoot()) {
+  let raw;
+  try {
+    raw = await fs12.readFile(path13.join(configRoot, "config.json"), "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  const result = GlobalConfigSchema.safeParse(parsed);
+  return result.success ? result.data : {};
+}
+async function resolveDefaultChannels(configRoot) {
+  const config = await readGlobalConfig(configRoot);
+  return config.channels && config.channels.length > 0 ? config.channels : FALLBACK_DEFAULT_CHANNELS;
+}
+
 // src/commands/open.ts
 var ARCHIVE_DONE_AFTER_DAYS = 30;
-var ArgsSchema2 = z8.object({
-  slug: z8.string().min(1).optional(),
-  offline: z8.boolean().optional(),
+var ArgsSchema2 = z9.object({
+  slug: z9.string().min(1).optional(),
+  offline: z9.boolean().optional(),
   // Directory used to auto-resolve an initiative when no slug is given.
   // Defaults to the process cwd; callers that do not share the user's shell
   // cwd (the daemon / MCP server) must pass this explicitly.
-  cwd: z8.string().min(1).optional(),
+  cwd: z9.string().min(1).optional(),
   // Force the picker even when the cwd matches an initiative's worktree.
-  pick: z8.boolean().optional(),
+  pick: z9.boolean().optional(),
   // Frame the bootstrap prompt as ad-hoc work related to the workstream rather
   // than a continuation of its handoff / top task.
-  adhoc: z8.boolean().optional(),
+  adhoc: z9.boolean().optional(),
   // Skip the sibling-session probe (and the lease write that goes with it).
-  no_sibling_check: z8.boolean().optional(),
+  no_sibling_check: z9.boolean().optional(),
   // Internal: `aw` calls this command in-process and holds a `launcher` lease
   // of its own for the same session, so it suppresses the oneshot lease here
   // rather than writing a second one that would then look like a sibling.
-  lease_mode: z8.literal("defer").optional()
+  lease_mode: z9.literal("defer").optional()
 });
-var InitiativeSummarySchema = z8.object({
-  slug: z8.string(),
-  title: z8.string(),
-  state: z8.enum(["focused", "backburner", "paused", "done"]),
-  rank: z8.number().int().positive().optional()
+var InitiativeSummarySchema = z9.object({
+  slug: z9.string(),
+  title: z9.string(),
+  state: z9.enum(["focused", "backburner", "paused", "done"]),
+  rank: z9.number().int().positive().optional()
 });
-var PickerResultSchema = z8.object({
-  picker: z8.literal(true),
-  initiatives: z8.array(InitiativeSummarySchema)
+var PickerResultSchema = z9.object({
+  picker: z9.literal(true),
+  initiatives: z9.array(InitiativeSummarySchema)
 });
-var OpenResultSchema = z8.object({
-  slug: z8.string(),
-  prompt: z8.string(),
-  cwd_hint: z8.string(),
-  channels: z8.array(z8.string()).optional(),
-  metadata: z8.object({
-    slug: z8.string(),
-    brief_title: z8.string(),
-    last_session: z8.object({ filename: z8.string(), ended: z8.string() }).optional(),
-    time_since_last_session_human: z8.string().optional(),
-    open_task_count: z8.number().int().nonnegative(),
-    recently_done_count: z8.number().int().nonnegative(),
-    bootstrap_at: z8.string(),
-    sibling_sessions: z8.number().int().nonnegative().optional()
+var OpenResultSchema = z9.object({
+  slug: z9.string(),
+  prompt: z9.string(),
+  cwd_hint: z9.string(),
+  channels: z9.array(z9.string()).optional(),
+  metadata: z9.object({
+    slug: z9.string(),
+    brief_title: z9.string(),
+    last_session: z9.object({ filename: z9.string(), ended: z9.string() }).optional(),
+    time_since_last_session_human: z9.string().optional(),
+    open_task_count: z9.number().int().nonnegative(),
+    recently_done_count: z9.number().int().nonnegative(),
+    bootstrap_at: z9.string(),
+    sibling_sessions: z9.number().int().nonnegative().optional()
   }),
   // How the initiative was selected: an explicit/prefix slug, or a match
   // between the caller's cwd and one of the initiative's worktrees.
-  resolved_from: z8.enum(["slug", "cwd"]).optional()
+  resolved_from: z9.enum(["slug", "cwd"]).optional()
 });
-var ResultSchema2 = z8.union([OpenResultSchema, PickerResultSchema]);
+var ResultSchema2 = z9.union([OpenResultSchema, PickerResultSchema]);
 var STATE_ORDER = {
   focused: 0,
   backburner: 1,
@@ -2244,11 +2287,6 @@ async function collectInitiatives(activeRoot) {
   summaries.sort(compareInitiatives);
   return summaries;
 }
-async function resolveCwdHint(activeRoot, slug) {
-  const registered = await readRegisteredWorktrees(path14.join(activeRoot, slug));
-  const preferred = defaultWorktreePath(registered);
-  return preferred === null ? path14.join(activeRoot, slug) : expandTilde(preferred);
-}
 async function claimOneshotLease(activeRoot, slug, cwd) {
   try {
     await acquireLease({ activeRoot, slug, cwd, mode: "oneshot" });
@@ -2276,11 +2314,12 @@ async function bootstrapInitiative(activeRoot, slug, opts) {
   if (detectSiblings && !opts.deferLease) {
     await claimOneshotLease(activeRoot, slug, cwdHint);
   }
+  const defaultChannels = await resolveDefaultChannels();
   return {
     slug,
     prompt,
     cwd_hint: cwdHint,
-    ...brief.channels && brief.channels.length > 0 ? { channels: brief.channels } : {},
+    channels: mergeChannels(defaultChannels, brief.channels),
     metadata,
     resolved_from: opts.resolvedFrom
   };
@@ -2350,6 +2389,122 @@ var openCommand = defineCommand({
 });
 var open_default = openCommand;
 
+// src/commands/resume.ts
+import { z as z10 } from "zod";
+
+// src/sessions/resolve-session-location.ts
+import { promises as fs13 } from "fs";
+import os2 from "os";
+import path15 from "path";
+import matter2 from "gray-matter";
+async function findInActiveWork(activeRoot, sessionId) {
+  for (const slug of await listInitiativeSlugs(activeRoot)) {
+    const sessionsDir = path15.join(activeRoot, slug, "sessions");
+    let filenames;
+    try {
+      filenames = await fs13.readdir(sessionsDir);
+    } catch {
+      continue;
+    }
+    for (const filename of filenames) {
+      if (!filename.endsWith(".md") || !filename.includes(sessionId)) continue;
+      let raw;
+      try {
+        raw = await fs13.readFile(path15.join(sessionsDir, filename), "utf8");
+      } catch {
+        continue;
+      }
+      const { data } = matter2(raw);
+      if (data.session_id === sessionId) {
+        return { slug, cwd: resolveLaunchCwd(activeRoot, slug) };
+      }
+    }
+  }
+  return null;
+}
+function transcriptsRoot() {
+  return process.env.CLAUDE_PROJECTS_ROOT ?? path15.join(os2.homedir(), ".claude", "projects");
+}
+async function extractCwd(filePath) {
+  const raw = await fs13.readFile(filePath, "utf8");
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (record && typeof record === "object") {
+      const cwd = record.cwd;
+      if (typeof cwd === "string" && cwd.length > 0) return cwd;
+    }
+  }
+  return null;
+}
+async function findInClaudeProjects(sessionId) {
+  const root = transcriptsRoot();
+  let projectDirs;
+  try {
+    projectDirs = await fs13.readdir(root);
+  } catch {
+    return null;
+  }
+  const targetName = `${sessionId}.jsonl`;
+  for (const dir of projectDirs) {
+    const candidate = path15.join(root, dir, targetName);
+    try {
+      await fs13.access(candidate);
+    } catch {
+      continue;
+    }
+    const cwd = await extractCwd(candidate);
+    if (cwd) return cwd;
+  }
+  return null;
+}
+async function resolveSessionLocation(activeRoot, sessionId) {
+  const viaActiveWork = await findInActiveWork(activeRoot, sessionId);
+  if (viaActiveWork) {
+    return { cwd: viaActiveWork.cwd, source: "active-work", slug: viaActiveWork.slug };
+  }
+  const viaProjects = await findInClaudeProjects(sessionId);
+  if (viaProjects) {
+    return { cwd: viaProjects, source: "claude-projects" };
+  }
+  return null;
+}
+
+// src/commands/resume.ts
+var ArgsSchema3 = z10.object({
+  session_id: z10.string().min(1)
+});
+var ResultSchema3 = z10.object({
+  session_id: z10.string(),
+  cwd: z10.string(),
+  source: z10.enum(["active-work", "claude-projects"]),
+  slug: z10.string().optional()
+});
+var resume_default = defineCommand({
+  name: "resume",
+  description: "Resolve the working directory a Claude session id belongs to, so `claude --resume` can be run from the right place.",
+  args: ArgsSchema3,
+  result: ResultSchema3,
+  cli: {
+    positional: ["session_id"],
+    usage: "active-work resume <session_id>"
+  },
+  async run(args, ctx) {
+    const resolved = await resolveSessionLocation(ctx.activeRoot, args.session_id);
+    if (!resolved) {
+      throw new NotFoundError(
+        `No session found for '${args.session_id}' in active-work sessions or ~/.claude/projects.`
+      );
+    }
+    return { session_id: args.session_id, ...resolved };
+  }
+});
+
 // src/utils/color.ts
 import pc from "picocolors";
 var enabled = !("NO_COLOR" in process.env) && process.stdout.isTTY === true;
@@ -2374,26 +2529,17 @@ export {
   getConfigRoot,
   getInitiativeDir,
   getLockPath,
-  BranchEntrySchema,
-  StashEntrySchema,
-  WorktreeEntrySchema,
-  ArtifactsSchema,
-  atomicWrite,
-  withFileLock,
-  hashContent,
-  readArtifactHashes,
-  readYaml,
-  writeYaml,
-  readArtifactsFile,
-  registeredOf,
-  readRegisteredWorktrees,
-  writeArtifactsFile,
+  getMinerRoot,
   defineCommand,
-  successEnvelope,
-  errorEnvelope,
   registry,
   register,
+  successEnvelope,
+  errorEnvelope,
   TaskSchema,
+  BranchEntrySchema,
+  StashEntrySchema,
+  WorktreeEntrySchema,
+  ArtifactsSchema,
   SessionIdSchema,
   NextStepSchema,
   SessionResolveSchema,
@@ -2406,6 +2552,10 @@ export {
   findSessionIssues,
   NoteKindSchema,
   NOTE_TITLE_MAX_LENGTH,
+  atomicWrite,
+  withFileLock,
+  hashContent,
+  readArtifactHashes,
   readFrontmatter,
   readRawFrontmatter,
   writeFrontmatter,
@@ -2422,25 +2572,34 @@ export {
   source_add_default,
   loadNotesFromDir,
   writeNoteFile,
-  writePidFile,
   readPidFile,
   removePidFile,
-  DEFAULT_DAEMON_PORT,
   resolveDaemonPort,
   probeHealth,
+  DEFAULT_DAEMON_PORT,
   isProcessAlive,
   acquireLease,
   releaseLease,
   releaseLeaseSync,
   sweepAllLeases,
+  readYaml,
+  writeYaml,
   getGitRunner,
   getGhRunner,
   resolveLocalRepoPath,
   resolveOrgRepo,
   assembleBootstrap,
+  buildClaudeArgs,
+  parseLauncherFlags,
+  readArtifactsFile,
+  registeredOf,
+  readRegisteredWorktrees,
+  writeArtifactsFile,
   resolveSlug,
+  resolveLaunchCwd,
   resolveSlugFromCwd,
   open_default,
+  resume_default,
   color
 };
-//# sourceMappingURL=chunk-FM2KVFDO.js.map
+//# sourceMappingURL=chunk-HSGZOWS3.js.map