@rucher/carnet 0.0.0-stage → 0.1.0

package/dist/resume-Daotqfdq.mjs

@@ -0,0 +1,985 @@
+import { DatabaseSync } from "node:sqlite";
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { homedir } from "node:os";
+// src/context.ts
+function nowIso(ctx) {
+	return ctx.now().toISOString();
+}
+// src/errors.ts
+var CarnetError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "CarnetError";
+	}
+};
+// src/events.ts
+const EVENT_TYPES = [
+	"started",
+	"finished",
+	"answered",
+	"applied",
+	"tested",
+	"committed",
+	"dropped"
+];
+function isEventType(value) {
+	return typeof value === "string" && EVENT_TYPES.includes(value);
+}
+function toEvent(row) {
+	return {
+		id: row.id,
+		session: row.session,
+		at: row.at,
+		type: row.type,
+		agent: row.agent,
+		commit: row.commit_sha,
+		link: row.link,
+		note: row.note
+	};
+}
+function logEvent(ctx, session, input) {
+	if (!isEventType(input.type)) throw new CarnetError("INVALID_EVENT_TYPE", `Unknown event type "${String(input.type)}"`);
+	const result = ctx.db.prepare("INSERT INTO events (session, at, type, agent, commit_sha, link, note) VALUES (?, ?, ?, ?, ?, ?, ?)").run(session, nowIso(ctx), input.type, input.agent ?? null, input.commit ?? null, input.link ?? null, input.note ?? null);
+	return toEvent(ctx.db.prepare("SELECT * FROM events WHERE id = ?").get(result.lastInsertRowid));
+}
+function readEvents(ctx, { session, limit = 20 }) {
+	return ctx.db.prepare(`SELECT * FROM (SELECT * FROM events WHERE session = ? ORDER BY id DESC LIMIT ?) ORDER BY id ASC`).all(session, limit).map(toEvent);
+}
+// src/status/model.ts
+const AGENT_STATUSES = [
+	"running",
+	"discussing",
+	"answer",
+	"review",
+	"apply",
+	"test",
+	"commit",
+	"branch",
+	"closed"
+];
+const USER_ACTION_STATUSES = [
+	"discussing",
+	"answer",
+	"review",
+	"apply",
+	"test",
+	"commit",
+	"branch"
+];
+const EMOJI = {
+	running: "⏳",
+	discussing: "💬",
+	answer: "❓",
+	review: "👀",
+	apply: "📥",
+	test: "🧪",
+	commit: "✅",
+	branch: "🌿"
+};
+const MAIN_WORKING_EMOJI = "⚙️";
+const LEGEND = "⚙️ main working · 💬 discussing · ❓ answer · 👀 review · 📥 apply · 🧪 test · ✅ commit · 🌿 branch · ⏳ running";
+function isAgentStatus(value) {
+	return typeof value === "string" && AGENT_STATUSES.includes(value);
+}
+function isUserActionStatus(value) {
+	return typeof value === "string" && USER_ACTION_STATUSES.includes(value);
+}
+const OPEN_AGENT_STATUSES = ["running", ...USER_ACTION_STATUSES];
+// src/status/note.ts
+const NOTE_MAX = 60;
+const PATH_PREFIX = /^(\/|\.\.?\/|~\/)/;
+const FILE_AFTER_SLASH = /\/[^/\s]+\.[A-Za-z0-9]+$/;
+function looksLikePath(token) {
+	if (PATH_PREFIX.test(token)) return true;
+	const slashes = token.split("/").length - 1;
+	return slashes >= 2 || slashes === 1 && FILE_AFTER_SLASH.test(token);
+}
+function sanitizeNote(text) {
+	const cleaned = text.replaceAll("`", "").split(/\s+/).filter((token) => token && !looksLikePath(token)).join(" ").trim();
+	if (cleaned.length <= 60) return cleaned;
+	return `${cleaned.slice(0, 59).trimEnd()}…`;
+}
+// src/agents.ts
+function toAgent(row) {
+	return {
+		session: row.session,
+		name: row.name,
+		task: row.task,
+		status: row.status,
+		note: row.note,
+		reportPath: row.report_path,
+		baseCommit: row.base_commit,
+		worktree: row.worktree,
+		queueOrder: row.queue_order,
+		hostAgentId: row.host_agent_id,
+		pendingStatus: row.pending_status,
+		doneAt: row.done_at,
+		startedAt: row.started_at,
+		updatedAt: row.updated_at
+	};
+}
+const REPORTING_NOTE = "reporting";
+const PUBLISH_FALLBACK_MILLISECONDS = 12e4;
+function publishPending(ctx, session, name) {
+	const row = ctx.db.prepare("SELECT pending_status, report_path FROM agents WHERE session = ? AND name = ?").get(session, name);
+	if (!row?.pending_status) return;
+	ctx.db.prepare("UPDATE agents SET status = pending_status, pending_status = NULL, note = NULL, updated_at = ? WHERE session = ? AND name = ?").run(nowIso(ctx), session, name);
+	logEvent(ctx, session, {
+		type: "finished",
+		agent: name,
+		link: row.report_path ?? void 0
+	});
+}
+function publishOverdue(ctx, session) {
+	const before = (/* @__PURE__ */ new Date(ctx.now().getTime() - PUBLISH_FALLBACK_MILLISECONDS)).toISOString();
+	const rows = ctx.db.prepare("SELECT name FROM agents WHERE session = ? AND pending_status IS NOT NULL AND done_at <= ?").all(session, before);
+	for (const row of rows) publishPending(ctx, session, row.name);
+}
+function getAgent(ctx, session, name) {
+	publishOverdue(ctx, session);
+	const row = ctx.db.prepare("SELECT * FROM agents WHERE session = ? AND name = ?").get(session, name);
+	return row && toAgent(row);
+}
+function requireAgent(ctx, session, name) {
+	const agent = getAgent(ctx, session, name);
+	if (!agent) throw new CarnetError("AGENT_NOT_FOUND", `No agent "${name}" in this session`);
+	return agent;
+}
+function startAgent(ctx, session, input) {
+	const name = sanitizeNote(input.name);
+	const existing = getAgent(ctx, session, name);
+	if (existing && existing.status !== "closed") throw new CarnetError("AGENT_EXISTS", `Agent "${name}" is already open in this session`);
+	if (existing) ctx.db.prepare("DELETE FROM agents WHERE session = ? AND name = ?").run(session, name);
+	const at = nowIso(ctx);
+	ctx.db.prepare(`INSERT INTO agents (session, name, task, status, base_commit, worktree, started_at, updated_at)
+       VALUES (?, ?, ?, 'running', ?, ?, ?, ?)`).run(session, name, input.task, input.baseCommit ?? null, input.worktree ?? null, at, at);
+	logEvent(ctx, session, {
+		type: "started",
+		agent: name,
+		note: input.task
+	});
+	return requireAgent(ctx, session, name);
+}
+function updateAgent(ctx, session, name, input) {
+	const current = requireAgent(ctx, session, name);
+	if (!isAgentStatus(input.status) || input.status === "closed") throw new CarnetError("INVALID_STATUS", `Invalid agent status "${input.status}"; use agent_drop to close`);
+	const note = input.note === void 0 ? null : sanitizeNote(input.note);
+	if (current.pendingStatus) publishPending(ctx, session, name);
+	ctx.db.prepare("UPDATE agents SET note = COALESCE(?, CASE WHEN status = 'running' AND ? <> 'running' THEN NULL ELSE note END), status = ?, report_path = COALESCE(?, report_path), updated_at = ? WHERE session = ? AND name = ?").run(note, input.status, input.status, input.reportPath ?? null, nowIso(ctx), session, name);
+	return requireAgent(ctx, session, name);
+}
+function finishAgent(ctx, session, name, input) {
+	const agent = requireAgent(ctx, session, name);
+	const status = input.hasQuestions ? "answer" : "review";
+	const at = nowIso(ctx);
+	ctx.db.prepare("UPDATE agents SET pending_status = ?, note = ?, report_path = ?, done_at = ?, updated_at = ? WHERE session = ? AND name = ?").run(status, REPORTING_NOTE, input.reportPath, at, at, session, name);
+	if (!agent.hostAgentId) publishPending(ctx, session, name);
+	return requireAgent(ctx, session, name);
+}
+function dropAgent(ctx, session, name, reason) {
+	requireAgent(ctx, session, name);
+	ctx.db.prepare("UPDATE agents SET status = 'closed', queue_order = NULL, updated_at = ? WHERE session = ? AND name = ?").run(nowIso(ctx), session, name);
+	logEvent(ctx, session, {
+		type: "dropped",
+		agent: name,
+		note: reason
+	});
+	return requireAgent(ctx, session, name);
+}
+function listAgents(ctx, session, options = {}) {
+	publishOverdue(ctx, session);
+	const where = options.includeClosed ? "" : "AND status != 'closed'";
+	return ctx.db.prepare(`SELECT * FROM agents WHERE session = ? ${where} ORDER BY started_at ASC, name ASC`).all(session).map(toAgent);
+}
+function reorderQueue(ctx, session, names) {
+	const at = nowIso(ctx);
+	ctx.db.prepare("UPDATE agents SET queue_order = NULL WHERE session = ?").run(session);
+	const update = ctx.db.prepare("UPDATE agents SET queue_order = ?, updated_at = ? WHERE session = ? AND name = ?");
+	names.forEach((name, index) => {
+		update.run(index + 1, at, session, sanitizeNote(name));
+	});
+	return listAgents(ctx, session);
+}
+// src/db/schema.ts
+const migrations = [
+	`
+CREATE TABLE sessions (
+  id TEXT PRIMARY KEY,
+  name TEXT UNIQUE,
+  purpose TEXT,
+  status TEXT NOT NULL DEFAULT 'temporary'
+    CHECK (status IN ('temporary', 'active', 'dropped')),
+  cwd TEXT,
+  repo TEXT,
+  claude_pid INTEGER,
+  created_at TEXT NOT NULL,
+  last_active_at TEXT NOT NULL
+);
+
+CREATE TABLE agents (
+  session TEXT NOT NULL REFERENCES sessions(id),
+  name TEXT NOT NULL,
+  task TEXT,
+  status TEXT NOT NULL
+    CHECK (status IN ('running', 'discussing', 'answer', 'review', 'apply', 'test', 'commit', 'branch', 'closed')),
+  note TEXT,
+  report_path TEXT,
+  base_commit TEXT,
+  worktree TEXT,
+  queue_order INTEGER,
+  started_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (session, name)
+);
+
+CREATE TABLE table_items (
+  session TEXT PRIMARY KEY REFERENCES sessions(id),
+  text TEXT NOT NULL,
+  status TEXT,
+  main_working INTEGER NOT NULL DEFAULT 0,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE events (
+  id INTEGER PRIMARY KEY,
+  session TEXT NOT NULL REFERENCES sessions(id),
+  at TEXT NOT NULL,
+  type TEXT NOT NULL
+    CHECK (type IN ('started', 'finished', 'answered', 'applied', 'tested', 'committed', 'dropped')),
+  agent TEXT,
+  commit_sha TEXT,
+  link TEXT,
+  note TEXT
+);
+
+CREATE INDEX events_session_at ON events(session, at);
+CREATE INDEX agents_session_status ON agents(session, status);
+`,
+	`
+ALTER TABLE agents ADD COLUMN claude_agent_id TEXT;
+`,
+	`
+ALTER TABLE sessions ADD COLUMN hooked_at TEXT;
+CREATE INDEX sessions_claude_pid ON sessions(claude_pid, hooked_at);
+`,
+	`
+ALTER TABLE agents ADD COLUMN pending_status TEXT;
+ALTER TABLE agents ADD COLUMN done_at TEXT;
+`,
+	`
+UPDATE sessions SET status = 'active' WHERE status = 'paused';
+`,
+	`
+ALTER TABLE sessions RENAME COLUMN claude_pid TO host_pid;
+ALTER TABLE sessions ADD COLUMN host TEXT NOT NULL DEFAULT 'claude-code';
+ALTER TABLE agents RENAME COLUMN claude_agent_id TO host_agent_id;
+DROP INDEX sessions_claude_pid;
+CREATE INDEX sessions_host_pid ON sessions(host, host_pid, hooked_at);
+`
+];
+function schemaVersion(db) {
+	return db.prepare("PRAGMA user_version").get().user_version;
+}
+function migrate(db) {
+	const current = schemaVersion(db);
+	for (const [version, migration] of migrations.entries()) {
+		if (version < current) continue;
+		db.exec("BEGIN");
+		try {
+			db.exec(migration);
+			db.exec(`PRAGMA user_version = ${version + 1}`);
+			db.exec("COMMIT");
+		} catch (error) {
+			db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+}
+// src/db/open.ts
+const MEMORY_DB = ":memory:";
+function openDatabase(path) {
+	const db = new DatabaseSync(path);
+	if (path !== ":memory:") db.exec("PRAGMA journal_mode = WAL");
+	db.exec("PRAGMA foreign_keys = ON");
+	db.exec("PRAGMA busy_timeout = 5000");
+	migrate(db);
+	return db;
+}
+// src/hosts/claude-code.ts
+const TRANSCRIPT_TAIL_BYTES = 262144;
+const TITLE_PATTERN = /"type":"custom-title","customTitle":("(?:[^"\\]|\\.)*")/g;
+const REPOS_START = "<!-- rucher:repos start -->";
+const REPOS_END = "<!-- rucher:repos end -->";
+function payloadObject(json) {
+	const data = JSON.parse(json);
+	if (typeof data.session_id !== "string" || !data.session_id) throw new TypeError("Hook payload has no session_id");
+	return data;
+}
+function text(data, key) {
+	const value = data[key];
+	return typeof value === "string" ? value : void 0;
+}
+function transcriptTitle(path) {
+	let descriptor;
+	try {
+		descriptor = openSync(path, "r");
+		const size = fstatSync(descriptor).size;
+		const length = Math.min(size, TRANSCRIPT_TAIL_BYTES);
+		const buffer = Buffer.alloc(length);
+		readSync(descriptor, buffer, 0, length, size - length);
+		const last = [...buffer.toString("utf8").matchAll(TITLE_PATTERN)].at(-1)?.[1];
+		return last === void 0 ? void 0 : JSON.parse(last);
+	} catch {
+		return;
+	} finally {
+		if (descriptor !== void 0) closeSync(descriptor);
+	}
+}
+function reposBlock(group) {
+	const repos = group.repos.length ? group.repos.map((repo) => `- \`${basename(repo)}\`: ${repo}`).join("\n") : "- (none yet: `rucher group add <path>`)";
+	return `${REPOS_START}\n## Repos\n\n${repos}\n${REPOS_END}`;
+}
+function replaceReposBlock(content, group) {
+	const start = content.indexOf(REPOS_START);
+	const end = content.indexOf(REPOS_END);
+	if (start === -1 || end === -1 || end < start) return null;
+	return content.slice(0, start) + reposBlock(group) + content.slice(end + 25);
+}
+function groupInstructions(group) {
+	return `# ${group.name}
+
+Meta directory of the ${group.name} group: context only, the repos live at their own paths below and are reachable through \`.claude/settings.json\`. Start Claude Code sessions here.
+
+${reposBlock(group)}
+
+## Multi-agent work
+
+Use the rucher tools (Carnet) for agent statuses and the journal, and the rucher skill for the workflow.
+
+## Shared instructions
+
+(what every session of this group should know)
+`;
+}
+function groupSettings(group) {
+	return `${JSON.stringify({ permissions: { additionalDirectories: group.repos } }, null, 2)}\n`;
+}
+const claudeCode = {
+	id: "claude-code",
+	displayName: "Claude Code",
+	processId(env) {
+		const processId = Number(env.CLAUDE_PID);
+		return Number.isInteger(processId) && processId > 0 ? processId : null;
+	},
+	sessionIdFromEnvironment(env) {
+		return env.CLAUDE_CODE_SESSION_ID || void 0;
+	},
+	projectDirectory(env) {
+		return env.CLAUDE_PROJECT_DIR || void 0;
+	},
+	parseSessionPayload(json) {
+		const data = payloadObject(json);
+		return {
+			session_id: data.session_id,
+			cwd: text(data, "cwd"),
+			source: text(data, "source"),
+			session_title: text(data, "session_title")
+		};
+	},
+	parsePromptPayload(json) {
+		const data = payloadObject(json);
+		return {
+			session_id: data.session_id,
+			cwd: text(data, "cwd"),
+			session_title: text(data, "session_title"),
+			transcript_path: text(data, "transcript_path")
+		};
+	},
+	parseSubagentPayload(json) {
+		const data = payloadObject(json);
+		const agentId = text(data, "agent_id");
+		if (!agentId) throw new TypeError("Hook payload has no agent_id");
+		return {
+			session_id: data.session_id,
+			agent_id: agentId,
+			agent_type: text(data, "agent_type"),
+			cwd: text(data, "cwd")
+		};
+	},
+	promptTitle(payload) {
+		return payload.session_title ?? (payload.transcript_path ? transcriptTitle(payload.transcript_path) : void 0);
+	},
+	resumeCommand(session) {
+		return {
+			command: "claude",
+			args: ["--resume", session.id]
+		};
+	},
+	renameInstruction(name) {
+		return `Ask the human to run /rename ${name} in Claude Code so the titles match.`;
+	},
+	contextFiles: [{
+		path: ".claude/settings.json",
+		sync(group, mode) {
+			const path = join(group.root, ".claude", "settings.json");
+			if (!existsSync(path)) {
+				if (group.repos.length === 0) return "unchanged";
+				mkdirSync(dirname(path), { recursive: true });
+				writeFileSync(path, groupSettings(group));
+				return "written";
+			}
+			const settings = JSON.parse(readFileSync(path, "utf8"));
+			const current = settings.permissions?.additionalDirectories ?? [];
+			const next = mode === "exact" ? group.repos : [...current, ...group.repos.filter((repo) => !current.includes(repo))];
+			if (next.length === current.length && next.every((repo, index) => repo === current[index])) return "unchanged";
+			settings.permissions = {
+				...settings.permissions,
+				additionalDirectories: next
+			};
+			writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`);
+			return "updated";
+		}
+	}, {
+		path: "CLAUDE.md",
+		sync(group) {
+			const path = join(group.root, "CLAUDE.md");
+			if (!existsSync(path)) {
+				writeFileSync(path, groupInstructions(group));
+				return "written";
+			}
+			const content = readFileSync(path, "utf8");
+			const next = replaceReposBlock(content, group);
+			if (next === null) return "no-markers";
+			if (next === content) return "unchanged";
+			writeFileSync(path, next);
+			return "updated";
+		}
+	}]
+};
+// src/hosts/host.ts
+const DEFAULT_HOST = "claude-code";
+const HOSTS = { [claudeCode.id]: claudeCode };
+function allHosts() {
+	return Object.values(HOSTS);
+}
+function hostById(id) {
+	const host = HOSTS[id];
+	if (!host) throw new CarnetError("UNKNOWN_HOST", `Unknown host "${id}" (available: ${Object.keys(HOSTS).join(", ")})`);
+	return host;
+}
+// src/group/registry.ts
+function rucherHome(env = process.env) {
+	return env.RUCHER_HOME ?? join(homedir(), ".rucher");
+}
+function registryPath(env) {
+	return join(rucherHome(env), "groups.json");
+}
+function readRegistry(env) {
+	const file = registryPath(env);
+	if (!existsSync(file)) return [];
+	return JSON.parse(readFileSync(file, "utf8")).groups ?? [];
+}
+function writeRegistry(groups, env) {
+	groups.sort((left, right) => left.name.localeCompare(right.name) || left.path.localeCompare(right.path));
+	mkdirSync(rucherHome(env), { recursive: true });
+	writeFileSync(registryPath(env), `${JSON.stringify({ groups }, null, 2)}\n`);
+	return groups;
+}
+function registerGroup(reference, env) {
+	return writeRegistry([...readRegistry(env).filter((group) => group.path !== reference.path), reference], env);
+}
+function unregisterGroups(paths, env) {
+	return writeRegistry(readRegistry(env).filter((group) => !paths.includes(group.path)), env);
+}
+// src/group/locate.ts
+const GROUP_DIRECTORY = ".rucher";
+const REPORTS_DIRECTORY = "reports";
+const GROUP_FILE = "group.json";
+const DB_FILE = "carnet.db";
+function isInside(directory, path) {
+	const relativePath = relative(directory, path);
+	return relativePath === "" || !relativePath.startsWith("..") && !resolve(relativePath).startsWith(relativePath);
+}
+function repoNameFor(group, path) {
+	if (!path) return null;
+	const repo = group.repos.find((repo) => isInside(repo, resolve(path)));
+	return repo ? basename(repo) : null;
+}
+function repoPathFor(group, path) {
+	if (!path) return null;
+	const absolutePath = resolve(path);
+	const repo = group.repos.find((candidate) => isInside(candidate, absolutePath));
+	if (!repo) return null;
+	const relativePath = relative(repo, absolutePath);
+	return relativePath ? join(basename(repo), relativePath) : basename(repo);
+}
+function findGroupRoot(from) {
+	let directory = resolve(from);
+	for (;;) {
+		if (isGroupRoot(directory)) return directory;
+		const parent = dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+function reportsDirectoryOf(group) {
+	return join(group.root, GROUP_DIRECTORY, REPORTS_DIRECTORY);
+}
+function reportPathFor(group, agentName) {
+	return join(reportsDirectoryOf(group), `${agentName}.md`);
+}
+function isGroupRoot(directory) {
+	return existsSync(join(directory, GROUP_DIRECTORY, GROUP_FILE));
+}
+function loadGroup(root) {
+	const file = JSON.parse(readFileSync(join(root, GROUP_DIRECTORY, GROUP_FILE), "utf8"));
+	return {
+		root,
+		name: file.name,
+		repos: (file.repos ?? []).map((repo) => resolve(root, repo)),
+		hosts: file.hosts?.length ? file.hosts : [DEFAULT_HOST],
+		dbPath: join(root, GROUP_DIRECTORY, DB_FILE)
+	};
+}
+function groupByRepo(path, env) {
+	for (const reference of readRegistry(env)) {
+		if (!isGroupRoot(reference.path)) continue;
+		const group = loadGroup(reference.path);
+		if (group.repos.some((repo) => isInside(repo, path))) return group;
+	}
+	return null;
+}
+function locateGroup({ cwd = process.cwd(), env = process.env } = {}) {
+	const projectDirectories = allHosts().map((host) => host.projectDirectory(env)).filter((directory) => directory !== void 0);
+	const candidates = [resolve(cwd), ...projectDirectories.map((directory) => resolve(directory))];
+	for (const directory of candidates) {
+		const root = findGroupRoot(directory);
+		if (root) return loadGroup(root);
+	}
+	for (const directory of candidates) {
+		const group = groupByRepo(directory, env);
+		if (group) return group;
+	}
+	throw new CarnetError("NO_GROUP", `No Rucher group for ${cwd}: run "rucher init" in a meta directory, or "rucher group add <this repo>" there`);
+}
+// src/sessions.ts
+const COLUMNS = "id, name, purpose, status, cwd, repo, host, host_pid, hooked_at, created_at, last_active_at";
+function toSession(row) {
+	return {
+		id: row.id,
+		name: row.name,
+		purpose: row.purpose,
+		status: row.status,
+		cwd: row.cwd,
+		repo: row.repo,
+		host: row.host,
+		hostPid: row.host_pid,
+		hookedAt: row.hooked_at,
+		createdAt: row.created_at,
+		lastActiveAt: row.last_active_at
+	};
+}
+function getSession(ctx, id) {
+	const row = ctx.db.prepare(`SELECT ${COLUMNS} FROM sessions WHERE id = ?`).get(id);
+	return row && toSession(row);
+}
+function requireSession(ctx, id) {
+	const session = getSession(ctx, id);
+	if (!session) throw new CarnetError("SESSION_NOT_FOUND", `Unknown session ${id}`);
+	return session;
+}
+function ensureSession(ctx, id, cwd, group) {
+	const existing = getSession(ctx, id);
+	if (existing) return existing;
+	const at = nowIso(ctx);
+	ctx.db.prepare("INSERT INTO sessions (id, status, cwd, repo, created_at, last_active_at) VALUES (?, 'temporary', ?, ?, ?, ?)").run(id, cwd ?? null, group ? repoNameFor(group, cwd) : null, at, at);
+	return requireSession(ctx, id);
+}
+function titleAvailable(ctx, id, title) {
+	const owner = sessionByName(ctx, title);
+	return !owner || owner.id === id;
+}
+function adoptTitle(ctx, id, rawTitle) {
+	const session = requireSession(ctx, id);
+	const title = rawTitle?.trim() || null;
+	if (title === null || title === session.name || !titleAvailable(ctx, id, title)) return session;
+	ctx.db.prepare(`UPDATE sessions
+       SET name = ?, status = CASE WHEN status = 'temporary' THEN 'active' ELSE status END
+       WHERE id = ?`).run(title, id);
+	return requireSession(ctx, id);
+}
+function upsertFromHook(ctx, group, payload, env = {}) {
+	const at = nowIso(ctx);
+	const host = env.host ?? "claude-code";
+	const hostPid = env.processId ?? null;
+	const repo = repoNameFor(group, payload.cwd);
+	const existing = getSession(ctx, payload.session_id);
+	if (!existing) ctx.db.prepare(`INSERT INTO sessions (id, status, cwd, repo, host, host_pid, hooked_at, created_at, last_active_at)
+         VALUES (?, 'temporary', ?, ?, ?, ?, ?, ?, ?)`).run(payload.session_id, payload.cwd ?? null, repo, host, hostPid, at, at, at);
+	else ctx.db.prepare(`UPDATE sessions
+         SET last_active_at = ?, hooked_at = ?, cwd = ?, repo = ?, host = ?, host_pid = ?
+         WHERE id = ?`).run(at, at, payload.cwd ?? existing.cwd, repo ?? existing.repo, host, hostPid ?? existing.hostPid, payload.session_id);
+	return adoptTitle(ctx, payload.session_id, payload.session_title);
+}
+function touchSession(ctx, id) {
+	ctx.db.prepare("UPDATE sessions SET last_active_at = ? WHERE id = ?").run(nowIso(ctx), id);
+}
+function nameSession(ctx, id, name, purpose) {
+	requireSession(ctx, id);
+	try {
+		ctx.db.prepare(`UPDATE sessions
+         SET name = ?, purpose = COALESCE(?, purpose), last_active_at = ?,
+             status = CASE WHEN status = 'temporary' THEN 'active' ELSE status END
+         WHERE id = ?`).run(name, purpose ?? null, nowIso(ctx), id);
+	} catch (error) {
+		if (error instanceof Error && error.message.includes("UNIQUE")) throw new CarnetError("SESSION_NAME_TAKEN", `A session named "${name}" already exists`);
+		throw error;
+	}
+	return requireSession(ctx, id);
+}
+function listSessions(ctx, options = {}) {
+	const excluded = [];
+	if (!options.includeTemporary) excluded.push("temporary");
+	if (!options.includeDropped) excluded.push("dropped");
+	const placeholders = excluded.map(() => "?").join(", ");
+	const where = excluded.length ? `WHERE status NOT IN (${placeholders})` : "";
+	return ctx.db.prepare(`SELECT ${COLUMNS} FROM sessions ${where} ORDER BY last_active_at DESC`).all(...excluded).map(toSession);
+}
+function dropSession(ctx, id) {
+	requireSession(ctx, id);
+	const at = nowIso(ctx);
+	ctx.db.prepare("UPDATE agents SET status = 'closed', updated_at = ? WHERE session = ? AND status != 'closed'").run(at, id);
+	ctx.db.prepare("UPDATE sessions SET status = 'dropped', last_active_at = ? WHERE id = ?").run(at, id);
+	return requireSession(ctx, id);
+}
+function defaultSession(ctx) {
+	const row = ctx.db.prepare(`SELECT ${COLUMNS} FROM sessions WHERE status != 'dropped' ORDER BY last_active_at DESC LIMIT 1`).get();
+	return row && toSession(row);
+}
+function sessionByName(ctx, name) {
+	const row = ctx.db.prepare(`SELECT ${COLUMNS} FROM sessions WHERE name = ?`).get(name);
+	return row && toSession(row);
+}
+const MINIMUM_ID_PREFIX = 4;
+function shortId(id) {
+	return id.slice(0, 8);
+}
+function findSession(ctx, reference) {
+	const byName = sessionByName(ctx, reference);
+	if (byName) return byName;
+	const byId = getSession(ctx, reference);
+	if (byId) return byId;
+	const isIdPrefix = /^[0-9a-f-]+$/i.test(reference);
+	if (isIdPrefix && reference.length >= 4) {
+		const rows = ctx.db.prepare(`SELECT ${COLUMNS} FROM sessions WHERE id LIKE ? ORDER BY last_active_at DESC`).all(`${reference.toLowerCase()}%`);
+		const [only, ...others] = rows;
+		if (only && others.length === 0) return toSession(only);
+		if (only) throw new CarnetError("SESSION_AMBIGUOUS", `Session id "${reference}" matches several sessions: ${rows.map((row) => shortId(row.id)).join(", ")}`);
+	}
+	throw new CarnetError("SESSION_NOT_FOUND", `Unknown session "${reference}"${isIdPrefix && reference.length < 4 ? ` (an id prefix needs at least 4 characters)` : ""}`);
+}
+function sessionByHostProcess(ctx, host, processId) {
+	const row = ctx.db.prepare(`SELECT ${COLUMNS} FROM sessions
+       WHERE host = ? AND host_pid = ? AND hooked_at IS NOT NULL
+       ORDER BY hooked_at DESC LIMIT 1`).get(host, processId);
+	return row && toSession(row);
+}
+// src/merge.ts
+function namesOf(ctx, session) {
+	return ctx.db.prepare("SELECT name FROM agents WHERE session = ?").all(session).map((row) => row.name);
+}
+function mergeSessions(ctx, fromId, intoId) {
+	if (fromId === intoId) throw new CarnetError("SESSION_MERGE_INVALID", "Cannot merge a session into itself");
+	const from = requireSession(ctx, fromId);
+	const into = requireSession(ctx, intoId);
+	const at = nowIso(ctx);
+	const taken = new Set(namesOf(ctx, intoId));
+	const fromNames = namesOf(ctx, fromId);
+	const movedAgents = fromNames.filter((name) => !taken.has(name));
+	const closedAgents = fromNames.filter((name) => taken.has(name));
+	ctx.db.exec("BEGIN");
+	try {
+		const moveAgent = ctx.db.prepare("UPDATE agents SET session = ?, updated_at = ? WHERE session = ? AND name = ?");
+		for (const name of movedAgents) moveAgent.run(intoId, at, fromId, name);
+		ctx.db.prepare("UPDATE agents SET status = 'closed', updated_at = ? WHERE session = ? AND status != 'closed'").run(at, fromId);
+		const movedEvents = Number(ctx.db.prepare("UPDATE events SET session = ? WHERE session = ?").run(intoId, fromId).changes);
+		const movedTable = !(ctx.db.prepare("SELECT 1 FROM table_items WHERE session = ?").get(intoId) !== void 0) && Number(ctx.db.prepare("UPDATE table_items SET session = ? WHERE session = ?").run(intoId, fromId).changes) > 0;
+		ctx.db.prepare("DELETE FROM table_items WHERE session = ?").run(fromId);
+		const keepName = into.name === null && from.name !== null;
+		ctx.db.prepare("UPDATE sessions SET status = 'dropped', name = NULL, last_active_at = ? WHERE id = ?").run(at, fromId);
+		ctx.db.prepare(`UPDATE sessions
+         SET name = COALESCE(?, name), purpose = COALESCE(purpose, ?), last_active_at = ?,
+             status = CASE WHEN ? AND status = 'temporary' THEN 'active' ELSE status END
+         WHERE id = ?`).run(keepName ? from.name : null, from.purpose, at, keepName ? 1 : 0, intoId);
+		ctx.db.exec("COMMIT");
+		return {
+			session: requireSession(ctx, intoId),
+			movedAgents,
+			closedAgents,
+			movedEvents,
+			movedTable
+		};
+	} catch (error) {
+		ctx.db.exec("ROLLBACK");
+		throw error;
+	}
+}
+// src/purge.ts
+const DEFAULT_PURGE_DAYS = 3;
+const DAY_MILLISECONDS = 864e5;
+function purgeDays(value) {
+	const days = Number(value);
+	return Number.isFinite(days) && days > 0 ? days : 3;
+}
+const PURGEABLE = `
+  id != ? AND last_active_at < ?
+  AND NOT EXISTS (SELECT 1 FROM events WHERE events.session = sessions.id)
+  AND (
+    status = 'dropped'
+    OR (status = 'temporary' AND NOT EXISTS (SELECT 1 FROM agents WHERE agents.session = sessions.id))
+  )`;
+function purgeSessions(ctx, keepId, days) {
+	const cutoff = (/* @__PURE__ */ new Date(ctx.now().getTime() - days * DAY_MILLISECONDS)).toISOString();
+	ctx.db.exec("BEGIN");
+	try {
+		const ids = ctx.db.prepare(`SELECT id FROM sessions WHERE ${PURGEABLE}`).all(keepId, cutoff).map((row) => row.id);
+		for (const table of ["table_items", "agents"]) {
+			const statement = ctx.db.prepare(`DELETE FROM ${table} WHERE session = ?`);
+			for (const id of ids) statement.run(id);
+		}
+		const deleteSession = ctx.db.prepare("DELETE FROM sessions WHERE id = ?");
+		for (const id of ids) deleteSession.run(id);
+		ctx.db.exec("COMMIT");
+		return ids;
+	} catch (error) {
+		ctx.db.exec("ROLLBACK");
+		throw error;
+	}
+}
+// src/status/render.ts
+const MAIN_WORKING_SUFFIX = "(main working, not ready)";
+function renderTableLine(item) {
+	if (item.mainWorking) return `${MAIN_WORKING_EMOJI} ${item.text} ${MAIN_WORKING_SUFFIX}`;
+	return `${EMOJI[item.status ?? "discussing"]} ${item.text}`;
+}
+function renderAgentLine(line) {
+	return line.note ? `${line.emoji} ${line.name} — ${line.note}` : `${line.emoji} ${line.name}`;
+}
+function renderSections(view) {
+	const out = [];
+	if (view.table) out.push("On the table", `  ${renderTableLine(view.table)}`, "");
+	out.push("Waiting on you");
+	if (view.waiting.length === 0) out.push("  nothing");
+	view.waiting.forEach((line, index) => {
+		out.push(`  ${index + 1}. ${renderAgentLine(line)}`);
+	});
+	out.push("", "Running");
+	if (view.running.length === 0) out.push("  nothing");
+	for (const line of view.running) out.push(`  ${renderAgentLine(line)}`);
+	return out.join("\n");
+}
+function renderStatus(view) {
+	return [
+		view.time,
+		"",
+		renderSections(view),
+		"",
+		LEGEND
+	].join("\n");
+}
+// src/table.ts
+function toItem(row) {
+	return {
+		session: row.session,
+		text: row.text,
+		status: row.status,
+		mainWorking: row.main_working === 1,
+		updatedAt: row.updated_at
+	};
+}
+function getTable(ctx, session) {
+	const row = ctx.db.prepare("SELECT * FROM table_items WHERE session = ?").get(session);
+	return row && toItem(row);
+}
+function setTable(ctx, session, input) {
+	if (input.mainWorking && input.status) throw new CarnetError("TABLE_STATUS_WITH_MAIN_WORKING", "A user-action status cannot be set while main is working");
+	if (input.status !== void 0 && !isUserActionStatus(input.status)) throw new CarnetError("INVALID_STATUS", `Invalid table status "${String(input.status)}"`);
+	ctx.db.prepare(`INSERT INTO table_items (session, text, status, main_working, updated_at) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(session) DO UPDATE SET text = excluded.text, status = excluded.status,
+         main_working = excluded.main_working, updated_at = excluded.updated_at`).run(session, sanitizeNote(input.text), input.status ?? null, input.mainWorking ? 1 : 0, nowIso(ctx));
+	return getTable(ctx, session);
+}
+function clearTable(ctx, session) {
+	ctx.db.prepare("DELETE FROM table_items WHERE session = ?").run(session);
+}
+// src/status/view.ts
+const BUCKET = {
+	answer: 0,
+	review: 1
+};
+function bucketOf(status) {
+	return BUCKET[status] ?? 2;
+}
+function compareWaiting(left, right) {
+	if (left.queueOrder !== null || right.queueOrder !== null) {
+		if (left.queueOrder === null) return 1;
+		if (right.queueOrder === null) return -1;
+		return left.queueOrder - right.queueOrder;
+	}
+	return bucketOf(left.status) - bucketOf(right.status) || left.startedAt.localeCompare(right.startedAt);
+}
+function toLine(agent) {
+	return {
+		name: agent.name,
+		status: agent.status,
+		emoji: agent.status === "closed" ? "" : EMOJI[agent.status],
+		note: agent.note
+	};
+}
+function formatClock(date) {
+	return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+function buildStatusView(ctx, session) {
+	const agents = listAgents(ctx, session.id);
+	const waiting = agents.filter((agent) => isUserActionStatus(agent.status)).sort(compareWaiting).map(toLine);
+	const running = agents.filter((agent) => agent.status === "running").map(toLine);
+	return {
+		time: formatClock(ctx.now()),
+		sessionName: session.name,
+		table: getTable(ctx, session.id) ?? null,
+		waiting,
+		running
+	};
+}
+// src/subagents.ts
+const PAIRING_WINDOW_MILLISECONDS = 6e4;
+const STOPPED_NOTE = "stopped without agent_done";
+function byHostAgentId(ctx, session, hostAgentId) {
+	const row = ctx.db.prepare("SELECT * FROM agents WHERE session = ? AND host_agent_id = ?").get(session, hostAgentId);
+	return row && toAgent(row);
+}
+function pairSubagent(ctx, session, hostAgentId) {
+	const paired = byHostAgentId(ctx, session, hostAgentId);
+	if (paired) return paired;
+	const since = (/* @__PURE__ */ new Date(ctx.now().getTime() - PAIRING_WINDOW_MILLISECONDS)).toISOString();
+	const row = ctx.db.prepare(`SELECT * FROM agents
+       WHERE session = ? AND status = 'running' AND host_agent_id IS NULL AND started_at >= ?
+       ORDER BY started_at ASC, rowid ASC LIMIT 1`).get(session, since);
+	if (!row) return void 0;
+	ctx.db.prepare("UPDATE agents SET host_agent_id = ? WHERE session = ? AND name = ?").run(hostAgentId, session, row.name);
+	return byHostAgentId(ctx, session, hostAgentId);
+}
+function stopSubagent(ctx, session, hostAgentId) {
+	const agent = byHostAgentId(ctx, session, hostAgentId);
+	if (!agent || agent.status !== "running") return void 0;
+	if (agent.pendingStatus) {
+		publishPending(ctx, session, agent.name);
+		return byHostAgentId(ctx, session, hostAgentId);
+	}
+	ctx.db.prepare("UPDATE agents SET status = 'review', note = ?, updated_at = ? WHERE session = ? AND name = ?").run(STOPPED_NOTE, nowIso(ctx), session, agent.name);
+	logEvent(ctx, session, {
+		type: "finished",
+		agent: agent.name,
+		note: STOPPED_NOTE
+	});
+	return byHostAgentId(ctx, session, hostAgentId);
+}
+// src/carnet.ts
+var Carnet = class {
+	group;
+	db;
+	ctx;
+	constructor(group, db, options = {}) {
+		this.group = group;
+		this.db = db;
+		this.ctx = {
+			db,
+			now: options.now ?? (() => /* @__PURE__ */ new Date())
+		};
+	}
+	sessions = {
+		get: (id) => getSession(this.ctx, id),
+		find: (reference) => findSession(this.ctx, reference),
+		require: (id) => requireSession(this.ctx, id),
+		ensure: (id, cwd) => ensureSession(this.ctx, id, cwd, this.group),
+		upsertFromHook: (payload, env) => upsertFromHook(this.ctx, this.group, payload, env),
+		touch: (id) => touchSession(this.ctx, id),
+		merge: (fromId, intoId) => mergeSessions(this.ctx, fromId, intoId),
+		purge: (keepId, days) => purgeSessions(this.ctx, keepId, days),
+		name: (id, name, purpose) => nameSession(this.ctx, id, name, purpose),
+		adoptTitle: (id, title) => adoptTitle(this.ctx, id, title),
+		list: (options) => listSessions(this.ctx, options),
+		drop: (id) => dropSession(this.ctx, id),
+		default: () => defaultSession(this.ctx),
+		byName: (name) => sessionByName(this.ctx, name),
+		byHostProcess: (host, processId) => sessionByHostProcess(this.ctx, host, processId)
+	};
+	agents = {
+		get: (session, name) => getAgent(this.ctx, session, name),
+		start: (session, input) => startAgent(this.ctx, session, input),
+		update: (session, name, input) => updateAgent(this.ctx, session, name, input),
+		finish: (session, name, input) => finishAgent(this.ctx, session, name, input),
+		drop: (session, name, reason) => dropAgent(this.ctx, session, name, reason),
+		list: (session, options) => listAgents(this.ctx, session, options),
+		reorderQueue: (session, names) => reorderQueue(this.ctx, session, names),
+		pairSubagent: (session, hostAgentId) => pairSubagent(this.ctx, session, hostAgentId),
+		stopSubagent: (session, hostAgentId) => stopSubagent(this.ctx, session, hostAgentId)
+	};
+	table = {
+		get: (session) => getTable(this.ctx, session),
+		set: (session, input) => setTable(this.ctx, session, input),
+		clear: (session) => clearTable(this.ctx, session)
+	};
+	events = {
+		log: (session, input) => logEvent(this.ctx, session, input),
+		read: (session, limit) => readEvents(this.ctx, {
+			session,
+			limit
+		})
+	};
+	status = {
+		view: (session) => buildStatusView(this.ctx, session),
+		render: (session) => renderStatus(buildStatusView(this.ctx, session)),
+		sections: (session) => renderSections(buildStatusView(this.ctx, session))
+	};
+	close() {
+		this.db.close();
+	}
+};
+function openCarnet(options = {}) {
+	const group = locateGroup(options);
+	return new Carnet(group, openDatabase(options.dbPath ?? group.dbPath), options);
+}
+// src/resume.ts
+const RESUME_EVENTS = 20;
+const RESUME_MAX_CHARACTERS = 2e3;
+function formatEventLine(event) {
+	return [
+		formatClock(new Date(event.at)),
+		event.type,
+		event.agent,
+		event.link ?? event.note,
+		event.commit?.slice(0, 7)
+	].filter(Boolean).join("  ");
+}
+function sessionLabel(session) {
+	const name = session.name ?? session.id;
+	return session.purpose ? `${name} (${session.purpose})` : name;
+}
+function resumeContext(carnet, session, { events = 20, maxCharacters = RESUME_MAX_CHARACTERS } = {}) {
+	const head = `Rucher session ${sessionLabel(session)}, state when resumed:\n\n${carnet.status.render(session)}`;
+	const lines = carnet.events.read(session.id, events).map(formatEventLine);
+	const build = () => lines.length ? `${head}\n\nLast events\n${lines.map((line) => `  ${line}`).join("\n")}` : head;
+	let text = build();
+	while (text.length > maxCharacters && lines.length > 0) {
+		lines.shift();
+		text = build();
+	}
+	return text.length > maxCharacters ? `${text.slice(0, maxCharacters - 1)}…` : text;
+}
+export { schemaVersion as $, repoNameFor as A, hostById as B, GROUP_FILE as C, isInside as D, isGroupRoot as E, registerGroup as F, groupSettings as G, REPOS_START as H, rucherHome as I, transcriptTitle as J, replaceReposBlock as K, unregisterGroups as L, reportPathFor as M, reportsDirectoryOf as N, loadGroup as O, readRegistry as P, migrations as Q, DEFAULT_HOST as R, GROUP_DIRECTORY as S, findGroupRoot as T, claudeCode as U, REPOS_END as V, groupInstructions as W, openDatabase as X, MEMORY_DB as Y, migrate as Z, DEFAULT_PURGE_DAYS as _, sessionLabel as a, EMOJI as at, shortId as b, PAIRING_WINDOW_MILLISECONDS as c, OPEN_AGENT_STATUSES as ct, formatClock as d, isUserActionStatus as dt, PUBLISH_FALLBACK_MILLISECONDS as et, MAIN_WORKING_SUFFIX as f, EVENT_TYPES as ft, renderTableLine as g, renderStatus as h, resumeContext as i, AGENT_STATUSES as it, repoPathFor as j, locateGroup as k, STOPPED_NOTE as l, USER_ACTION_STATUSES as lt, renderSections as m, CarnetError as mt, RESUME_MAX_CHARACTERS as n, NOTE_MAX as nt, Carnet as o, LEGEND as ot, renderAgentLine as p, isEventType as pt, reposBlock as q, formatEventLine as r, sanitizeNote as rt, openCarnet as s, MAIN_WORKING_EMOJI as st, RESUME_EVENTS as t, REPORTING_NOTE as tt, buildStatusView as u, isAgentStatus as ut, purgeDays as v, REPORTS_DIRECTORY as w, DB_FILE as x, MINIMUM_ID_PREFIX as y, allHosts as z };
+
+//# sourceMappingURL=resume-Daotqfdq.mjs.map