@titan-design/active-work 0.1.0

package/dist/chunk-OET6AFME.js

@@ -0,0 +1,1276 @@
+// 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 path7 from "path";
+import { z as z5 } 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 worktreeEntry = z.object({
+  path: z.string().min(1),
+  default: z.boolean().optional()
+});
+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"
+  }),
+  worktrees: z.record(z.string(), worktreeEntry).optional(),
+  channels: z.array(channelTarget).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/bootstrap/prompt.ts
+import { promises as fs3 } from "fs";
+import path4 from "path";
+
+// src/schemas/task.ts
+import { z as z2 } 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 = z2.string().refine(isValidIsoDate2, { message: "Must be a valid zero-padded YYYY-MM-DD date" });
+var isoDateOrNull = z2.union([isoDate2, z2.null()]);
+var TaskSchema = z2.object({
+  id: z2.string().regex(/^[A-Z][A-Z0-9]*-\d+$/, {
+    message: "id must match /^[A-Z][A-Z0-9]*-\\d+$/ (e.g. EC-1)"
+  }),
+  title: z2.string().min(1),
+  priority: z2.number().int().positive(),
+  severity: z2.enum(["critical", "high", "medium", "low"]).optional(),
+  estimate: z2.number().positive().optional(),
+  done_when: z2.string().min(1).optional(),
+  status: z2.enum(["open", "done"]),
+  tags: z2.array(z2.string()).optional(),
+  notes: z2.string().optional(),
+  created: isoDate2,
+  updated: isoDate2,
+  done_at: isoDateOrNull
+});
+
+// src/schemas/session.ts
+import { z as z3 } 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 = z3.string().refine(isValidIso8601, { message: "Must be a valid ISO 8601 datetime with timezone" });
+var SessionFrontmatterSchema = z3.object({
+  session_id: z3.string().min(1),
+  started: iso8601,
+  ended: iso8601,
+  track: z3.enum(["canonical", "sidecar"])
+}).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"
+    });
+  }
+});
+
+// src/schemas/artifacts.ts
+import { z as z4 } from "zod";
+var BranchEntrySchema = z4.object({
+  repo: z4.string().min(1),
+  name: z4.string().min(1),
+  note: z4.string().optional()
+});
+var StashEntrySchema = z4.object({
+  repo: z4.string().min(1),
+  label: z4.string().min(1),
+  sha: z4.string().optional()
+});
+var ArtifactsSchema = z4.object({
+  branches: z4.array(BranchEntrySchema).default([]),
+  stashes: z4.array(StashEntrySchema).default([])
+});
+
+// src/utils/yaml-io.ts
+import { promises as fs2 } from "fs";
+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/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 fs2.readFile(filePath, "utf8");
+  let parsed;
+  try {
+    parsed = YAML.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 = YAML.stringify(result.data);
+  await atomicWrite(filePath, yaml);
+}
+
+// src/utils/git-gh.ts
+import { spawn } from "child_process";
+import path3 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 path3.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/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/bootstrap/prompt.ts
+import YAML2 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_DAY = MS_PER_HOUR * 24;
+var FRONTMATTER_DELIM = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+async function readMarkdownWithSchema(filePath, schema) {
+  const raw = await fs3.readFile(filePath, "utf8");
+  const match = FRONTMATTER_DELIM.exec(raw);
+  let frontmatterText = "";
+  let body = raw;
+  if (match) {
+    frontmatterText = match[1] ?? "";
+    body = match[2] ?? "";
+  }
+  const parsed = frontmatterText ? YAML2.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 };
+}
+async function loadCanonicalSessions(initiativeDir) {
+  const sessionsDir = path4.join(initiativeDir, "sessions");
+  let entries;
+  try {
+    entries = await fs3.readdir(sessionsDir);
+  } catch {
+    return [];
+  }
+  const mdFiles = entries.filter((n) => n.endsWith(".md"));
+  const loaded = [];
+  for (const filename of mdFiles) {
+    const fullPath = path4.join(sessionsDir, filename);
+    try {
+      const { frontmatter, body } = await readMarkdownWithSchema(
+        fullPath,
+        SessionFrontmatterSchema
+      );
+      if (frontmatter.track === "canonical") {
+        loaded.push({ filename, frontmatter, body });
+      }
+    } catch {
+    }
+  }
+  loaded.sort(
+    (a, b) => new Date(b.frontmatter.ended).getTime() - new Date(a.frontmatter.ended).getTime()
+  );
+  return loaded;
+}
+async function loadTasks(initiativeDir) {
+  const tasksDir = path4.join(initiativeDir, "tasks");
+  let entries;
+  try {
+    entries = await fs3.readdir(tasksDir);
+  } catch {
+    return [];
+  }
+  const ymlFiles = entries.filter(
+    (n) => n.endsWith(".yml") || n.endsWith(".yaml")
+  );
+  const tasks = [];
+  for (const filename of ymlFiles) {
+    const fullPath = path4.join(tasksDir, filename);
+    try {
+      tasks.push(await readYaml(fullPath, TaskSchema));
+    } catch {
+    }
+  }
+  return tasks;
+}
+async function loadArtifacts(initiativeDir) {
+  const artifactsPath = path4.join(initiativeDir, "artifacts.yml");
+  try {
+    return await readYaml(artifactsPath, ArtifactsSchema);
+  } catch {
+    return { branches: [], stashes: [] };
+  }
+}
+function truncateLines(body, max) {
+  const lines = body.split("\n");
+  const trimmed = [];
+  let count = 0;
+  for (const line of lines) {
+    if (count >= max) break;
+    trimmed.push(line);
+    if (line.trim().length > 0) count++;
+  }
+  return trimmed.join("\n").replace(/\s+$/, "");
+}
+function formatTimeSince(from, now) {
+  const diffMs = now.getTime() - from.getTime();
+  if (diffMs < MS_PER_HOUR) return "just now";
+  if (diffMs < MS_PER_DAY) {
+    const hours = Math.floor(diffMs / MS_PER_HOUR);
+    return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  }
+  const days = Math.floor(diffMs / MS_PER_DAY);
+  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 firstLine(text) {
+  if (!text) return void 0;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length > 0) return trimmed;
+  }
+  return void 0;
+}
+function renderTaskLine(idx, task) {
+  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 note = firstLine(task.notes);
+  if (note) line += `
+   ${note}`;
+  return line;
+}
+function renderTopTasks(tasks, topN) {
+  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)).join("\n"),
+    count: openTasks.length
+  };
+}
+function renderRecentlyDone(tasks, windowDays, now) {
+  const cutoff = now.getTime() - windowDays * MS_PER_DAY;
+  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 body = done.map((t) => `- [${t.id}] ${t.title} \u2014 done ${t.done_at}`).join("\n");
+  return { body, count: done.length };
+}
+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.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}`;
+  return line;
+}
+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) {
+  const sections = [];
+  if (artifacts.branches.length > 0) {
+    const branchLines = artifacts.branches.map(renderStaticBranchLine).join("\n");
+    sections.push(`Branches:
+${branchLines}`);
+  }
+  const stashBody = renderStashes(artifacts);
+  if (stashBody) sections.push(`Stashes:
+${stashBody}`);
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}
+function renderLiveArtifacts(artifacts, statuses) {
+  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 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 exists = await git("git", [
+        "-C",
+        repoPath,
+        "rev-parse",
+        "--verify",
+        `refs/heads/${branch.name}`
+      ]);
+      out.present = exists.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);
+}
+async function loadBrief(initiativeDir, slug) {
+  const briefPath = path4.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
+  } = input;
+  const initiativeDir = path4.join(activeRoot, slug);
+  const { frontmatter: brief, body: briefBody } = await loadBrief(
+    initiativeDir,
+    slug
+  );
+  const [sessions, tasks, artifacts] = await Promise.all([
+    loadCanonicalSessions(initiativeDir),
+    loadTasks(initiativeDir),
+    loadArtifacts(initiativeDir)
+  ]);
+  const latestSession = sessions[0];
+  const briefExcerpt = truncateLines(briefBody, BRIEF_BODY_MAX_LINES) || "_(no brief body)_";
+  const { body: tasksBody, count: openTaskCount } = renderTopTasks(tasks, topNTasks);
+  const { body: recentlyDoneBody, count: recentlyDoneCount } = renderRecentlyDone(
+    tasks,
+    recentlyDoneDays,
+    now
+  );
+  let artifactsBody = null;
+  if (!includeLiveStatus || artifacts.branches.length === 0) {
+    artifactsBody = renderStaticArtifacts(artifacts);
+  } else {
+    const fetcher = liveStatusFetcher ?? defaultLiveStatusFetcher;
+    try {
+      const statuses = await fetcher(artifacts.branches);
+      artifactsBody = renderLiveArtifacts(artifacts, statuses);
+    } catch {
+      artifactsBody = renderStaticArtifacts(artifacts);
+    }
+  }
+  const timeSinceHuman = latestSession ? formatTimeSince(new Date(latestSession.frontmatter.ended), now) : void 0;
+  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}).`
+  );
+  sections.push(`# Why we're doing this
+${briefExcerpt}`);
+  if (latestSession) {
+    const sessionExcerpt = truncateLines(latestSession.body, SESSION_BODY_MAX_LINES) || "_(empty session body)_";
+    const ended = endedDate(latestSession.frontmatter.ended);
+    sections.push(
+      `# Last session (${ended}, ${latestSession.frontmatter.session_id}) \u2014 ${timeSinceHuman}
+${sessionExcerpt}`
+    );
+  } else {
+    sections.push(`# Last session
+No previous sessions recorded.`);
+  }
+  sections.push(`# Tasks (top ${topNTasks} open by priority)
+${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(", ")}`
+    );
+  }
+  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 session record\`.` : `Work the top task unless redirected. Update tasks via \`active-work task done\` and capture the session via \`active-work session record\` when wrapping up.`
+  );
+  const prompt = sections.join("\n\n") + "\n";
+  const metadata = {
+    slug,
+    brief_title: brief.title,
+    open_task_count: openTaskCount,
+    recently_done_count: recentlyDoneCount,
+    bootstrap_at: bootstrapAt
+  };
+  if (latestSession) {
+    metadata.last_session = {
+      filename: latestSession.filename,
+      ended: latestSession.frontmatter.ended
+    };
+  }
+  if (timeSinceHuman) {
+    metadata.time_since_last_session_human = timeSinceHuman;
+  }
+  return { prompt, metadata };
+}
+
+// src/bootstrap/archive-tasks.ts
+import { promises as fsp } from "fs";
+import path5 from "path";
+var MS_PER_DAY2 = 864e5;
+async function archiveStaleTasks(initiativeDir, opts) {
+  if (!(opts.retentionDays > 0)) return [];
+  const tasksDir = path5.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_DAY2;
+  const archiveDir = path5.join(tasksDir, "archive");
+  const archived = [];
+  for (const filename of ymlFiles) {
+    const fullPath = path5.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, path5.join(archiveDir, filename));
+      archived.push(id);
+    } catch {
+    }
+  }
+  return archived.sort();
+}
+
+// src/commands/_open-helpers.ts
+import { promises as fs4 } from "fs";
+import path6 from "path";
+async function listInitiativeSlugs(activeRoot) {
+  let entries;
+  try {
+    entries = await fs4.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 = path6.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path6.isAbsolute(rel);
+}
+async function canonicalize(p) {
+  try {
+    return await fs4.realpath(p);
+  } catch {
+    return path6.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 = path6.join(activeRoot, slug, "brief.md");
+    let brief;
+    try {
+      ({ frontmatter: brief } = await readMarkdownWithSchema(
+        briefPath,
+        BriefFrontmatterSchema
+      ));
+    } catch {
+      continue;
+    }
+    for (const entry of Object.values(brief.worktrees ?? {})) {
+      const displayPath = expandTilde(entry.path);
+      if (!path6.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 ArgsSchema = z5.object({
+  slug: z5.string().min(1).optional(),
+  offline: z5.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: z5.string().min(1).optional(),
+  // Force the picker even when the cwd matches an initiative's worktree.
+  pick: z5.boolean().optional(),
+  // Frame the bootstrap prompt as ad-hoc work related to the workstream rather
+  // than a continuation of its handoff / top task.
+  adhoc: z5.boolean().optional()
+});
+var InitiativeSummarySchema = z5.object({
+  slug: z5.string(),
+  title: z5.string(),
+  state: z5.enum(["focused", "backburner", "paused", "done"]),
+  rank: z5.number().int().positive().optional()
+});
+var PickerResultSchema = z5.object({
+  picker: z5.literal(true),
+  initiatives: z5.array(InitiativeSummarySchema)
+});
+var OpenResultSchema = z5.object({
+  slug: z5.string(),
+  prompt: z5.string(),
+  cwd_hint: z5.string(),
+  channels: z5.array(z5.string()).optional(),
+  metadata: z5.object({
+    slug: z5.string(),
+    brief_title: z5.string(),
+    last_session: z5.object({ filename: z5.string(), ended: z5.string() }).optional(),
+    time_since_last_session_human: z5.string().optional(),
+    open_task_count: z5.number().int().nonnegative(),
+    recently_done_count: z5.number().int().nonnegative(),
+    bootstrap_at: z5.string()
+  }),
+  // 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: z5.enum(["slug", "cwd"]).optional()
+});
+var ResultSchema = z5.union([OpenResultSchema, PickerResultSchema]);
+var STATE_ORDER = {
+  focused: 0,
+  backburner: 1,
+  paused: 2,
+  done: 3
+};
+async function loadInitiativeSummary(activeRoot, slug) {
+  const briefPath = path7.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;
+}
+function resolveCwdHint(activeRoot, slug, brief) {
+  const worktrees = brief.worktrees ?? {};
+  for (const entry of Object.values(worktrees)) {
+    if (entry.default) return expandTilde(entry.path);
+  }
+  const entries = Object.values(worktrees);
+  if (entries.length === 1) return expandTilde(entries[0].path);
+  return path7.join(activeRoot, slug);
+}
+async function bootstrapInitiative(activeRoot, slug, opts) {
+  const briefPath = path7.join(activeRoot, slug, "brief.md");
+  const { frontmatter: brief } = await readMarkdownWithSchema(
+    briefPath,
+    BriefFrontmatterSchema
+  );
+  const cwdHint = opts.cwdHintOverride ?? resolveCwdHint(activeRoot, slug, brief);
+  const archivedTaskIds = await archiveStaleTasks(
+    path7.join(activeRoot, slug),
+    { retentionDays: ARCHIVE_DONE_AFTER_DAYS, now: /* @__PURE__ */ new Date() }
+  );
+  const { prompt, metadata } = await assembleBootstrap({
+    activeRoot,
+    slug,
+    includeLiveStatus: !opts.offline,
+    archivedTaskIds,
+    adhoc: opts.adhoc
+  });
+  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: ArgsSchema,
+  result: ResultSchema,
+  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."
+      }
+    },
+    usage: "active-work open [slug] [--offline] [--cwd <dir>] [--pick] [--adhoc]"
+  },
+  async run(args, ctx) {
+    const activeRoot = ctx.activeRoot ?? getActiveRoot();
+    if (args.slug) {
+      const slug = await resolveSlug(activeRoot, args.slug);
+      return bootstrapInitiative(activeRoot, slug, {
+        offline: args.offline,
+        resolvedFrom: "slug",
+        adhoc: args.adhoc
+      });
+    }
+    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
+        });
+      }
+    }
+    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 {
+  BriefFrontmatterSchema,
+  expandTilde,
+  getActiveRoot,
+  getStateRoot,
+  getConfigRoot,
+  getInitiativeDir,
+  getLockPath,
+  defineCommand,
+  successEnvelope,
+  errorEnvelope,
+  registry,
+  register,
+  TaskSchema,
+  SessionFrontmatterSchema,
+  ArtifactsSchema,
+  atomicWrite,
+  withFileLock,
+  coerceDates,
+  readYaml,
+  writeYaml,
+  getGitRunner,
+  getGhRunner,
+  resolveLocalRepoPath,
+  resolveOrgRepo,
+  today,
+  nowIso,
+  EXIT,
+  ActiveWorkError,
+  ValidationError,
+  NotFoundError,
+  UsageError,
+  DaemonError,
+  ConfigError,
+  formatError,
+  assembleBootstrap,
+  resolveSlug,
+  resolveSlugFromCwd,
+  open_default,
+  color
+};
+//# sourceMappingURL=chunk-OET6AFME.js.map