@titan-design/active-work 0.1.0 → 0.2.0

package/dist/chunk-FM2KVFDO.js

@@ -0,0 +1,2446 @@
+// src/utils/paths.ts
+import os from "os";
+import path from "path";
+import envPaths from "env-paths";
+var PROJECT_NAME = "active-work";
+function paths() {
+  return envPaths(PROJECT_NAME, { suffix: "" });
+}
+function expandTilde(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+function getActiveRoot() {
+  const override = process.env.ACTIVE_ROOT;
+  if (override && override.length > 0) {
+    return path.resolve(expandTilde(override));
+  }
+  return paths().data;
+}
+function getStateRoot() {
+  return paths().log;
+}
+function getConfigRoot() {
+  return paths().config;
+}
+function getInitiativeDir(slug) {
+  return path.join(getActiveRoot(), 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 };
+}
+
+// src/registry/types.ts
+function defineCommand(cmd) {
+  return cmd;
+}
+
+// src/registry/index.ts
+var registry = /* @__PURE__ */ new Map();
+function register(cmd) {
+  if (registry.has(cmd.name)) {
+    throw new Error(`Command already registered: ${cmd.name}`);
+  }
+  registry.set(cmd.name, cmd);
+}
+
+// src/errors.ts
+var EXIT = {
+  OK: 0,
+  GENERIC: 1,
+  USAGE: 64,
+  // EX_USAGE
+  DATAERR: 65,
+  // EX_DATAERR — invalid input data / validation
+  NOINPUT: 66,
+  // EX_NOINPUT — file/initiative not found
+  UNAVAILABLE: 69,
+  // EX_UNAVAILABLE — daemon unreachable
+  SOFTWARE: 70,
+  // EX_SOFTWARE — internal bug
+  CONFIG: 78
+  // EX_CONFIG — bad config
+};
+var ActiveWorkError = class extends Error {
+  code = EXIT.GENERIC;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ActiveWorkError";
+  }
+};
+var ValidationError = class extends ActiveWorkError {
+  code = EXIT.DATAERR;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends ActiveWorkError {
+  code = EXIT.NOINPUT;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "NotFoundError";
+  }
+};
+var UsageError = class extends ActiveWorkError {
+  code = EXIT.USAGE;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UsageError";
+  }
+};
+var DaemonError = class extends ActiveWorkError {
+  code = EXIT.UNAVAILABLE;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DaemonError";
+  }
+};
+var ConfigError = class extends ActiveWorkError {
+  code = EXIT.CONFIG;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ConfigError";
+  }
+};
+function formatError(err) {
+  if (err instanceof ActiveWorkError) {
+    return { message: err.message, code: err.code };
+  }
+  if (err instanceof Error) {
+    return { message: err.message, code: EXIT.GENERIC };
+  }
+  return { message: String(err), code: EXIT.GENERIC };
+}
+
+// src/commands/open.ts
+import path14 from "path";
+import { z as z8 } from "zod";
+
+// src/schemas/brief.ts
+import { z } from "zod";
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var isValidIsoDate = (value) => {
+  if (!ISO_DATE_REGEX.test(value)) return false;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return false;
+  return parsed.toISOString().slice(0, 10) === value;
+};
+var isoDate = z.string().refine(isValidIsoDate, { message: "Must be a valid zero-padded YYYY-MM-DD date" });
+var positiveInt = z.number().int().positive();
+var TaskSeqSchema = positiveInt;
+var channelTarget = z.string().min(1).regex(/^(?:(?:server|plugin):.+|[A-Za-z0-9_-]+)$/, {
+  message: 'channel must be a target like "server:voltras", "plugin:name@marketplace", or a bare server name'
+});
+var BriefFrontmatterSchema = z.object({
+  schema_version: positiveInt,
+  title: z.string().min(1),
+  updated: isoDate,
+  state: z.enum(["focused", "backburner", "paused", "done"]),
+  rank: positiveInt.optional(),
+  paused_since: isoDate.optional(),
+  restart_trigger: z.string().min(1).optional(),
+  ship_target: z.string().optional(),
+  owner: z.string().optional(),
+  task_prefix: z.string().min(1).regex(/^[A-Z][A-Z0-9]*$/, {
+    message: "task_prefix must be uppercase letters/digits starting with a letter"
+  }),
+  channels: z.array(channelTarget).optional(),
+  // 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.
+  task_seq: TaskSeqSchema.optional()
+}).superRefine((value, ctx) => {
+  if (value.state === "focused" && value.rank === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["rank"],
+      message: 'rank is required when state is "focused"'
+    });
+  }
+  if (value.state === "paused") {
+    if (value.paused_since === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["paused_since"],
+        message: 'paused_since is required when state is "paused"'
+      });
+    }
+    if (value.restart_trigger === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["restart_trigger"],
+        message: 'restart_trigger is required when state is "paused"'
+      });
+    }
+  }
+});
+
+// src/utils/registered-worktrees.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+
+// src/schemas/artifacts.ts
+import { z as z2 } from "zod";
+var BranchEntrySchema = z2.object({
+  repo: z2.string().min(1),
+  name: z2.string().min(1),
+  note: z2.string().optional()
+});
+var StashEntrySchema = z2.object({
+  repo: z2.string().min(1),
+  label: z2.string().min(1),
+  sha: z2.string().optional()
+});
+var WorktreeEntrySchema = z2.object({
+  path: z2.string().min(1),
+  repo: z2.string().min(1),
+  branch: z2.string().min(1).optional(),
+  holding: z2.string().min(1).optional(),
+  pr: z2.number().int().positive().optional(),
+  note: z2.string().optional(),
+  /** Operator's label. Present only on registered worktrees. */
+  name: z2.string().min(1).optional(),
+  /** The worktree `aw <slug>` starts in. Only meaningful alongside `name`. */
+  default: z2.boolean().optional()
+});
+var ArtifactsSchema = z2.object({
+  branches: z2.array(BranchEntrySchema).default([]),
+  stashes: z2.array(StashEntrySchema).default([]),
+  worktrees: z2.array(WorktreeEntrySchema).default([])
+}).superRefine((value, ctx) => {
+  const names = /* @__PURE__ */ new Set();
+  let defaults = 0;
+  value.worktrees.forEach((entry, i) => {
+    if (entry.name !== void 0) {
+      if (names.has(entry.name)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["worktrees", i, "name"],
+          message: `duplicate worktree name: ${entry.name}`
+        });
+      }
+      names.add(entry.name);
+    }
+    if (entry.default === true) {
+      defaults += 1;
+      if (entry.name === void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["worktrees", i, "default"],
+          message: "default requires a named worktree"
+        });
+      }
+    }
+  });
+  if (defaults > 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["worktrees"],
+      message: "at most one worktree may be default"
+    });
+  }
+});
+
+// src/utils/yaml-io.ts
+import { promises as fs3 } from "fs";
+import YAML2 from "yaml";
+
+// src/utils/artifact-hash.ts
+import { createHash } from "crypto";
+import { promises as fs2 } from "fs";
+import path3 from "path";
+import YAML from "yaml";
+
+// src/utils/fs-atomic.ts
+import { randomBytes } from "crypto";
+import { promises as fs } from "fs";
+import path2 from "path";
+import lockfile from "proper-lockfile";
+async function atomicWrite(targetPath, content) {
+  const dir = path2.dirname(targetPath);
+  const base = path2.basename(targetPath);
+  const suffix = `${process.pid}.${randomBytes(6).toString("hex")}`;
+  const tempPath = path2.join(dir, `${base}.tmp.${suffix}`);
+  let handle;
+  try {
+    handle = await fs.open(tempPath, "wx");
+    await handle.writeFile(content);
+    await handle.sync();
+  } finally {
+    if (handle) await handle.close();
+  }
+  try {
+    await fs.rename(tempPath, targetPath);
+  } catch (err) {
+    await fs.rm(tempPath, { force: true });
+    throw err;
+  }
+}
+async function withFileLock(lockTarget, fn) {
+  await fs.mkdir(path2.dirname(lockTarget), { recursive: true });
+  const release = await lockfile.lock(lockTarget, {
+    realpath: false,
+    retries: { retries: 5, factor: 1.5, minTimeout: 50 }
+  });
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
+// src/utils/artifact-hash.ts
+var MANIFEST_FILENAME = ".artifact-hashes.yml";
+function classifyStructuredArtifact(filePath) {
+  const base = path3.basename(filePath);
+  const dir = path3.dirname(filePath);
+  if (base === "artifacts.yml" || base === "brief.md") {
+    return { initiativeDir: dir, relPath: base };
+  }
+  if (base.endsWith(".yml") && path3.basename(dir) === "tasks") {
+    return { initiativeDir: path3.dirname(dir), relPath: path3.posix.join("tasks", base) };
+  }
+  return null;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+async function readManifest(initiativeDir) {
+  const manifestPath = path3.join(initiativeDir, MANIFEST_FILENAME);
+  let raw;
+  try {
+    raw = await fs2.readFile(manifestPath, "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = YAML.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object") return {};
+  return parsed;
+}
+async function readArtifactHashes(initiativeDir) {
+  return readManifest(initiativeDir);
+}
+async function recordArtifactHash(initiativeDir, relPath, content) {
+  const manifest = await readManifest(initiativeDir);
+  manifest[relPath] = hashContent(content);
+  const manifestPath = path3.join(initiativeDir, MANIFEST_FILENAME);
+  await atomicWrite(manifestPath, YAML.stringify(manifest));
+}
+
+// src/utils/coerce-dates.ts
+function dateToString(d) {
+  if (d.getUTCHours() === 0 && d.getUTCMinutes() === 0 && d.getUTCSeconds() === 0 && d.getUTCMilliseconds() === 0) {
+    return d.toISOString().slice(0, 10);
+  }
+  return d.toISOString();
+}
+function coerceDates(value) {
+  if (value instanceof Date) {
+    return dateToString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(coerceDates);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = coerceDates(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/utils/yaml-io.ts
+async function readYaml(filePath, schema) {
+  const raw = await fs3.readFile(filePath, "utf8");
+  let parsed;
+  try {
+    parsed = YAML2.parse(raw);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse YAML at ${filePath}: ${reason}`);
+  }
+  const coerced = coerceDates(parsed);
+  const result = schema.safeParse(coerced);
+  if (!result.success) {
+    throw new Error(`Schema validation failed for ${filePath}: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function writeYaml(filePath, data, schema) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new Error(`Schema validation failed for ${filePath}: ${result.error.message}`);
+  }
+  const yaml = YAML2.stringify(result.data);
+  await atomicWrite(filePath, yaml);
+  const artifact = classifyStructuredArtifact(filePath);
+  if (artifact) await recordArtifactHash(artifact.initiativeDir, artifact.relPath, yaml);
+}
+
+// src/utils/registered-worktrees.ts
+function artifactsPathFor(initiativeDir) {
+  return path4.join(initiativeDir, "artifacts.yml");
+}
+var EMPTY = { branches: [], stashes: [], worktrees: [] };
+async function readArtifactsFile(initiativeDir) {
+  const file = artifactsPathFor(initiativeDir);
+  try {
+    await fs4.access(file);
+  } catch {
+    return { ...EMPTY, branches: [], stashes: [], worktrees: [] };
+  }
+  return readYaml(file, ArtifactsSchema);
+}
+function registeredOf(artifacts) {
+  return artifacts.worktrees.filter(
+    (entry) => entry.name !== void 0
+  );
+}
+async function readRegisteredWorktrees(initiativeDir) {
+  try {
+    return registeredOf(await readArtifactsFile(initiativeDir));
+  } catch {
+    return [];
+  }
+}
+function defaultWorktreePath(registered) {
+  const explicit = registered.find((entry) => entry.default === true);
+  if (explicit) return explicit.path;
+  return registered.length === 1 ? registered[0].path : null;
+}
+async function writeArtifactsFile(initiativeDir, artifacts) {
+  await writeYaml(artifactsPathFor(initiativeDir), artifacts, ArtifactsSchema);
+}
+
+// src/bootstrap/prompt.ts
+import { promises as fs11 } from "fs";
+import path11 from "path";
+
+// src/schemas/task.ts
+import { z as z3 } from "zod";
+var ISO_DATE_REGEX2 = /^\d{4}-\d{2}-\d{2}$/;
+var isValidIsoDate2 = (value) => {
+  if (!ISO_DATE_REGEX2.test(value)) return false;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return false;
+  return parsed.toISOString().slice(0, 10) === value;
+};
+var isoDate2 = z3.string().refine(isValidIsoDate2, { message: "Must be a valid zero-padded YYYY-MM-DD date" });
+var isoDateOrNull = z3.union([isoDate2, z3.null()]);
+var TaskSchema = z3.object({
+  id: z3.string().regex(/^[A-Z][A-Z0-9]*-\d+$/, {
+    message: "id must match /^[A-Z][A-Z0-9]*-\\d+$/ (e.g. EC-1)"
+  }),
+  title: z3.string().min(1),
+  priority: z3.number().int().positive(),
+  severity: z3.enum(["critical", "high", "medium", "low"]).optional(),
+  estimate: z3.number().positive().optional(),
+  done_when: z3.string().min(1).optional(),
+  status: z3.enum(["open", "done"]),
+  tags: z3.array(z3.string()).optional(),
+  notes: z3.string().optional(),
+  created: isoDate2,
+  updated: isoDate2,
+  done_at: isoDateOrNull
+});
+
+// src/sessions/open-loops.ts
+import { promises as fs5 } from "fs";
+import path5 from "path";
+import YAML3 from "yaml";
+
+// src/schemas/session.ts
+import { z as z4 } from "zod";
+var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+var isValidIso8601 = (value) => {
+  if (!ISO_8601_REGEX.test(value)) return false;
+  const parsed = new Date(value);
+  return !Number.isNaN(parsed.getTime());
+};
+var iso8601 = z4.string().refine(isValidIso8601, { message: "Must be a valid ISO 8601 datetime with timezone" });
+var REF_SEGMENT_REGEX = /^[^#\s/]+$/;
+var REF_SEGMENT_MESSAGE = 'must not contain whitespace, "#" or "/"';
+var SessionIdSchema = z4.string().min(1).regex(REF_SEGMENT_REGEX, { message: `session_id ${REF_SEGMENT_MESSAGE}` });
+var NextStepSchema = z4.object({
+  id: z4.string().min(1).regex(REF_SEGMENT_REGEX, { message: `next_steps id ${REF_SEGMENT_MESSAGE}` }),
+  text: z4.string().min(1),
+  kind: z4.enum(["task", "pr", "prose"]),
+  ref: z4.string().min(1).optional()
+});
+var SessionResolveSchema = z4.object({
+  ref: z4.string().regex(/^[^#\s]+#[^#\s]+$/, {
+    message: "ref must be '<session file stem>#<next_step id>'"
+  }),
+  outcome: z4.enum(["done", "abandoned"]),
+  note: z4.string().min(1).optional()
+});
+function checkUniqueStepIds(steps, ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  steps.forEach((step, index) => {
+    if (seen.has(step.id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["next_steps", index, "id"],
+        message: `next_steps ids must be unique within a session: ${step.id}`
+      });
+    }
+    seen.add(step.id);
+  });
+}
+function checkAbandonedHasNote(entries, ctx) {
+  entries.forEach((entry, index) => {
+    if (entry.outcome === "abandoned" && entry.note === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["resolves", index, "note"],
+        message: 'note is required when outcome is "abandoned"'
+      });
+    }
+  });
+}
+var SessionFrontmatterSchema = z4.object({
+  session_id: SessionIdSchema,
+  started: iso8601,
+  ended: iso8601,
+  track: z4.enum(["canonical", "sidecar", "adhoc"]),
+  next_steps: z4.array(NextStepSchema).default([]),
+  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()
+}).superRefine((value, ctx) => {
+  const started = new Date(value.started).getTime();
+  const ended = new Date(value.ended).getTime();
+  if (Number.isFinite(started) && Number.isFinite(ended) && ended < started) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["ended"],
+      message: "ended must be greater than or equal to started"
+    });
+  }
+  checkUniqueStepIds(value.next_steps, ctx);
+  checkAbandonedHasNote(value.resolves, ctx);
+  if (value.no_loops === true && (value.next_steps.length > 0 || value.resolves.length > 0)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["no_loops"],
+      message: "no_loops cannot be set alongside next_steps or resolves"
+    });
+  }
+});
+
+// src/sessions/open-loops.ts
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var FRONTMATTER_DELIM = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function describe(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function loadSession(fullPath, sessionFile) {
+  const fail = (reason) => ({
+    ok: false,
+    problem: { file: `${sessionFile}.md`, reason }
+  });
+  let raw;
+  try {
+    raw = await fs5.readFile(fullPath, "utf8");
+  } catch (err) {
+    return fail(`unreadable: ${describe(err)}`);
+  }
+  const match = FRONTMATTER_DELIM.exec(raw);
+  if (!match) return fail("no frontmatter block");
+  let parsed;
+  try {
+    parsed = YAML3.parse(match[1] ?? "");
+  } catch (err) {
+    return fail(`invalid YAML: ${describe(err)}`);
+  }
+  const result = SessionFrontmatterSchema.safeParse(parsed);
+  if (!result.success) return fail(`invalid frontmatter: ${summarizeIssues(result.error)}`);
+  return { ok: true, session: toLoadedSession(sessionFile, result.data, match[2] ?? "") };
+}
+function summarizeIssues(error) {
+  return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join(", ");
+}
+function toLoadedSession(sessionFile, frontmatter, body) {
+  return {
+    sessionFile,
+    sessionId: frontmatter.session_id,
+    ended: frontmatter.ended,
+    endedMs: new Date(frontmatter.ended).getTime(),
+    frontmatter,
+    body
+  };
+}
+async function loadSessionsFromDir(initiativeDir) {
+  const sessionsDir = path5.join(initiativeDir, "sessions");
+  let entries;
+  try {
+    entries = await fs5.readdir(sessionsDir);
+  } catch {
+    return { sessions: [], malformed: [] };
+  }
+  const sessions = [];
+  const malformed = [];
+  for (const filename of entries.filter((n) => n.endsWith(".md")).sort()) {
+    const result = await loadSession(
+      path5.join(sessionsDir, filename),
+      filename.slice(0, -".md".length)
+    );
+    if (result.ok) sessions.push(result.session);
+    else malformed.push(result.problem);
+  }
+  return { sessions, malformed };
+}
+function indexLoops(sessions) {
+  const loops = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    for (const step of session.frontmatter.next_steps) {
+      loops.set(`${session.sessionFile}#${step.id}`, {
+        ref: `${session.sessionFile}#${step.id}`,
+        step,
+        session
+      });
+    }
+  }
+  return loops;
+}
+function refStem(ref) {
+  const hash = ref.indexOf("#");
+  return hash < 0 ? ref : ref.slice(0, hash);
+}
+function classifyResolve(ref, session, loops) {
+  if (refStem(ref) === session.sessionFile) return "self";
+  const target = loops.get(ref);
+  if (!target) return "missing";
+  if (target.session.sessionId === session.sessionId) return "self";
+  if (target.session.endedMs >= session.endedMs) return "not-prior";
+  return null;
+}
+function applyResolves(sessions, loops) {
+  const resolutions = /* @__PURE__ */ new Map();
+  const dangling = [];
+  for (const session of sessions) {
+    for (const entry of session.frontmatter.resolves) {
+      const kind = classifyResolve(entry.ref, session, loops);
+      if (kind !== null) {
+        dangling.push({ sessionFile: session.sessionFile, ref: entry.ref, kind });
+        continue;
+      }
+      const existing = resolutions.get(entry.ref);
+      if (existing && existing.closedAtMs > session.endedMs) continue;
+      resolutions.set(entry.ref, {
+        outcome: entry.outcome,
+        ...entry.note !== void 0 ? { note: entry.note } : {},
+        closedBy: session.sessionFile,
+        closedAt: session.frontmatter.ended,
+        closedAtMs: session.endedMs
+      });
+    }
+  }
+  return { resolutions, dangling };
+}
+function analyzeLoaded({ sessions, malformed }) {
+  const loops = indexLoops(sessions);
+  const { resolutions, dangling } = applyResolves(sessions, loops);
+  return { loops: [...loops.values()], resolutions, dangling, malformed };
+}
+async function analyze(initiativeDir) {
+  return analyzeLoaded(await loadSessionsFromDir(initiativeDir));
+}
+function normalizePrRef(ref) {
+  const trimmed = ref.trim();
+  const fromUrl = /\/pull\/(\d+)/.exec(trimmed);
+  return fromUrl?.[1] ?? trimmed.replace(/^#/, "");
+}
+function isAutoResolved(entry, opts) {
+  const target = entry.step.ref;
+  if (target === void 0) return false;
+  if (entry.step.kind === "task" && opts.tasks) {
+    return opts.tasks.some((t) => t.id === target && t.status === "done");
+  }
+  if (entry.step.kind === "pr" && opts.mergedPrs) {
+    const wanted = normalizePrRef(target);
+    return opts.mergedPrs.some((ref) => normalizePrRef(ref) === wanted);
+  }
+  return false;
+}
+function toOpenLoop(entry, now) {
+  const ageMs = now.getTime() - entry.session.endedMs;
+  return {
+    ref: entry.ref,
+    text: entry.step.text,
+    ...entry.step.ref !== void 0 ? { targetRef: entry.step.ref } : {},
+    kind: entry.step.kind,
+    sessionFile: entry.session.sessionFile,
+    sessionId: entry.session.sessionId,
+    openedAt: entry.session.ended,
+    ageDays: Math.max(0, Math.floor(ageMs / MS_PER_DAY))
+  };
+}
+function deriveOpenLoopsFrom(loaded, opts) {
+  const { loops, resolutions } = analyzeLoaded(loaded);
+  return loops.filter((entry) => !resolutions.has(entry.ref) && !isAutoResolved(entry, opts)).map((entry) => toOpenLoop(entry, opts.now)).sort(
+    (a, b) => new Date(a.openedAt).getTime() - new Date(b.openedAt).getTime() || a.ref.localeCompare(b.ref)
+  );
+}
+async function deriveOpenLoops(initiativeDir, opts) {
+  return deriveOpenLoopsFrom(await loadSessionsFromDir(initiativeDir), opts);
+}
+function toResolvedLoop(entry, resolution, now) {
+  const ageMs = now.getTime() - new Date(resolution.closedAt).getTime();
+  return {
+    ref: entry.ref,
+    text: entry.step.text,
+    kind: entry.step.kind,
+    outcome: resolution.outcome,
+    ...resolution.note !== void 0 ? { note: resolution.note } : {},
+    sessionFile: entry.session.sessionFile,
+    closedBy: resolution.closedBy,
+    openedAt: entry.session.ended,
+    closedAt: resolution.closedAt,
+    ageDays: Math.max(0, Math.floor(ageMs / MS_PER_DAY))
+  };
+}
+function deriveResolvedLoopsFrom(loaded, opts) {
+  const { loops, resolutions } = analyzeLoaded(loaded);
+  return loops.flatMap((entry) => {
+    const resolution = resolutions.get(entry.ref);
+    return resolution ? [toResolvedLoop(entry, resolution, opts.now)] : [];
+  }).sort(
+    (a, b) => new Date(b.closedAt).getTime() - new Date(a.closedAt).getTime() || a.ref.localeCompare(b.ref)
+  );
+}
+async function findDanglingResolves(initiativeDir) {
+  const { dangling } = await analyze(initiativeDir);
+  return dangling;
+}
+async function findSessionIssues(initiativeDir) {
+  const { dangling, malformed } = await analyze(initiativeDir);
+  return { dangling, malformed };
+}
+
+// src/notes/note-file.ts
+import { promises as fs8 } from "fs";
+import path7 from "path";
+
+// src/schemas/note.ts
+import { z as z5 } from "zod";
+var ISO_DATE_REGEX3 = /^\d{4}-\d{2}-\d{2}$/;
+var isValidIsoDate3 = (value) => {
+  if (!ISO_DATE_REGEX3.test(value)) return false;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return false;
+  return parsed.toISOString().slice(0, 10) === value;
+};
+var isoDate3 = z5.string().refine(isValidIsoDate3, { message: "Must be a valid zero-padded YYYY-MM-DD date" });
+var NoteKindSchema = z5.enum(["process", "gotcha", "fyi", "decision"]);
+var NOTE_TITLE_MAX_LENGTH = 120;
+var NoteFrontmatterSchema = z5.object({
+  kind: NoteKindSchema,
+  title: z5.string().min(1),
+  created: isoDate3,
+  tags: z5.array(z5.string().min(1)).optional()
+});
+
+// src/utils/gray-matter-io.ts
+import { promises as fs6 } from "fs";
+import matter from "gray-matter";
+async function readFrontmatter(filePath, schema) {
+  const raw = await fs6.readFile(filePath, "utf8");
+  const parsed = matter(raw);
+  const coerced = coerceDates(parsed.data);
+  const result = schema.safeParse(coerced);
+  if (!result.success) {
+    throw new Error(`Frontmatter validation failed for ${filePath}: ${result.error.message}`);
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
+async function readRawFrontmatter(filePath) {
+  const raw = await fs6.readFile(filePath, "utf8");
+  const parsed = matter(raw);
+  const coerced = coerceDates(parsed.data);
+  return {
+    frontmatter: { ...coerced },
+    body: parsed.content
+  };
+}
+async function writeFrontmatter(filePath, frontmatter, body, schema) {
+  const result = schema.safeParse(frontmatter);
+  if (!result.success) {
+    throw new Error(`Frontmatter validation failed for ${filePath}: ${result.error.message}`);
+  }
+  const stringified = matter.stringify(body, result.data);
+  await atomicWrite(filePath, stringified);
+  const artifact = classifyStructuredArtifact(filePath);
+  if (artifact) await recordArtifactHash(artifact.initiativeDir, artifact.relPath, stringified);
+}
+
+// src/commands/source-add.ts
+import { promises as fs7 } from "fs";
+import path6 from "path";
+import { z as z6 } from "zod";
+
+// src/utils/today.ts
+function today() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/commands/source-add.ts
+var ArgsSchema = z6.object({
+  slug: z6.string().min(1),
+  file: z6.string().min(1),
+  type: z6.enum(["pr", "deepdive", "session", "pointer"]),
+  label: z6.string().optional(),
+  topic: z6.string().optional(),
+  pr_number: z6.number().int().positive().optional(),
+  date: z6.string().optional(),
+  force: z6.boolean().optional()
+});
+var ResultSchema = z6.object({
+  moved_to: z6.string(),
+  noop: z6.boolean().optional()
+});
+function slugifyLabel(input) {
+  const cleaned = input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return cleaned.length > 0 ? cleaned : "untitled";
+}
+function deriveFilename(args) {
+  switch (args.type) {
+    case "pr": {
+      if (args.pr_number === void 0) {
+        throw new ValidationError("source.add type=pr requires --pr-number");
+      }
+      if (!args.label) {
+        throw new ValidationError("source.add type=pr requires --label");
+      }
+      return `pr-${args.pr_number}-${slugifyLabel(args.label)}.md`;
+    }
+    case "deepdive": {
+      if (!args.topic) {
+        throw new ValidationError("source.add type=deepdive requires --topic");
+      }
+      return `deepdive-${slugifyLabel(args.topic)}.md`;
+    }
+    case "session": {
+      if (!args.label) {
+        throw new ValidationError("source.add type=session requires --label");
+      }
+      const date = args.date ?? today();
+      return `${date}-${slugifyLabel(args.label)}.md`;
+    }
+    case "pointer": {
+      if (!args.label) {
+        throw new ValidationError("source.add type=pointer requires --label");
+      }
+      return `${slugifyLabel(args.label)}.md`;
+    }
+  }
+}
+async function pathExists(p) {
+  try {
+    await fs7.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function movePath(src, dest) {
+  try {
+    await fs7.rename(src, dest);
+  } catch (err) {
+    const code = err.code;
+    if (code === "EXDEV") {
+      await fs7.copyFile(src, dest);
+      await fs7.unlink(src);
+      return;
+    }
+    throw err;
+  }
+}
+var source_add_default = defineCommand({
+  name: "source.add",
+  description: "Move a source file into <slug>/sources/ with a conventional filename.",
+  args: ArgsSchema,
+  result: ResultSchema,
+  cli: {
+    positional: ["slug", "file"],
+    options: {
+      type: {
+        long: "--type",
+        description: "Source type: pr | deepdive | session | pointer",
+        required: true
+      },
+      label: { long: "--label", description: "Short label (slugified into filename)" },
+      topic: { long: "--topic", description: "Topic for deepdive type" },
+      pr_number: { long: "--pr-number", description: "PR number for type=pr" },
+      date: { long: "--date", description: "Date YYYY-MM-DD for type=session" },
+      force: { long: "--force", description: "Overwrite if target exists" }
+    }
+  },
+  async run(args) {
+    const sourcePath = path6.resolve(args.file);
+    if (!await pathExists(sourcePath)) {
+      throw new NotFoundError(`source file not found: ${sourcePath}`);
+    }
+    const filename = deriveFilename(args);
+    const sourcesDir = path6.join(getInitiativeDir(args.slug), "sources");
+    const targetPath = path6.join(sourcesDir, filename);
+    if (path6.resolve(sourcePath) === path6.resolve(targetPath)) {
+      return { moved_to: targetPath, noop: true };
+    }
+    await fs7.mkdir(sourcesDir, { recursive: true });
+    if (await pathExists(targetPath) && !args.force) {
+      throw new ValidationError(`target already exists: ${targetPath} (use --force to overwrite)`);
+    }
+    await movePath(sourcePath, targetPath);
+    return { moved_to: targetPath };
+  }
+});
+
+// src/notes/note-file.ts
+function getNotesDir(initiativeDir) {
+  return path7.join(initiativeDir, "sources", "notes");
+}
+function compareNewestFirst(a, b) {
+  return b.filename.localeCompare(a.filename);
+}
+async function loadNotesFromDir(initiativeDir) {
+  const dir = getNotesDir(initiativeDir);
+  let entries;
+  try {
+    entries = await fs8.readdir(dir);
+  } catch {
+    return { notes: [], malformed: [] };
+  }
+  const notes = [];
+  const malformed = [];
+  for (const filename of entries.filter((n) => n.endsWith(".md")).sort()) {
+    const fullPath = path7.join(dir, filename);
+    try {
+      const { frontmatter, body } = await readFrontmatter(fullPath, NoteFrontmatterSchema);
+      notes.push({ filename, path: fullPath, frontmatter, body });
+    } catch (err) {
+      malformed.push({
+        file: filename,
+        reason: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { notes: notes.sort(compareNewestFirst), malformed };
+}
+async function exists(p) {
+  try {
+    await fs8.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pickAvailableFilename(dir, baseName) {
+  if (!await exists(path7.join(dir, `${baseName}.md`))) return `${baseName}.md`;
+  for (let i = 1; i < 1e4; i++) {
+    const candidate = `${baseName}-${i}.md`;
+    if (!await exists(path7.join(dir, candidate))) return candidate;
+  }
+  throw new Error(`Could not find an available filename for ${baseName}`);
+}
+async function writeNoteFile(initiativeDir, frontmatter, body) {
+  const dir = getNotesDir(initiativeDir);
+  await fs8.mkdir(dir, { recursive: true });
+  const baseName = `${frontmatter.created}-${slugifyLabel(frontmatter.title)}`;
+  const filename = await pickAvailableFilename(dir, baseName);
+  const fullPath = path7.join(dir, filename);
+  await writeFrontmatter(fullPath, frontmatter, body, NoteFrontmatterSchema);
+  return { path: fullPath, filename };
+}
+
+// src/sessions/lease.ts
+import { promises as fs10, unlinkSync } from "fs";
+import { randomBytes as randomBytes2 } from "crypto";
+import path9 from "path";
+
+// src/schemas/lease.ts
+import { z as z7 } from "zod";
+var ISO_8601_REGEX2 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+var isValidIso86012 = (value) => {
+  if (!ISO_8601_REGEX2.test(value)) return false;
+  const parsed = new Date(value);
+  return !Number.isNaN(parsed.getTime());
+};
+var iso86012 = z7.string().refine(isValidIso86012, { message: "Must be a valid ISO 8601 datetime with timezone" });
+var LeaseModeSchema = z7.enum(["launcher", "oneshot"]);
+var LeaseSchema = z7.object({
+  /** Random hex; also the filename stem (`<lease_id>.json`). */
+  lease_id: z7.string().min(1),
+  slug: z7.string().min(1),
+  /** The launch cwd, so a sibling can be told apart from a second checkout. */
+  cwd: z7.string().min(1),
+  mode: LeaseModeSchema,
+  /** Present only for `launcher` leases — the `aw` process to probe. */
+  pid: z7.number().int().positive().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");
+}
+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 };
+}
+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;
+}
+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;
+}
+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;
+  }
+}
+
+// src/sessions/lease.ts
+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);
+}
+function leasePath(activeRoot, slug, leaseId) {
+  return path9.join(leaseDir(activeRoot, slug), `${leaseId}.json`);
+}
+async function acquireLease(input) {
+  const { activeRoot, slug, cwd, mode, pid, label, now = /* @__PURE__ */ new Date() } = input;
+  const leaseId = randomBytes2(8).toString("hex");
+  const lease = LeaseSchema.parse({
+    lease_id: leaseId,
+    slug,
+    cwd,
+    mode,
+    ...mode === "launcher" && pid !== void 0 ? { pid } : {},
+    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");
+  return {
+    leaseId,
+    release: () => releaseLease(activeRoot, slug, leaseId)
+  };
+}
+function isIgnorableUnlinkError(err) {
+  const code = err?.code;
+  return code === "ENOENT";
+}
+async function releaseLease(activeRoot, slug, leaseId) {
+  try {
+    await fs10.unlink(leasePath(activeRoot, slug, leaseId));
+  } catch (err) {
+    if (!isIgnorableUnlinkError(err)) throw err;
+  }
+}
+function releaseLeaseSync(activeRoot, slug, leaseId) {
+  try {
+    unlinkSync(leasePath(activeRoot, slug, leaseId));
+  } catch {
+  }
+}
+function isLive(lease, now, isAlive) {
+  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);
+}
+function toSibling(lease) {
+  return {
+    lease_id: lease.lease_id,
+    cwd: lease.cwd,
+    mode: lease.mode,
+    started: lease.started,
+    ...lease.pid !== void 0 ? { pid: lease.pid } : {},
+    ...lease.label !== void 0 ? { label: lease.label } : {}
+  };
+}
+async function readOneLease(file) {
+  try {
+    const raw = await fs10.readFile(file, "utf8");
+    const parsed = LeaseSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function unlinkQuietly(file) {
+  try {
+    await fs10.unlink(file);
+  } catch {
+  }
+}
+async function readLiveLeases(input) {
+  const { activeRoot, slug, now = /* @__PURE__ */ new Date(), excludeLeaseId, isAlive = isProcessAlive } = input;
+  try {
+    const dir = leaseDir(activeRoot, slug);
+    let entries;
+    try {
+      entries = await fs10.readdir(dir);
+    } catch {
+      return [];
+    }
+    const live = [];
+    for (const name of entries) {
+      if (!name.endsWith(".json")) continue;
+      const file = path9.join(dir, name);
+      const lease = await readOneLease(file);
+      if (!lease || !isLive(lease, now, isAlive)) {
+        await unlinkQuietly(file);
+        continue;
+      }
+      if (lease.lease_id === excludeLeaseId) continue;
+      live.push(toSibling(lease));
+    }
+    return live.sort((a, b) => a.started.localeCompare(b.started));
+  } catch {
+    return [];
+  }
+}
+async function sweepAllLeases(activeRoot, options = {}) {
+  const root = path9.join(activeRoot, LEASE_DIR_NAME);
+  let slugs;
+  try {
+    const entries = await fs10.readdir(root, { withFileTypes: true });
+    slugs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return { live: 0, pruned: 0 };
+    return { live: 0, pruned: 0, error: err.message };
+  }
+  let live = 0;
+  let before = 0;
+  for (const slug of slugs) {
+    try {
+      const names = await fs10.readdir(leaseDir(activeRoot, slug));
+      before += names.filter((n) => n.endsWith(".json")).length;
+      live += (await readLiveLeases({ activeRoot, slug, ...options })).length;
+    } catch (err) {
+      return { live, pruned: Math.max(before - live, 0), error: err.message };
+    }
+  }
+  return { live, pruned: Math.max(before - live, 0) };
+}
+
+// src/utils/git-gh.ts
+import { spawn } from "child_process";
+import path10 from "path";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var defaultRunner = (bin, args, opts = {}) => new Promise((resolve, reject) => {
+  const child = spawn(bin, args, {
+    cwd: opts.cwd,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  let settled = false;
+  const timer = setTimeout(() => {
+    if (settled) return;
+    settled = true;
+    child.kill("SIGKILL");
+    reject(new Error(`${bin} timed out after ${opts.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`));
+  }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+  child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+  child.on("error", (err) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    reject(err);
+  });
+  child.on("close", (code) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolve({
+      code,
+      stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+      stderr: Buffer.concat(stderrChunks).toString("utf8")
+    });
+  });
+});
+var gitRunner = defaultRunner;
+var ghRunner = defaultRunner;
+function getGitRunner() {
+  return gitRunner;
+}
+function getGhRunner() {
+  return ghRunner;
+}
+function looksLikeOrgRepo(repo) {
+  if (!repo) return false;
+  if (repo.startsWith("/") || repo.startsWith("~") || repo.startsWith(".")) return false;
+  if (/\s/.test(repo)) return false;
+  const slashCount = (repo.match(/\//g) ?? []).length;
+  return slashCount === 1;
+}
+function resolveLocalRepoPath(repo) {
+  if (looksLikeOrgRepo(repo)) return null;
+  return path10.resolve(expandTilde(repo));
+}
+async function deriveOrgRepoFromPath(repoPath) {
+  try {
+    const res = await gitRunner("git", ["-C", repoPath, "remote", "get-url", "origin"]);
+    if (res.code !== 0) return null;
+    return parseOrgRepoFromRemoteUrl(res.stdout.trim());
+  } catch {
+    return null;
+  }
+}
+function parseOrgRepoFromRemoteUrl(url) {
+  const trimmed = url.trim().replace(/\.git$/, "");
+  const sshMatch = /^[^@]+@[^:]+:([^/]+)\/(.+)$/.exec(trimmed);
+  if (sshMatch) return `${sshMatch[1]}/${sshMatch[2]}`;
+  try {
+    const u = new URL(trimmed);
+    const parts = u.pathname.replace(/^\//, "").split("/");
+    if (parts.length >= 2 && parts[0] && parts[1]) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+  } catch {
+  }
+  return null;
+}
+async function resolveOrgRepo(repo) {
+  if (looksLikeOrgRepo(repo)) return repo;
+  const localPath = resolveLocalRepoPath(repo);
+  if (!localPath) return null;
+  return deriveOrgRepoFromPath(localPath);
+}
+
+// src/bootstrap/prompt.ts
+import YAML4 from "yaml";
+var BRIEF_BODY_MAX_LINES = 40;
+var SESSION_BODY_MAX_LINES = 25;
+var DEFAULT_TOP_N_TASKS = 5;
+var DEFAULT_RECENTLY_DONE_DAYS = 14;
+var RECENT_THRESHOLD_DAYS = 14;
+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 match = FRONTMATTER_DELIM2.exec(raw);
+  let frontmatterText = "";
+  let body = raw;
+  if (match) {
+    frontmatterText = match[1] ?? "";
+    body = match[2] ?? "";
+  }
+  const parsed = frontmatterText ? YAML4.parse(frontmatterText) : {};
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(`Frontmatter validation failed for ${filePath}: ${result.error.message}`);
+  }
+  return { frontmatter: result.data, body };
+}
+function compareSessionsNewestFirst(a, b) {
+  const endedDelta = new Date(b.frontmatter.ended).getTime() - new Date(a.frontmatter.ended).getTime();
+  if (endedDelta !== 0) return endedDelta;
+  return new Date(b.frontmatter.started).getTime() - new Date(a.frontmatter.started).getTime();
+}
+async function loadSessionsNewestFirst(initiativeDir) {
+  const { sessions, malformed } = await loadSessionsFromDir(initiativeDir);
+  return { sessions: [...sessions].sort(compareSessionsNewestFirst), malformed };
+}
+function describe2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function loadTasks(initiativeDir) {
+  const tasksDir = path11.join(initiativeDir, "tasks");
+  let entries;
+  try {
+    entries = await fs11.readdir(tasksDir);
+  } catch {
+    return { tasks: [], malformed: [] };
+  }
+  const ymlFiles = entries.filter((n) => n.endsWith(".yml") || n.endsWith(".yaml"));
+  const tasks = [];
+  const malformed = [];
+  for (const filename of ymlFiles) {
+    const fullPath = path11.join(tasksDir, filename);
+    try {
+      tasks.push(await readYaml(fullPath, TaskSchema));
+    } catch (err) {
+      malformed.push({ file: filename, reason: describe2(err) });
+    }
+  }
+  return { tasks, malformed };
+}
+function isMissingFile(err) {
+  return err?.code === "ENOENT";
+}
+async function loadArtifacts(initiativeDir) {
+  const artifactsPath = path11.join(initiativeDir, "artifacts.yml");
+  const empty = { branches: [], stashes: [], worktrees: [] };
+  try {
+    return { artifacts: await readYaml(artifactsPath, ArtifactsSchema) };
+  } catch (err) {
+    if (isMissingFile(err)) return { artifacts: empty };
+    return { artifacts: empty, error: describe2(err) };
+  }
+}
+function truncateLines(body, max, source) {
+  const lines = body.split("\n");
+  const trimmed = [];
+  let count = 0;
+  let consumed = 0;
+  for (const line of lines) {
+    if (count >= max) break;
+    trimmed.push(line);
+    consumed++;
+    if (line.trim().length > 0) count++;
+  }
+  const dropped = lines.slice(consumed).filter((l) => l.trim().length > 0).length;
+  const kept = trimmed.join("\n").replace(/\s+$/, "");
+  if (dropped === 0) return kept;
+  return `${kept}
+\u2026(+${dropped} lines \u2014 see ${source})`;
+}
+function formatTimeSince(from, now) {
+  const diffMs = now.getTime() - from.getTime();
+  if (diffMs < MS_PER_HOUR) return "just now";
+  if (diffMs < MS_PER_DAY2) {
+    const hours = Math.floor(diffMs / MS_PER_HOUR);
+    return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  }
+  const days = Math.floor(diffMs / MS_PER_DAY2);
+  const base = `${days} day${days === 1 ? "" : "s"} ago`;
+  if (days >= RECENT_THRESHOLD_DAYS) {
+    return `${base} \u2014 likely needs context refresher`;
+  }
+  return base;
+}
+function compareTasksByPriority(a, b) {
+  if (a.priority !== b.priority) return a.priority - b.priority;
+  return a.id.localeCompare(b.id);
+}
+function nonBlankLines(text) {
+  if (!text) return [];
+  return text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function firstLine(text) {
+  return nonBlankLines(text)[0];
+}
+var TASK_SUMMARY_MAX_LINES = 2;
+var TASK_SUMMARY_MAX_CHARS = 200;
+function summarizeField(label, lines, pointer) {
+  const kept = lines.slice(0, TASK_SUMMARY_MAX_LINES);
+  const joined = kept.join(" ");
+  const clamped = joined.length > TASK_SUMMARY_MAX_CHARS ? joined.slice(0, TASK_SUMMARY_MAX_CHARS).replace(/\s+\S*$/, "").trimEnd() : joined;
+  const remaining = lines.length - kept.length + (clamped === joined ? 0 : 1);
+  if (remaining === 0) return `${label}${clamped}`;
+  const noun = remaining === 1 ? "line" : "lines";
+  return `${label}${clamped}\u2026(+${remaining} ${noun} \u2014 see ${pointer})`;
+}
+function renderTaskSummary(task, slug) {
+  const pointer = `\`active-work task list ${slug} --json\``;
+  const doneWhen = nonBlankLines(task.done_when);
+  if (doneWhen.length > 0) {
+    return summarizeField("done when: ", doneWhen, pointer);
+  }
+  const notes = nonBlankLines(task.notes);
+  if (notes.length > 0) return summarizeField("notes: ", notes, pointer);
+  return void 0;
+}
+function renderTaskLine(idx, task, slug) {
+  const meta = [`priority ${task.priority}`];
+  if (task.severity) meta.push(`severity ${task.severity}`);
+  if (task.estimate !== void 0) meta.push(`est ${task.estimate}`);
+  let line = `${idx}. [${task.id}] (${meta.join(", ")}) ${task.title}`;
+  const summary = renderTaskSummary(task, slug);
+  if (summary) line += `
+   ${summary}`;
+  return line;
+}
+function renderTopTasks(tasks, topN, slug) {
+  const openTasks = tasks.filter((t) => t.status === "open").sort(compareTasksByPriority);
+  if (openTasks.length === 0) {
+    return { body: "_No open tasks._", count: 0 };
+  }
+  const shown = openTasks.slice(0, topN);
+  return {
+    body: shown.map((task, i) => renderTaskLine(i + 1, task, slug)).join("\n"),
+    count: openTasks.length
+  };
+}
+function renderRecentlyDone(tasks, windowDays, now, slug) {
+  const cutoff = now.getTime() - windowDays * MS_PER_DAY2;
+  const done = tasks.filter((t) => t.status === "done" && t.done_at).filter((t) => {
+    const ts = new Date(t.done_at).getTime();
+    return Number.isFinite(ts) && ts >= cutoff;
+  }).sort((a, b) => a.done_at < b.done_at ? 1 : -1);
+  if (done.length === 0) return { body: null, count: 0 };
+  const noun = done.length === 1 ? "task" : "tasks";
+  const body = `${done.length} ${noun} completed \u2014 \`active-work task list ${slug} --status done --json\``;
+  return { body, count: done.length };
+}
+var DURABLE_NOTES_LIMIT = 12;
+function renderNoteLine(note) {
+  const { kind, title, created } = note.frontmatter;
+  return `- [${kind}] ${title} (${created})`;
+}
+function renderDurableNotes(loaded, slug) {
+  const { notes, malformed } = loaded;
+  if (notes.length === 0 && malformed.length === 0) return null;
+  const shown = notes.slice(0, DURABLE_NOTES_LIMIT);
+  const lines = shown.map(renderNoteLine);
+  const overflow = notes.length - shown.length;
+  if (overflow > 0) {
+    lines.push(`(+${overflow} older \u2014 \`active-work note list ${slug}\`)`);
+  }
+  if (malformed.length > 0) {
+    lines.push(
+      `(${malformed.length} note file(s) unreadable \u2014 run \`active-work note list ${slug}\`)`
+    );
+  }
+  const heading = overflow > 0 ? `# Durable notes (newest ${shown.length} of ${notes.length})` : `# Durable notes (${notes.length})`;
+  return `${heading}
+${lines.join("\n")}`;
+}
+function renderNoOpenLoops(newestSession) {
+  if (newestSession?.frontmatter.no_loops === true) {
+    return `Nothing hanging \u2014 the ${endedDate(newestSession.ended)} session asserted the ledger is clear.`;
+  }
+  return "Nothing hanging \u2014 no unresolved loops, but no session has asserted the ledger is clear.";
+}
+function malformedNote(malformed) {
+  if (malformed.length === 0) return "";
+  return ` (${malformed.length} session file(s) unreadable \u2014 run \`active-work doctor\`)`;
+}
+function malformedTaskNote(malformed) {
+  if (malformed.length === 0) return "";
+  const files = malformed.map((m) => m.file).join(", ");
+  return ` \u2014 ${malformed.length} task file(s) unreadable (${files}); run \`active-work doctor\``;
+}
+function textOpensWithRef(text, ref, kind) {
+  const head = text.replace(/^\s*(PR\s*)?#?/i, "");
+  if (kind === "pr" && normalizePrRef(head.split(/\s/)[0] ?? "") === ref) return true;
+  if (!head.toLowerCase().startsWith(ref.toLowerCase())) return false;
+  const next = head.charAt(ref.length);
+  return next === "" || !/[A-Za-z0-9]/.test(next);
+}
+function loopLabel(loop) {
+  if (loop.targetRef === void 0) return loop.text;
+  const ref = loop.kind === "pr" ? normalizePrRef(loop.targetRef) : loop.targetRef;
+  if (textOpensWithRef(loop.text, ref, loop.kind)) return loop.text;
+  return loop.kind === "pr" ? `PR #${ref} ${loop.text}` : `${ref} ${loop.text}`;
+}
+function renderOpenLoops(loops, malformed, newestSession) {
+  const note = malformedNote(malformed);
+  if (loops.length === 0) {
+    return `# Open loops${note}
+${renderNoOpenLoops(newestSession)}`;
+  }
+  const labels = loops.map(loopLabel);
+  const ageWidth = Math.max(...loops.map((l) => String(l.ageDays).length));
+  const labelWidth = Math.max(...labels.map((l) => l.length));
+  const lines = loops.map((loop, i) => {
+    const age = `[${String(loop.ageDays).padStart(ageWidth)}d]`;
+    const label = labels[i].padEnd(labelWidth);
+    const from = loop.openedAt.slice(0, 10);
+    return `- ${age} ${label}   (from ${from}, ref ${loop.ref})`;
+  });
+  const oldest = loops[0].ageDays;
+  return `# Open loops (${loops.length} hanging, oldest ${oldest}d)${note}
+${lines.join("\n")}`;
+}
+var WRAP_DIRECTIVE = "Update tasks via `active-work task done` and close the session out via `active-work wrap` when wrapping up \u2014 it records the session, files the loops you leave open, and stamps the brief in one step.";
+function renderClosingInstruction(openLoops) {
+  if (openLoops.length === 0) {
+    return `Work the top task unless redirected. ${WRAP_DIRECTIVE}`;
+  }
+  const count = openLoops.length;
+  const noun = count === 1 ? "loop" : "loops";
+  const verb = count === 1 ? "is" : "are";
+  return `Start with the open ${noun}: ${count} ${verb} still hanging from prior sessions, and unfinished threads take precedence over the backlog. Work them first, citing each one by the \`ref\` printed under "Open loops", and pass every loop you settle to \`active-work wrap --resolves\` with outcome \`done\` or \`abandoned\` \u2014 deciding not to do a loop still closes it. Once the loops are handled, or if the user redirects, work the top task by priority. ${WRAP_DIRECTIVE}`;
+}
+function renderAbandonedLoops(resolved, windowDays) {
+  const abandoned = resolved.filter(
+    (loop) => loop.outcome === "abandoned" && loop.ageDays <= windowDays
+  );
+  if (abandoned.length === 0) return null;
+  const lines = abandoned.map((loop) => {
+    const head = `- ${loop.text} (dropped ${loop.closedAt.slice(0, 10)})`;
+    return loop.note ? `${head}
+  why: ${loop.note}` : head;
+  });
+  return `# Abandoned in the last ${windowDays} days (${abandoned.length})
+${lines.join("\n")}`;
+}
+var LIVE_RENDER_LIMIT = 10;
+function renderStaticBranchLine(branch) {
+  const head = `- ${branch.name} (${branch.repo})`;
+  return branch.note ? `${head} \u2014 ${branch.note}` : head;
+}
+function renderLiveBranchLine(status) {
+  const parts = [`- ${status.name} (${status.repo})`];
+  if (!status.present) {
+    parts.push("[missing locally]");
+  } else if (status.ahead !== null && status.behind !== null) {
+    parts.push(`+${status.ahead}/-${status.behind}`);
+  }
+  if (status.last_commit_iso) {
+    parts.push(`last commit ${status.last_commit_iso.slice(0, 10)}`);
+  }
+  if (status.pr) {
+    const checks = status.pr.checks ? ` ${status.pr.checks}` : "";
+    parts.push(`PR #${status.pr.number} ${status.pr.state}${checks}`);
+  }
+  let line = parts.join(" ");
+  if (status.note) line += ` \u2014 ${status.note}`;
+  if (status.pr) {
+    line += `
+  PR: ${status.pr.title} \u2014 ${status.pr.url}`;
+  }
+  return line;
+}
+var WORKTREE_RENDER_LIMIT = 8;
+function renderWorktreeLine(entry) {
+  const parts = [`- ${entry.name}${entry.default ? " (default)" : ""}: ${entry.path}`];
+  if (entry.branch) parts.push(`[${entry.branch}]`);
+  if (entry.pr) parts.push(`PR #${entry.pr}`);
+  const trailer = entry.holding ?? entry.note;
+  return trailer ? `${parts.join(" ")} \u2014 ${trailer}` : parts.join(" ");
+}
+function renderWorktrees(artifacts, slug) {
+  const registered = artifacts.worktrees.filter((w) => w.name !== void 0);
+  const observed = artifacts.worktrees.length - registered.length;
+  if (registered.length === 0 && observed === 0) return null;
+  const lines = [];
+  const shown = registered.slice(0, WORKTREE_RENDER_LIMIT);
+  if (shown.length > 0) {
+    lines.push(...shown.map(renderWorktreeLine));
+  } else {
+    lines.push("_None registered._");
+  }
+  const overflow = registered.length - shown.length;
+  if (overflow > 0) {
+    lines.push(`(+${overflow} more registered \u2014 \`active-work artifact list ${slug}\`)`);
+  }
+  if (observed > 0) {
+    const noun = observed === 1 ? "worktree" : "worktrees";
+    lines.push(
+      `(+${observed} observed ${noun} swept from git, not registered \u2014 \`active-work artifact list ${slug}\`)`
+    );
+  }
+  return `Worktrees (registered):
+${lines.join("\n")}`;
+}
+function renderStashes(artifacts) {
+  if (artifacts.stashes.length === 0) return null;
+  return artifacts.stashes.map((s) => `- ${s.repo}: ${s.label}${s.sha ? ` (${s.sha.slice(0, 12)})` : ""}`).join("\n");
+}
+function renderStaticArtifacts(artifacts, slug) {
+  const sections = [];
+  if (artifacts.branches.length > 0) {
+    const branchLines = artifacts.branches.map(renderStaticBranchLine).join("\n");
+    sections.push(`Branches:
+${branchLines}`);
+  }
+  const worktreeBody = renderWorktrees(artifacts, slug);
+  if (worktreeBody) sections.push(worktreeBody);
+  const stashBody = renderStashes(artifacts);
+  if (stashBody) sections.push(`Stashes:
+${stashBody}`);
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}
+function renderLiveArtifacts(artifacts, statuses, slug) {
+  const sections = [];
+  if (statuses.length > 0) {
+    const shown = statuses.slice(0, LIVE_RENDER_LIMIT);
+    const lines = shown.map(renderLiveBranchLine).join("\n");
+    const overflow = statuses.length - shown.length;
+    const suffix = overflow > 0 ? `
+(+${overflow} more)` : "";
+    sections.push(`Branches (live):
+${lines}${suffix}`);
+  } else if (artifacts.branches.length > 0) {
+    const branchLines = artifacts.branches.map(renderStaticBranchLine).join("\n");
+    sections.push(`Branches:
+${branchLines}`);
+  }
+  const worktreeBody = renderWorktrees(artifacts, slug);
+  if (worktreeBody) sections.push(worktreeBody);
+  const stashBody = renderStashes(artifacts);
+  if (stashBody) sections.push(`Stashes:
+${stashBody}`);
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}
+async function defaultLiveStatusFetcher(branches) {
+  const results = [];
+  const limit = Math.min(branches.length, LIVE_RENDER_LIMIT);
+  for (let i = 0; i < limit; i++) {
+    results.push(await fetchOne(branches[i]));
+  }
+  return results;
+}
+async function fetchOne(branch) {
+  const out = {
+    repo: branch.repo,
+    name: branch.name,
+    ...branch.note ? { note: branch.note } : {},
+    present: false,
+    last_commit_iso: null,
+    ahead: null,
+    behind: null,
+    pr: null
+  };
+  const repoPath = resolveLocalRepoPath(branch.repo);
+  const git = getGitRunner();
+  const gh = getGhRunner();
+  if (repoPath) {
+    try {
+      const exists2 = await git("git", [
+        "-C",
+        repoPath,
+        "rev-parse",
+        "--verify",
+        `refs/heads/${branch.name}`
+      ]);
+      out.present = exists2.code === 0;
+    } catch {
+    }
+    if (out.present) {
+      try {
+        const lc = await git("git", ["-C", repoPath, "log", "-1", "--format=%cI", branch.name]);
+        if (lc.code === 0) {
+          const s = lc.stdout.trim();
+          out.last_commit_iso = s.length > 0 ? s : null;
+        }
+      } catch {
+      }
+      for (const base of ["main", "master"]) {
+        try {
+          const verify = await git("git", [
+            "-C",
+            repoPath,
+            "rev-parse",
+            "--verify",
+            `refs/remotes/origin/${base}`
+          ]);
+          if (verify.code !== 0) continue;
+          const counts = await git("git", [
+            "-C",
+            repoPath,
+            "rev-list",
+            "--left-right",
+            "--count",
+            `origin/${base}...${branch.name}`
+          ]);
+          if (counts.code === 0) {
+            const parts = counts.stdout.trim().split(/\s+/);
+            if (parts.length === 2) {
+              const b = Number(parts[0]);
+              const a = Number(parts[1]);
+              if (Number.isFinite(a) && Number.isFinite(b)) {
+                out.ahead = a;
+                out.behind = b;
+              }
+            }
+          }
+          break;
+        } catch {
+        }
+      }
+    }
+  }
+  try {
+    const orgRepo = await resolveOrgRepo(branch.repo);
+    if (orgRepo) {
+      const res = await gh("gh", [
+        "pr",
+        "list",
+        "--head",
+        branch.name,
+        "--repo",
+        orgRepo,
+        "--json",
+        "number,state,title,url,statusCheckRollup",
+        "--limit",
+        "1"
+      ]);
+      if (res.code === 0) {
+        const parsed = JSON.parse(res.stdout);
+        if (Array.isArray(parsed) && parsed.length > 0) {
+          const first = parsed[0];
+          if (typeof first.number === "number" && typeof first.state === "string" && typeof first.title === "string" && typeof first.url === "string") {
+            const rollup = first.statusCheckRollup ?? [];
+            let pass = 0;
+            let fail = 0;
+            let pending = 0;
+            for (const entry of rollup) {
+              const tag = (entry.conclusion ?? entry.state ?? "").toUpperCase();
+              if (tag === "SUCCESS") pass++;
+              else if (tag === "FAILURE" || tag === "CANCELLED" || tag === "TIMED_OUT") fail++;
+              else pending++;
+            }
+            let checks;
+            if (rollup.length > 0) {
+              if (fail > 0) checks = `fail (${fail}/${rollup.length})`;
+              else if (pending > 0) checks = `pending (${pending}/${rollup.length})`;
+              else checks = `pass (${pass}/${rollup.length})`;
+            }
+            out.pr = {
+              number: first.number,
+              state: first.state,
+              title: first.title,
+              url: first.url,
+              ...checks ? { checks } : {}
+            };
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function endedDate(iso) {
+  return iso.slice(0, 10);
+}
+function selectParallelSessions(sessions, narrativeSession) {
+  if (!narrativeSession) return [];
+  const cutoff = new Date(narrativeSession.frontmatter.ended).getTime();
+  return sessions.filter(
+    (s) => s !== narrativeSession && s.frontmatter.track !== "canonical" && new Date(s.frontmatter.ended).getTime() > cutoff
+  );
+}
+function renderParallelSessions(sessions) {
+  if (sessions.length === 0) return null;
+  const lines = sessions.map((s) => {
+    const { ended, session_id, track } = s.frontmatter;
+    const summary = firstLine(s.body) ?? "_(empty session body)_";
+    return `- ${endedDate(ended)} (${track}, ${session_id}) \u2014 ${summary}`;
+  });
+  return `# Parallel sessions since then
+${lines.join("\n")}`;
+}
+var MS_PER_MINUTE = 6e4;
+function formatElapsedShort(from, now) {
+  const diffMs = now.getTime() - from.getTime();
+  if (!Number.isFinite(diffMs) || diffMs < MS_PER_MINUTE) return "just started";
+  const minutes = Math.floor(diffMs / MS_PER_MINUTE);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return rest === 0 ? `${hours}h ago` : `${hours}h ${rest}m ago`;
+}
+function hasAgentChatChannel(brief) {
+  return (brief.channels ?? []).some((raw) => {
+    const name = raw.replace(/^(?:server|plugin):/, "").split("@")[0] ?? "";
+    return name === "agent-chat";
+  });
+}
+function renderSiblingLine(sibling, now) {
+  const elapsed = formatElapsedShort(new Date(sibling.started), now);
+  const where = `in \`${sibling.cwd}\``;
+  if (sibling.mode === "launcher") {
+    const pid = sibling.pid === void 0 ? "" : ` (pid ${sibling.pid})`;
+    return `- started ${elapsed} ${where} \u2014 launched via \`aw\`, process still running${pid}.`;
+  }
+  return `- bootstrapped ${elapsed} ${where} \u2014 no live process to confirm, so it may have already exited.`;
+}
+var SIBLING_HEADING = "# Another session may already be live on this initiative";
+function renderSiblingSessions(siblings, brief, topTaskTitle, now) {
+  if (siblings.length === 0) return "";
+  const lines = siblings.map((s) => renderSiblingLine(s, now));
+  const topTask = topTaskTitle ? ` ("${topTaskTitle}")` : "";
+  lines.push(
+    `Before starting the top task${topTask}, ask the user which session owns it. If this is the second session, take distinct scope and record it with \`active-work wrap --track adhoc\` \u2014 not \`canonical\`, which would bury the other session's mainline thread in the next bootstrap.`
+  );
+  if (hasAgentChatChannel(brief)) {
+    lines.push(
+      "This initiative carries an agent-chat channel: register under a name that distinguishes you from the other session and coordinate scope there."
+    );
+  }
+  return `${SIBLING_HEADING}
+${lines.join("\n")}`;
+}
+function renderBriefState(brief, now) {
+  if (brief.state === "focused") return null;
+  const lines = [];
+  if (brief.paused_since) {
+    const since = formatTimeSince(new Date(brief.paused_since), now);
+    lines.push(`Paused since ${brief.paused_since} (${since}).`);
+  }
+  if (brief.restart_trigger) {
+    lines.push(`Restart trigger: ${brief.restart_trigger}`);
+  }
+  lines.push(
+    `This initiative is \`${brief.state}\`, not \`focused\` \u2014 confirm with the user before treating its tasks as current work.`
+  );
+  return `# Initiative state: ${brief.state}
+${lines.join("\n")}`;
+}
+async function loadBrief(initiativeDir, slug) {
+  const briefPath = path11.join(initiativeDir, "brief.md");
+  try {
+    return await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new NotFoundError(`Initiative '${slug}' has no readable brief.md (${reason})`);
+  }
+}
+async function assembleBootstrap(input) {
+  const {
+    activeRoot,
+    slug,
+    now = /* @__PURE__ */ new Date(),
+    topNTasks = DEFAULT_TOP_N_TASKS,
+    recentlyDoneDays = DEFAULT_RECENTLY_DONE_DAYS,
+    includeLiveStatus = true,
+    liveStatusFetcher,
+    archivedTaskIds,
+    adhoc = false,
+    detectSiblings = true,
+    siblingProbe = readLiveLeases,
+    ownLeaseId
+  } = input;
+  const initiativeDir = path11.join(activeRoot, slug);
+  const { frontmatter: brief, body: briefBody } = await loadBrief(initiativeDir, slug);
+  const [loaded, loadedTasks, loadedArtifacts, notes] = await Promise.all([
+    loadSessionsNewestFirst(initiativeDir),
+    loadTasks(initiativeDir),
+    loadArtifacts(initiativeDir),
+    loadNotesFromDir(initiativeDir)
+  ]);
+  const { sessions, malformed } = loaded;
+  const { tasks, malformed: malformedTasks } = loadedTasks;
+  const { artifacts, error: artifactsError } = loadedArtifacts;
+  const openLoops = deriveOpenLoopsFrom(loaded, { now, tasks });
+  const resolvedLoops = deriveResolvedLoopsFrom(loaded, { now, tasks });
+  const latestCanonical = sessions.find((s) => s.frontmatter.track === "canonical");
+  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 { body: tasksBody, count: openTaskCount } = renderTopTasks(tasks, topNTasks, slug);
+  const { body: recentlyDoneBody, count: recentlyDoneCount } = renderRecentlyDone(
+    tasks,
+    recentlyDoneDays,
+    now,
+    slug
+  );
+  let artifactsBody = null;
+  if (!includeLiveStatus || artifacts.branches.length === 0) {
+    artifactsBody = renderStaticArtifacts(artifacts, slug);
+  } else {
+    const fetcher = liveStatusFetcher ?? defaultLiveStatusFetcher;
+    try {
+      const statuses = await fetcher(artifacts.branches);
+      artifactsBody = renderLiveArtifacts(artifacts, statuses, slug);
+    } catch {
+      artifactsBody = renderStaticArtifacts(artifacts, slug);
+    }
+  }
+  const timeSinceHuman = narrativeSession ? formatTimeSince(new Date(narrativeSession.frontmatter.ended), now) : void 0;
+  let siblings = [];
+  if (detectSiblings) {
+    try {
+      siblings = await siblingProbe({
+        activeRoot,
+        slug,
+        now,
+        ...ownLeaseId ? { excludeLeaseId: ownLeaseId } : {}
+      });
+    } catch {
+      siblings = [];
+    }
+  }
+  const topTaskTitle = tasks.filter((t) => t.status === "open").sort(compareTasksByPriority)[0]?.title;
+  const sections = [];
+  sections.push(
+    adhoc ? `Starting an ad-hoc session on \`${slug}\` (${brief.title}). This session is scoped to ad-hoc work related to this workstream \u2014 not necessarily its handoff or current top task. The context below is background so you're oriented; wait for the user to describe the specific ad-hoc task before acting.` : `Starting a session on \`${slug}\` (${brief.title}).`
+  );
+  const siblingBody = renderSiblingSessions(siblings, brief, topTaskTitle, now);
+  if (siblingBody) sections.push(siblingBody);
+  const stateBody = renderBriefState(brief, now);
+  if (stateBody) sections.push(stateBody);
+  sections.push(`# Why we're doing this
+${briefExcerpt}`);
+  sections.push(renderOpenLoops(openLoops, malformed, sessions[0]));
+  const abandonedBody = renderAbandonedLoops(resolvedLoops, recentlyDoneDays);
+  if (abandonedBody) sections.push(abandonedBody);
+  if (narrativeSession) {
+    const sessionExcerpt = truncateLines(
+      narrativeSession.body,
+      SESSION_BODY_MAX_LINES,
+      path11.join(initiativeDir, "sessions", `${narrativeSession.sessionFile}.md`)
+    ) || "_(empty session body)_";
+    const ended = endedDate(narrativeSession.frontmatter.ended);
+    const trackLabel = usedFallbackTrack ? ` (${narrativeSession.frontmatter.track})` : "";
+    sections.push(
+      `# Last session${trackLabel} (${ended}, ${narrativeSession.frontmatter.session_id}) \u2014 ${timeSinceHuman}
+${sessionExcerpt}`
+    );
+  } else {
+    sections.push(`# Last session
+No previous sessions recorded.`);
+  }
+  if (parallelBody) sections.push(parallelBody);
+  sections.push(
+    `# Tasks (top ${topNTasks} open by priority)${malformedTaskNote(malformedTasks)}
+${tasksBody}`
+  );
+  if (recentlyDoneBody) {
+    sections.push(`# Recently done (last ${recentlyDoneDays} days)
+${recentlyDoneBody}`);
+  }
+  if (archivedTaskIds && archivedTaskIds.length > 0) {
+    sections.push(
+      `# Archived (housekeeping)
+Moved ${archivedTaskIds.length} stale done task(s) to tasks/archive/: ${archivedTaskIds.join(", ")}`
+    );
+  }
+  const notesBody = renderDurableNotes(notes, slug);
+  if (notesBody) sections.push(notesBody);
+  if (artifactsError) {
+    const artifactsPath = path11.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\`._`
+    );
+  } else if (artifactsBody) {
+    sections.push(`# Open artifacts
+${artifactsBody}`);
+  }
+  const bootstrapAt = nowIso();
+  const todayStr = today();
+  const contextLines = [`- Today: ${todayStr}`, `- Bootstrap: ${bootstrapAt}`];
+  if (timeSinceHuman) {
+    contextLines.push(`- Time since last session: ${timeSinceHuman}`);
+  }
+  sections.push(`# Context
+${contextLines.join("\n")}`);
+  sections.push(
+    adhoc ? `This is an ad-hoc session: treat the context above as background, not a directive. Do not assume we're continuing the top task or the handoff \u2014 the user will describe the specific ad-hoc task. Once they do, work it with the workstream context in mind. If it turns out to be substantive, still capture it via \`active-work task add\` / \`active-work wrap --track adhoc\`. The \`--track adhoc\` flag is required: this session runs alongside the mainline thread, and recording it as canonical would bury the real last session for the next bootstrap.` : renderClosingInstruction(openLoops)
+  );
+  const prompt = sections.join("\n\n") + "\n";
+  const metadata = {
+    slug,
+    brief_title: brief.title,
+    open_task_count: openTaskCount,
+    open_loop_count: openLoops.length,
+    recently_done_count: recentlyDoneCount,
+    bootstrap_at: bootstrapAt
+  };
+  if (narrativeSession) {
+    metadata.last_session = {
+      filename: `${narrativeSession.sessionFile}.md`,
+      ended: narrativeSession.frontmatter.ended
+    };
+  }
+  if (timeSinceHuman) {
+    metadata.time_since_last_session_human = timeSinceHuman;
+  }
+  if (siblings.length > 0) {
+    metadata.sibling_sessions = siblings.length;
+  }
+  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 });
+  } catch {
+    return [];
+  }
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+}
+async function resolveSlug(activeRoot, input) {
+  const slugs = await listInitiativeSlugs(activeRoot);
+  if (slugs.includes(input)) return input;
+  const matches = slugs.filter((s) => s.startsWith(input));
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) {
+    throw new NotFoundError(`Ambiguous slug '${input}'. Candidates: ${matches.join(", ")}`);
+  }
+  if (slugs.length === 0) {
+    throw new NotFoundError(`No initiatives found under ${activeRoot}`);
+  }
+  throw new NotFoundError(`No initiative matches '${input}'. Known: ${slugs.join(", ")}`);
+}
+function isInside(child, parent) {
+  const rel = path13.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path13.isAbsolute(rel);
+}
+async function canonicalize(p) {
+  try {
+    return await fs12.realpath(p);
+  } catch {
+    return path13.resolve(p);
+  }
+}
+async function resolveSlugFromCwd(activeRoot, cwd) {
+  const resolvedCwd = await canonicalize(cwd);
+  const slugs = await listInitiativeSlugs(activeRoot);
+  let best = null;
+  let tiedAtBest = false;
+  for (const slug of slugs) {
+    const briefPath = path13.join(activeRoot, slug, "brief.md");
+    try {
+      await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
+    } catch {
+      continue;
+    }
+    const registered = await readRegisteredWorktrees(path13.join(activeRoot, slug));
+    for (const entry of registered) {
+      const displayPath = expandTilde(entry.path);
+      if (!path13.isAbsolute(displayPath)) continue;
+      const canonical = await canonicalize(displayPath);
+      if (!isInside(resolvedCwd, canonical)) continue;
+      const depth = canonical.length;
+      if (best === null || depth > best.depth) {
+        best = { slug, worktreePath: displayPath, depth };
+        tiedAtBest = false;
+      } else if (depth === best.depth && slug !== best.slug) {
+        tiedAtBest = true;
+      }
+    }
+  }
+  if (best === null || tiedAtBest) return null;
+  return { slug: best.slug, worktreePath: best.worktreePath };
+}
+
+// src/commands/open.ts
+var ARCHIVE_DONE_AFTER_DAYS = 30;
+var ArgsSchema2 = z8.object({
+  slug: z8.string().min(1).optional(),
+  offline: z8.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(),
+  // Force the picker even when the cwd matches an initiative's worktree.
+  pick: z8.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(),
+  // Skip the sibling-session probe (and the lease write that goes with it).
+  no_sibling_check: z8.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()
+});
+var InitiativeSummarySchema = z8.object({
+  slug: z8.string(),
+  title: z8.string(),
+  state: z8.enum(["focused", "backburner", "paused", "done"]),
+  rank: z8.number().int().positive().optional()
+});
+var PickerResultSchema = z8.object({
+  picker: z8.literal(true),
+  initiatives: z8.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()
+  }),
+  // 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()
+});
+var ResultSchema2 = z8.union([OpenResultSchema, PickerResultSchema]);
+var STATE_ORDER = {
+  focused: 0,
+  backburner: 1,
+  paused: 2,
+  done: 3
+};
+async function loadInitiativeSummary(activeRoot, slug) {
+  const briefPath = path14.join(activeRoot, slug, "brief.md");
+  try {
+    const { frontmatter } = await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
+    return {
+      slug,
+      title: frontmatter.title,
+      state: frontmatter.state,
+      rank: frontmatter.rank
+    };
+  } catch {
+    return null;
+  }
+}
+function compareInitiatives(a, b) {
+  const stateDiff = STATE_ORDER[a.state] - STATE_ORDER[b.state];
+  if (stateDiff !== 0) return stateDiff;
+  if (a.rank !== void 0 && b.rank !== void 0 && a.rank !== b.rank) {
+    return a.rank - b.rank;
+  }
+  if (a.rank !== void 0 && b.rank === void 0) return -1;
+  if (a.rank === void 0 && b.rank !== void 0) return 1;
+  return a.slug.localeCompare(b.slug);
+}
+async function collectInitiatives(activeRoot) {
+  const slugs = await listInitiativeSlugs(activeRoot);
+  const summaries = [];
+  for (const slug of slugs) {
+    const summary = await loadInitiativeSummary(activeRoot, slug);
+    if (summary) summaries.push(summary);
+  }
+  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" });
+  } catch {
+  }
+}
+async function bootstrapInitiative(activeRoot, slug, opts) {
+  const briefPath = path14.join(activeRoot, slug, "brief.md");
+  const { frontmatter: brief } = await readMarkdownWithSchema(briefPath, BriefFrontmatterSchema);
+  const cwdHint = opts.cwdHintOverride ?? await resolveCwdHint(activeRoot, slug);
+  const archivedTaskIds = await archiveStaleTasks(path14.join(activeRoot, slug), {
+    retentionDays: ARCHIVE_DONE_AFTER_DAYS,
+    now: /* @__PURE__ */ new Date()
+  });
+  const detectSiblings = opts.detectSiblings !== false;
+  const { prompt, metadata } = await assembleBootstrap({
+    activeRoot,
+    slug,
+    includeLiveStatus: !opts.offline,
+    archivedTaskIds,
+    adhoc: opts.adhoc,
+    detectSiblings,
+    ...process.env.AW_LEASE_ID ? { ownLeaseId: process.env.AW_LEASE_ID } : {}
+  });
+  if (detectSiblings && !opts.deferLease) {
+    await claimOneshotLease(activeRoot, slug, cwdHint);
+  }
+  return {
+    slug,
+    prompt,
+    cwd_hint: cwdHint,
+    ...brief.channels && brief.channels.length > 0 ? { channels: brief.channels } : {},
+    metadata,
+    resolved_from: opts.resolvedFrom
+  };
+}
+var openCommand = defineCommand({
+  name: "open",
+  description: "Bootstrap a Claude session for an initiative. Without a slug, resolves the initiative whose worktree contains the caller's cwd; falls back to the picker list when nothing matches.",
+  args: ArgsSchema2,
+  result: ResultSchema2,
+  cli: {
+    positional: ["slug"],
+    options: {
+      offline: {
+        long: "--offline",
+        description: "Skip the live `gh`/`git` artifact lookup; render artifacts statically."
+      },
+      cwd: {
+        long: "--cwd",
+        description: "Directory to resolve the initiative from when no slug is given (default: current directory)."
+      },
+      pick: {
+        long: "--pick",
+        description: "Always return the picker list; skip resolving the initiative from the current directory."
+      },
+      adhoc: {
+        long: "--adhoc",
+        description: "Frame the prompt as ad-hoc work on the workstream (awaiting the user\u2019s task), not a continuation of the handoff / top task."
+      },
+      no_sibling_check: {
+        long: "--no-sibling-check",
+        description: "Skip the check for another session already live on this initiative, and do not record a lease for this one."
+      }
+    },
+    usage: "active-work open [slug] [--offline] [--cwd <dir>] [--pick] [--adhoc] [--no-sibling-check]"
+  },
+  async run(args, ctx) {
+    const activeRoot = ctx.activeRoot ?? getActiveRoot();
+    const detectSiblings = !args.no_sibling_check && !args.offline;
+    const deferLease = args.lease_mode === "defer";
+    if (args.slug) {
+      const slug = await resolveSlug(activeRoot, args.slug);
+      return bootstrapInitiative(activeRoot, slug, {
+        offline: args.offline,
+        resolvedFrom: "slug",
+        adhoc: args.adhoc,
+        detectSiblings,
+        deferLease
+      });
+    }
+    const cwd = args.cwd ?? ctx.cwd;
+    if (!args.pick && cwd) {
+      const matched = await resolveSlugFromCwd(activeRoot, cwd);
+      if (matched) {
+        return bootstrapInitiative(activeRoot, matched.slug, {
+          offline: args.offline,
+          resolvedFrom: "cwd",
+          cwdHintOverride: matched.worktreePath,
+          adhoc: args.adhoc,
+          detectSiblings,
+          deferLease
+        });
+      }
+    }
+    const initiatives = await collectInitiatives(activeRoot);
+    return { picker: true, initiatives };
+  }
+});
+var open_default = openCommand;
+
+// src/utils/color.ts
+import pc from "picocolors";
+var enabled = !("NO_COLOR" in process.env) && process.stdout.isTTY === true;
+var identity = (s) => s;
+var color = {
+  enabled,
+  bold: enabled ? pc.bold : identity,
+  dim: enabled ? pc.dim : identity,
+  green: enabled ? pc.green : identity,
+  yellow: enabled ? pc.yellow : identity,
+  red: enabled ? pc.red : identity,
+  cyan: enabled ? pc.cyan : identity,
+  gray: enabled ? pc.gray : identity
+};
+
+export {
+  TaskSeqSchema,
+  BriefFrontmatterSchema,
+  expandTilde,
+  getActiveRoot,
+  getStateRoot,
+  getConfigRoot,
+  getInitiativeDir,
+  getLockPath,
+  BranchEntrySchema,
+  StashEntrySchema,
+  WorktreeEntrySchema,
+  ArtifactsSchema,
+  atomicWrite,
+  withFileLock,
+  hashContent,
+  readArtifactHashes,
+  readYaml,
+  writeYaml,
+  readArtifactsFile,
+  registeredOf,
+  readRegisteredWorktrees,
+  writeArtifactsFile,
+  defineCommand,
+  successEnvelope,
+  errorEnvelope,
+  registry,
+  register,
+  TaskSchema,
+  SessionIdSchema,
+  NextStepSchema,
+  SessionResolveSchema,
+  SessionFrontmatterSchema,
+  loadSessionsFromDir,
+  deriveOpenLoopsFrom,
+  deriveOpenLoops,
+  deriveResolvedLoopsFrom,
+  findDanglingResolves,
+  findSessionIssues,
+  NoteKindSchema,
+  NOTE_TITLE_MAX_LENGTH,
+  readFrontmatter,
+  readRawFrontmatter,
+  writeFrontmatter,
+  today,
+  nowIso,
+  EXIT,
+  ActiveWorkError,
+  ValidationError,
+  NotFoundError,
+  UsageError,
+  DaemonError,
+  ConfigError,
+  formatError,
+  source_add_default,
+  loadNotesFromDir,
+  writeNoteFile,
+  writePidFile,
+  readPidFile,
+  removePidFile,
+  DEFAULT_DAEMON_PORT,
+  resolveDaemonPort,
+  probeHealth,
+  isProcessAlive,
+  acquireLease,
+  releaseLease,
+  releaseLeaseSync,
+  sweepAllLeases,
+  getGitRunner,
+  getGhRunner,
+  resolveLocalRepoPath,
+  resolveOrgRepo,
+  assembleBootstrap,
+  resolveSlug,
+  resolveSlugFromCwd,
+  open_default,
+  color
+};
+//# sourceMappingURL=chunk-FM2KVFDO.js.map