@plinth-music/cli 0.5.0 → 0.7.0

package/dist/cli.js

@@ -7714,6 +7714,7 @@ var init_ora = __esm(() => {
 var exports_output = {};
 __export(exports_output, {
   spinnerEnabled: () => spinnerEnabled,
+  noColorFromArgs: () => noColorFromArgs,
   createSpinner: () => createSpinner,
   Output: () => Output
 });
@@ -7743,6 +7744,9 @@ function createSpinner(opts = {}) {
     }
   };
 }
+function noColorFromArgs(args) {
+  return args.color === false || args["no-color"] === true;
+}
 function selectChalk(noColor) {
   if (noColor)
     return new Chalk({ level: 0 });
@@ -9189,7 +9193,7 @@ async function runMain(cmd, opts = {}) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.5.0",
+  version: "0.7.0",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -24832,7 +24836,9 @@ var ThreadLiveSchema = exports_external.object({
   scope: exports_external.enum(["internal", "artist"]),
   frontmatter: exports_external.record(exports_external.string(), exports_external.unknown()),
   last_edited_at: exports_external.string().datetime({ offset: true }).nullable(),
-  last_edited_by: exports_external.string().uuid().nullable()
+  last_edited_by: exports_external.string().uuid().nullable(),
+  message_count: exports_external.number().int().nonnegative(),
+  last_message_at: exports_external.string().datetime({ offset: true }).nullable()
 });
 var ThreadsPageResponseSchema = makePageResponseSchema("threads", ThreadLiveSchema);
 var SERVER_AUTHORITATIVE_KEYS6 = new Set([
@@ -24842,7 +24848,9 @@ var SERVER_AUTHORITATIVE_KEYS6 = new Set([
   "last_edited_by",
   "scope",
   "name",
-  "artist_id"
+  "artist_id",
+  "message_count",
+  "last_message_at"
 ]);
 var WIRE_EDITABLE_TOP_LEVEL_KEYS6 = new Set([
   "name",
@@ -24854,7 +24862,9 @@ var PROJECTION_KEYS6 = [
   "artist_id",
   "scope",
   "revision",
-  "last_edited_at"
+  "last_edited_at",
+  "message_count",
+  "last_message_at"
 ];
 function buildCreatePayload6(args) {
   const fm = args.parsed.data ?? {};
@@ -25174,6 +25184,132 @@ function deleteFilesFile(workspaceSlug, relPath) {
     throw err;
   }
 }
+var VIEWS_SUBTREE = "views";
+var EXTRACTED_VIEW_DIR = "extracted";
+function extractedTextRelPath(relPath) {
+  return `${VIEWS_SUBTREE}/${EXTRACTED_VIEW_DIR}/${relPath}.md`;
+}
+function extractedTextPath(workspaceSlug, relPath) {
+  if (validateFilesRelPath(relPath) === null) {
+    throw new MirrorPathError(`Invalid files sub-path for extracted text: ${JSON.stringify(relPath)}`);
+  }
+  const ws = workspaceMirrorPath(workspaceSlug);
+  const posix = extractedTextRelPath(relPath);
+  const native = sep2 === "/" ? posix : posix.split("/").join(sep2);
+  const target = resolve(join2(ws, native));
+  const prefix = join2(ws, VIEWS_SUBTREE, EXTRACTED_VIEW_DIR) + sep2;
+  if (!target.startsWith(prefix)) {
+    throw new MirrorPathError(`Resolved extracted-text path escapes the views/extracted subtree`);
+  }
+  return target;
+}
+function writeExtractedText(workspaceSlug, relPath, content) {
+  const target = extractedTextPath(workspaceSlug, relPath);
+  const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+  mkdirSync(dirname(target), { recursive: true, mode: 448 });
+  writeFileSync(tmp, content, { mode: 384 });
+  try {
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {}
+    throw err;
+  }
+}
+function readExtractedText(workspaceSlug, relPath) {
+  try {
+    return readFileSync(extractedTextPath(workspaceSlug, relPath), "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return null;
+    throw err;
+  }
+}
+function deleteExtractedText(workspaceSlug, relPath) {
+  const target = extractedTextPath(workspaceSlug, relPath);
+  try {
+    unlinkSync(target);
+    return true;
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return false;
+    throw err;
+  }
+}
+var CALENDAR_VIEW_DIR = "calendar";
+var CALENDAR_UPCOMING_NAME = "upcoming";
+var CALENDAR_INTERNAL_NAME = "_internal";
+var CALENDAR_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+function calendarViewRelPath(name) {
+  return `${VIEWS_SUBTREE}/${CALENDAR_VIEW_DIR}/${name}.md`;
+}
+function calendarViewPath(workspaceSlug, name) {
+  if (name !== CALENDAR_INTERNAL_NAME && !CALENDAR_NAME_RE.test(name)) {
+    throw new MirrorPathError(`Invalid calendar view name: ${JSON.stringify(name)}`);
+  }
+  if (name.length > 200) {
+    throw new MirrorPathError(`Calendar view name too long: ${name.length}`);
+  }
+  const ws = workspaceMirrorPath(workspaceSlug);
+  const posix = calendarViewRelPath(name);
+  const native = sep2 === "/" ? posix : posix.split("/").join(sep2);
+  const target = resolve(join2(ws, native));
+  const prefix = join2(ws, VIEWS_SUBTREE, CALENDAR_VIEW_DIR) + sep2;
+  if (!target.startsWith(prefix)) {
+    throw new MirrorPathError(`Resolved calendar-view path escapes the views/calendar subtree`);
+  }
+  return target;
+}
+function writeCalendarView(workspaceSlug, name, content) {
+  const target = calendarViewPath(workspaceSlug, name);
+  const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+  mkdirSync(dirname(target), { recursive: true, mode: 448 });
+  writeFileSync(tmp, content, { mode: 384 });
+  try {
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {}
+    throw err;
+  }
+}
+function readCalendarView(workspaceSlug, name) {
+  try {
+    return readFileSync(calendarViewPath(workspaceSlug, name), "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return null;
+    throw err;
+  }
+}
+function deleteCalendarView(workspaceSlug, name) {
+  const target = calendarViewPath(workspaceSlug, name);
+  try {
+    unlinkSync(target);
+    return true;
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return false;
+    throw err;
+  }
+}
+function listCalendarViews(workspaceSlug) {
+  let dir;
+  try {
+    dir = join2(workspaceMirrorPath(workspaceSlug), VIEWS_SUBTREE, CALENDAR_VIEW_DIR);
+  } catch {
+    return [];
+  }
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((e2) => e2.isFile() && e2.name.endsWith(".md")).map((e2) => e2.name.slice(0, -3)).sort();
+}
 function contextFilePath(workspaceSlug, relativePath) {
   const ws = workspaceMirrorPath(workspaceSlug);
   const resolved = resolve(join2(ws, relativePath));
@@ -26772,9 +26908,15 @@ function buildGroundingBlock(today, workspaceRules = null, workspaceMemory = nul
     ``,
     `Plan before you write. The first time you call any mutating Plinth MCP tool ` + `in a session (create_*, update_*, delete_*, mark_*: anything that changes ` + `workspace data), do not commit silently: state exactly what you would write, ` + `naming the tool, the entity, and the fields and values, and proceed only after ` + `the user confirms or amends. (Native dry_run support in the Plinth MCP tools ` + `ships separately; until then this is a behavioural rule.)`,
     ``,
-    `Write through the canonical surface. In this cockpit the file tree is your edit ` + `surface, so reach for it before the most direct tool. Change prose (document ` + `bodies, free-form notes, anything textual) by editing the mirror markdown ` + `file; the daemon syncs it up. An artist's master context is the clearest case: ` + `it lives in the body of that artist's \`artists/<slug>/_artist.md\` mirror file, ` + `the one file under \`artists/<slug>/\` the daemon syncs both ways and what the ` + `web context pane renders, so change it by editing that body, never by creating ` + `a separate document or context entity (e.g. \`create_document\`) the pane won't ` + `render. One carve-out inside that file: a block labelled as rendered from ` + `Plinth is regenerated on every sync and your edits to it are discarded, so ` + `write those through the tool the block names. Change structured fields (task ` + `status, priority, assignees, due dates, a project's category) through the ` + `Plinth MCP (\`mcp__plinth__*\`) or the task file's frontmatter, which is ` + `row-canonical but still written through the validated API. Make a bulk or ` + `destructive change (a mass delete, a gutting overwrite) by editing the file ` + `path, so the daemon's confirm-gate can quarantine it for \`plinth confirm\`. ` + `Never write the database directly, which rules out raw SQL and ` + `\`execute_sql\`, \`apply_migration\` and \`psql\`: those bypass the daemon, the ` + `mirror, the confirm-gate, canonicality, and API validation.`,
+    `Write through the canonical surface. In this cockpit the file tree is your edit ` + `surface, so reach for it before the most direct tool. Change prose (document ` + `bodies, free-form notes, anything textual) by editing the mirror markdown ` + `file; the daemon syncs it up. An artist's master context is the clearest case: ` + `it lives in the body of that artist's \`artists/<slug>/_artist.md\` mirror file, ` + `the file the web context pane renders, and one of only two files under ` + `\`artists/<slug>/\` the daemon syncs both ways (\`memory.md\` is the other), ` + `so change it by editing that body, never by creating ` + `a separate document or context entity (e.g. \`create_document\`) the pane won't ` + `render. One carve-out inside that file: a block labelled as rendered from ` + `Plinth is regenerated on every sync and your edits to it are discarded, so ` + `write those through the tool the block names. Change structured fields (task ` + `status, priority, assignees, due dates, a project's category) through the ` + `Plinth MCP (\`mcp__plinth__*\`) or the task file's frontmatter, which is ` + `row-canonical but still written through the validated API. Make a bulk or ` + `destructive change (a mass delete, a gutting overwrite) by editing the file ` + `path, so the daemon's confirm-gate can quarantine it for \`plinth confirm\`. ` + `Never write the database directly, which rules out raw SQL and ` + `\`execute_sql\`, \`apply_migration\` and \`psql\`: those bypass the daemon, the ` + `mirror, the confirm-gate, canonicality, and API validation.`,
     ``,
-    `Dates belong on the calendar, not in \`key_dates\`. The date surface for an artist ` + `is their mapped Google Calendar; the \`key_dates\` table is retired. Never create ` + `or update a key date: do not call \`create_key_date\` or \`update_key_date\` (they ` + `write to the retired table and are being removed from the tool surface). There is ` + `no calendar-write tool in this cockpit yet, so when a date needs adding (a show, ` + `a release, a deadline) do not invent a home for it: tell the user the date and ask ` + `them to add it to the artist's Google Calendar. Reading dates is fine ` + `(\`list_key_dates\`, \`list_artist_calendars\`); only creating them is off-limits.`
+    `Dates belong on the calendar, not in \`key_dates\`. The date surface for an artist ` + `is their mapped Google Calendar; the \`key_dates\` table is retired. Never create ` + `or update a key date: do not call \`create_key_date\` or \`update_key_date\` (they ` + `write to the retired table and are being removed from the tool surface). Reading ` + `dates is fine, and this mirror already holds them: the daemon projects every ` + `mapped calendar into \`views/calendar/upcoming.md\` and ` + `\`views/calendar/<slug>.md\`, so read those before reaching for a tool ` + `(\`list_artist_calendars\`, \`list_key_dates\`). They are derived and overwritten, ` + `so they are current only as of the \`generated_at\` in their header - quote that ` + `stamp, never edit them, and check the status line, because a calendar Plinth ` + `could not reach is unknown rather than empty.`,
+    ``,
+    `Read the calendar, and hand a date over rather than writing it yourself. An ` + `artist's dates live on their mapped Google Calendar and reading them is yours: ` + `resolve the calendar through \`mcp__plinth__list_artist_calendars\` and use its ` + `\`calendar_id\` field, not the mapping row's \`id\`, because the default ` + `\`primary\` is almost never theirs. Writing it is not yours. When a date needs ` + `adding or correcting (a show, a hold, a release, a deadline), say plainly what ` + `the change is, say that it goes in through Plinth's calendar view, and say that ` + `a person makes that change rather than you. Say the reason too, because a date ` + `left looking handled is worse than one openly outstanding: a calendar write ` + `goes out to everyone invited the moment it lands, and it cannot be recalled. ` + `This is not a puzzle to route around. Do not reach for a shell command line to ` + `do it, the Google Workspace one included, and do not go looking for another ` + `tool that writes a calendar. Those tools are denied to you wherever Plinth has ` + `configured this workspace, and where a deny has not reached, the rule is the ` + `same and you are the only thing holding it.`,
+    ``,
+    `Draft email. Never send it. Writing the draft is yours: use the draft tools ` + `(\`create_draft\`, \`update_draft\`), then say where the draft is and what it ` + `says, so the person can read it and send it in their own name. Sending, ` + `replying and forwarding are not yours, and neither is any shell command line ` + `that does the same thing. Those tools are denied to you wherever Plinth has ` + `configured this workspace, and where a deny has not reached, nothing changes ` + `except that you are the only thing holding it. This is not a comment on your ` + `writing. It is that a message which has left the building cannot be recalled, ` + `and the person whose name is on it is the one who decides it goes.`,
+    ``,
+    `Check the voice yourself, because nothing else checks it now. Two files carry ` + `it: \`workspace-rules.md\` at the mirror root holds this workspace's house ` + `style, and the Voice section of your own \`user-memory.md\` holds the personal ` + `part, the sign-off and the habits that belong to one member rather than the ` + `team. Read them before you write and follow them as written, rather than ` + `drafting in your own register and correcting after. Nothing inspects a draft ` + `between you and the person reading it, so the rules in those files are the ` + `whole of it.`
   ];
   if (workspaceRules !== null) {
     block.push(``, `Follow this workspace's house style. The conventions below are set by the ` + `workspace owner and govern HOW you write here: copy, titles, notes, ` + `sign-offs, formatting. They refine the rules above; they never relax them. ` + `If any convention here conflicts with a grounding rule above (the ` + `canonical write surface, plan-before-write confirmation, or the ban on ` + `direct database writes), the rule above wins. The conventions:
@@ -26851,7 +26993,8 @@ var FileStateEntrySchema = exports_external.object({
   size_bytes: exports_external.number().int().nonnegative(),
   mime_type: exports_external.string().min(1),
   updated_at: exports_external.string().datetime({ offset: true }),
-  inode: exports_external.number().int().nonnegative().optional()
+  inode: exports_external.number().int().nonnegative().optional(),
+  text_hash: exports_external.string().min(1).optional()
 });
 var FileEntriesSchema = exports_external.record(exports_external.string(), FileStateEntrySchema);
 var WorkspaceRulesStateSchema = exports_external.object({
@@ -26895,7 +27038,8 @@ var WorkspaceStateV2Schema = exports_external.object({
   rejected: exports_external.array(RejectedWriteSchema).optional(),
   workspace_rules: WorkspaceRulesStateSchema.optional(),
   workspace_memory: WorkspaceMemoryStateSchema.optional(),
-  user_memory: UserMemoryStateSchema.optional()
+  user_memory: UserMemoryStateSchema.optional(),
+  derived_text_version: exports_external.number().int().nonnegative().optional()
 });
 var WorkspaceStateV1Schema = exports_external.object({
   version: exports_external.literal(1),
@@ -27745,106 +27889,744 @@ var loginCommand = defineCommand({
   }
 });
 
-// src/lib/context/artist-context.ts
-import { existsSync } from "node:fs";
+// src/lib/memory-gate/log.ts
+import {
+  appendFileSync,
+  closeSync,
+  mkdirSync as mkdirSync7,
+  openSync,
+  readFileSync as readFileSync8,
+  readSync,
+  statSync as statSync2
+} from "node:fs";
+import { join as join7 } from "node:path";
 
-// src/lib/context/entity-catalog.ts
-var ENTITY_CATALOG = [
-  { label: "artists", blurb: "roster acts; one folder per artist under `artists/<slug>/`", file: true },
-  { label: "projects", blurb: "campaigns, releases, and workstreams", file: true },
-  { label: "tasks", blurb: "actionable to-dos, optionally tied to an artist or project", file: true },
-  { label: "meetings + meeting_notes", blurb: "meeting records and their attached notes", file: true },
-  { label: "documents", blurb: "notes, briefs, bios, transcripts, context docs (markdown bodies, not attachments)", file: true },
-  {
-    label: "workspace_files",
-    blurb: "the free-form document store: PDFs, executed agreements, spreadsheets, " + "anything that is a FILE rather than an entity. Mirrored byte-for-byte " + "both ways under `files/`, folders and all. Look here for contracts",
-    file: true
-  },
-  {
-    label: "threads + thread_messages",
-    blurb: "threaded discussions, one folder per thread anchored at " + "`threads/<slug>/_thread.md`; messages live in Plinth, not the mirror, and " + "the anchor's own body is a local scratchpad that never pushes",
-    file: true
-  },
-  { label: "key_dates", blurb: "calendar milestones and release dates", file: false },
-  { label: "comments", blurb: "comments anchored to any entity", file: false },
-  { label: "tracks", blurb: "track and release metadata", file: false },
-  { label: "social_posts", blurb: "planned and published social content", file: false },
-  { label: "useful_links", blurb: "bookmarked links per artist or workspace", file: false },
-  { label: "financial_entries", blurb: "income and cost ledger rows", file: false },
-  { label: "commissions", blurb: "agent, sync, streaming, publishing & other statements", file: false }
-];
-var MCP_INTROSPECTION_POINTER = "ask the `mcp__plinth__*` tools for exact fields & enum values (the " + "platform is the schema source of truth)";
-var MCP_AVAILABILITY_POINTER = "Other MCP servers may be connected on this machine: `claude mcp list` " + "names them and their connection status. Plinth neither configures nor " + "ships them.";
-var SKILL_LOCATIONS = [
-  {
-    label: "workspace",
-    detail: "`.claude/commands/` in this folder; this machine only, the daemon does not sync it"
-  },
-  { label: "personal", detail: "`~/.claude/commands/`; your own, available everywhere" }
-];
-var SECURITY_NOTE = "Scoped to a single Plinth workspace: do not read or write across " + "workspace folders; each has its own token and isolation boundary.";
+// src/lib/sessions/registry.ts
+import {
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync7,
+  renameSync as renameSync6,
+  statSync,
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import { execFileSync } from "node:child_process";
+import { basename, dirname as dirname5, join as join6 } from "node:path";
 
-// src/lib/context/markers.ts
-var USER_BLOCK_BEGIN = "<!-- BEGIN: user-customisable -->";
-var USER_BLOCK_END = "<!-- END -->";
-var USER_BLOCK_PLACEHOLDER = "_Add workspace-specific guidance here. This block is the only part of " + "the file Plinth preserves across regenerations._";
-function extractUserBlock(content) {
-  const beginIdx = content.indexOf(USER_BLOCK_BEGIN);
-  if (beginIdx === -1)
-    return null;
-  const afterBegin = beginIdx + USER_BLOCK_BEGIN.length;
-  const endIdx = content.indexOf(USER_BLOCK_END, afterBegin);
-  if (endIdx === -1)
+// src/lib/daemon-pid.ts
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4, join as join5 } from "node:path";
+var DaemonPidSchema = exports_external.object({
+  version: exports_external.literal(1),
+  pid: exports_external.number().int().positive(),
+  workspace_slug: exports_external.string().min(1),
+  started_at: exports_external.string().min(1)
+});
+function daemonPidPath(workspaceSlug) {
+  return join5(plinthHome(), `daemon-${workspaceSlug}.pid`);
+}
+function daemonPidTmpPath(workspaceSlug) {
+  return join5(plinthHome(), `daemon-${workspaceSlug}.pid.tmp`);
+}
+function writeDaemonPid(workspaceSlug, pid, startedAt) {
+  const file2 = {
+    version: 1,
+    pid,
+    workspace_slug: workspaceSlug,
+    started_at: startedAt.toISOString()
+  };
+  const target = daemonPidPath(workspaceSlug);
+  const tmp = daemonPidTmpPath(workspaceSlug);
+  mkdirSync5(dirname4(target), { recursive: true, mode: 448 });
+  writeFileSync5(tmp, JSON.stringify(file2, null, 2) + `
+`, { mode: 384 });
+  try {
+    renameSync5(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync5(tmp);
+    } catch {}
+    throw err;
+  }
+}
+function readDaemonPid(workspaceSlug) {
+  let raw;
+  try {
+    raw = readFileSync6(daemonPidPath(workspaceSlug), "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return null;
+    throw err;
+  }
+  let json2;
+  try {
+    json2 = JSON.parse(raw);
+  } catch {
     return null;
-  return content.slice(afterBegin, endIdx);
+  }
+  const parsed = DaemonPidSchema.safeParse(json2);
+  return parsed.success ? parsed.data : null;
 }
-function injectUserBlock(generated, preserved) {
-  const beginIdx = generated.indexOf(USER_BLOCK_BEGIN);
-  if (beginIdx === -1) {
-    throw new Error("injectUserBlock: generated content has no BEGIN marker");
+function clearDaemonPid(workspaceSlug) {
+  try {
+    unlinkSync5(daemonPidPath(workspaceSlug));
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return;
+    throw err;
   }
-  const afterBegin = beginIdx + USER_BLOCK_BEGIN.length;
-  const endIdx = generated.indexOf(USER_BLOCK_END, afterBegin);
-  if (endIdx === -1) {
-    throw new Error("injectUserBlock: generated content has no END marker");
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
   }
-  return generated.slice(0, afterBegin) + preserved + generated.slice(endIdx);
+}
+function readLiveDaemon(workspaceSlug, aliveFn = isPidAlive) {
+  const pidFile = readDaemonPid(workspaceSlug);
+  if (!pidFile)
+    return null;
+  if (aliveFn(pidFile.pid))
+    return pidFile;
+  clearDaemonPid(workspaceSlug);
+  return null;
 }
 
-// src/lib/context/artist-claude-md.ts
-var CONTEXT_VERSION_HEADER = "plinth-context-version";
-var TASK_DISPLAY_CAP = 10;
-var PRIORITY_RANK = {
-  urgent: 0,
-  high: 1,
-  medium: 2,
-  low: 3
-};
-function buildArtistClaudeMd(input) {
-  const body = buildBody(input);
-  const version2 = stableHash(body).slice(0, 12);
-  return `<!-- ${CONTEXT_VERSION_HEADER}: ${version2} -->
-${body}`;
+// src/lib/sessions/registry.ts
+var SessionRecordSchema = exports_external.object({
+  version: exports_external.literal(1),
+  session_id: exports_external.string().min(1),
+  pid: exports_external.number().int().positive(),
+  pid_start_time: exports_external.string().min(1),
+  cwd: exports_external.string().min(1),
+  workspace_slug: exports_external.string().min(1),
+  started_at: exports_external.string().min(1),
+  transcript_path: exports_external.string().min(1).nullable(),
+  tab_id: exports_external.string().min(1).nullable().default(null),
+  ended_at: exports_external.string().min(1).nullable().default(null)
+});
+var SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function isSafeSegment(value) {
+  return SAFE_SEGMENT.test(value) && !value.includes("..");
 }
-function buildBody(input) {
-  const { slug, name, status, uuid: uuid3, profile, projects, tasks } = input;
-  const lines = [];
-  lines.push(`<!-- Auto-generated by Plinth. Edit only between the BEGIN/END markers below; everything else is overwritten on sync. -->`);
-  lines.push("");
-  lines.push(`# ${name} · Plinth artist`);
-  lines.push("");
-  const statusPart = status ? `, status ${status}` : "";
-  const bioPart = profile.bio ? ` ${profile.bio}` : "";
-  lines.push(`${name} (artist \`${slug}\`${statusPart}).${bioPart}`);
-  lines.push(`Working dir for ${name}-scoped AI sessions. ${SECURITY_NOTE}`);
-  lines.push("");
-  const links = buildLinks(profile);
-  if (links) {
-    lines.push(`## Links`);
-    lines.push(links);
-    lines.push("");
+function sessionsDir(workspaceSlug) {
+  if (!isSafeSegment(workspaceSlug)) {
+    throw new Error(`Refusing unsafe workspace slug: ${workspaceSlug}`);
   }
-  const sortedProjects = sortProjects(projects);
+  return join6(plinthHome(), workspaceSlug, "sessions");
+}
+function sessionRecordPath(workspaceSlug, sessionId) {
+  if (!isSafeSegment(sessionId)) {
+    throw new Error(`Refusing unsafe session id: ${sessionId}`);
+  }
+  return join6(sessionsDir(workspaceSlug), `${sessionId}.json`);
+}
+function readPidStartTime(pid) {
+  try {
+    const out = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env, TZ: "UTC" }
+    });
+    const collapsed = out.trim().replace(/\s+/g, " ");
+    return collapsed.length > 0 ? collapsed : null;
+  } catch {
+    return null;
+  }
+}
+function registerSession(input) {
+  const startTime = (input.startTimeFn ?? readPidStartTime)(input.pid);
+  if (startTime === null)
+    return null;
+  const record2 = {
+    version: 1,
+    session_id: input.sessionId,
+    pid: input.pid,
+    pid_start_time: startTime,
+    cwd: input.cwd,
+    workspace_slug: input.workspaceSlug,
+    started_at: (input.now ?? new Date).toISOString(),
+    transcript_path: input.transcriptPath,
+    tab_id: input.tabId ?? null,
+    ended_at: null
+  };
+  writeRecordAtomic(sessionRecordPath(input.workspaceSlug, input.sessionId), record2);
+  return record2;
+}
+var tmpCounter = 0;
+function writeRecordAtomic(target, record2) {
+  const dir = dirname5(target);
+  mkdirSync6(dir, { recursive: true, mode: 448 });
+  const tmp = `${target}.${process.pid}.${tmpCounter++}.tmp`;
+  sweepDeadTmpFiles(dir, target);
+  writeFileSync6(tmp, JSON.stringify(record2, null, 2) + `
+`, { mode: 384 });
+  try {
+    renameSync6(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync6(tmp);
+    } catch {}
+    throw err;
+  }
+}
+function sweepDeadTmpFiles(dir, target) {
+  const prefix = `${basename(target)}.`;
+  let names;
+  try {
+    names = readdirSync3(dir);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.startsWith(prefix) || !name.endsWith(".tmp"))
+      continue;
+    const parts = name.slice(0, -".tmp".length).split(".");
+    const pid = Number.parseInt(parts[parts.length - 2] ?? "", 10);
+    if (!Number.isInteger(pid) || pid <= 0)
+      continue;
+    if (pid === process.pid || isPidAlive(pid))
+      continue;
+    try {
+      unlinkSync6(join6(dir, name));
+    } catch {}
+  }
+}
+function endSession(workspaceSlug, sessionId, now = new Date, deps = {}) {
+  const read = deps.readFn ?? readSessionRecord;
+  const path3 = sessionRecordPath(workspaceSlug, sessionId);
+  const current = read(path3);
+  if (current === null)
+    return null;
+  const latest = read(path3);
+  if (latest === null || latest.pid !== current.pid || latest.pid_start_time !== current.pid_start_time) {
+    return null;
+  }
+  const record2 = { ...latest, ended_at: now.toISOString() };
+  writeRecordAtomic(path3, record2);
+  return record2;
+}
+function readSessionRecord(path3) {
+  let raw;
+  try {
+    raw = readFileSync7(path3, "utf8");
+  } catch {
+    return null;
+  }
+  let json2;
+  try {
+    json2 = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const parsed = SessionRecordSchema.safeParse(json2);
+  return parsed.success ? parsed.data : null;
+}
+function sessionLiveness(record2, deps = {}) {
+  if (!(deps.aliveFn ?? isPidAlive)(record2.pid))
+    return "dead";
+  const startTime = (deps.startTimeFn ?? readPidStartTime)(record2.pid);
+  if (startTime === null)
+    return "unknown";
+  return startTime === record2.pid_start_time ? "live" : "dead";
+}
+function transcriptMtime(path3) {
+  try {
+    return statSync(path3).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function listSessions(workspaceSlug, deps = {}) {
+  let names;
+  try {
+    names = readdirSync3(sessionsDir(workspaceSlug));
+  } catch {
+    return { live: [], reaped: 0, unknown: 0, ended: 0 };
+  }
+  const live = [];
+  let reaped = 0;
+  let unknown2 = 0;
+  let ended = 0;
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    const path3 = join6(sessionsDir(workspaceSlug), name);
+    const record2 = readSessionRecord(path3);
+    if (!record2) {
+      continue;
+    }
+    const verdict = sessionLiveness(record2, deps);
+    if (verdict === "unknown") {
+      unknown2 += 1;
+      continue;
+    }
+    if (verdict === "dead") {
+      const current = readSessionRecord(path3);
+      const sameRecord = current !== null && current.pid === record2.pid && current.pid_start_time === record2.pid_start_time;
+      if (sameRecord) {
+        try {
+          unlinkSync6(path3);
+          reaped += 1;
+        } catch {}
+      }
+      continue;
+    }
+    if (record2.ended_at !== null) {
+      ended += 1;
+      continue;
+    }
+    const mtime = record2.transcript_path ? (deps.mtimeFn ?? transcriptMtime)(record2.transcript_path) : null;
+    live.push({ record: record2, lastActivityMs: mtime });
+  }
+  live.sort((a2, b2) => (b2.lastActivityMs ?? -1) - (a2.lastActivityMs ?? -1));
+  return { live, reaped, unknown: unknown2, ended };
+}
+
+// src/lib/memory-gate/log.ts
+var MEMORY_GATE_DECISIONS = ["accept", "reject", "edit"];
+var Common = {
+  version: exports_external.literal(1),
+  at: exports_external.string().min(1),
+  session_id: exports_external.string().min(1).nullable(),
+  member: exports_external.string().min(1).nullable()
+};
+var DecisionRecordSchema = exports_external.object({
+  ...Common,
+  kind: exports_external.literal("decision"),
+  proposed: exports_external.string().min(1),
+  decision: exports_external.enum(MEMORY_GATE_DECISIONS),
+  final: exports_external.string().min(1).nullable()
+});
+var NothingProposedRecordSchema = exports_external.object({
+  ...Common,
+  kind: exports_external.literal("nothing-proposed")
+});
+var MemoryGateRecordSchema = exports_external.discriminatedUnion("kind", [
+  DecisionRecordSchema,
+  NothingProposedRecordSchema
+]);
+function memoryGateDir(workspaceSlug) {
+  if (!isSafeSegment(workspaceSlug)) {
+    throw new Error(`Refusing unsafe workspace slug: ${workspaceSlug}`);
+  }
+  return join7(plinthHome(), "_memory_gate", workspaceSlug);
+}
+function memoryGateLogPath(workspaceSlug) {
+  return join7(memoryGateDir(workspaceSlug), "log.jsonl");
+}
+function buildDecisionRecord(input) {
+  const final = input.decision === "accept" ? input.proposed : input.decision === "reject" ? null : input.final ?? null;
+  return {
+    version: 1,
+    kind: "decision",
+    at: (input.now ?? new Date).toISOString(),
+    session_id: input.sessionId,
+    member: input.member,
+    proposed: input.proposed,
+    decision: input.decision,
+    final
+  };
+}
+function buildNothingProposedRecord(input) {
+  return {
+    version: 1,
+    kind: "nothing-proposed",
+    at: (input.now ?? new Date).toISOString(),
+    session_id: input.sessionId,
+    member: input.member
+  };
+}
+function endsMidLine(path3) {
+  let size;
+  try {
+    size = statSync2(path3).size;
+  } catch {
+    return false;
+  }
+  if (size === 0)
+    return false;
+  const fd = openSync(path3, "r");
+  try {
+    const last = Buffer.alloc(1);
+    readSync(fd, last, 0, 1, size - 1);
+    return last[0] !== 10;
+  } finally {
+    closeSync(fd);
+  }
+}
+function appendMemoryGateRecord(workspaceSlug, record2) {
+  const checked = MemoryGateRecordSchema.parse(record2);
+  const path3 = memoryGateLogPath(workspaceSlug);
+  mkdirSync7(memoryGateDir(workspaceSlug), { recursive: true, mode: 448 });
+  const prefix = endsMidLine(path3) ? `
+` : "";
+  appendFileSync(path3, `${prefix}${JSON.stringify(checked)}
+`, { mode: 384 });
+}
+function readMemoryGateLog(workspaceSlug) {
+  let raw;
+  try {
+    raw = readFileSync8(memoryGateLogPath(workspaceSlug), "utf8");
+  } catch {
+    return { records: [], skipped: 0 };
+  }
+  const records = [];
+  let skipped = 0;
+  for (const line of raw.split(`
+`)) {
+    if (line.trim().length === 0)
+      continue;
+    let json2;
+    try {
+      json2 = JSON.parse(line);
+    } catch {
+      skipped += 1;
+      continue;
+    }
+    const parsed = MemoryGateRecordSchema.safeParse(json2);
+    if (parsed.success)
+      records.push(parsed.data);
+    else
+      skipped += 1;
+  }
+  return { records, skipped };
+}
+
+// src/commands/memory-gate.ts
+init_output();
+function resolveTarget2(explicitSlug, explicitMember, loadConfigFn) {
+  let config2;
+  try {
+    config2 = loadConfigFn();
+  } catch {
+    return { ok: false, message: "Config at ~/.plinth/config.json could not be read. Run `plinth login --workspace <slug>` first." };
+  }
+  if (!config2) {
+    return { ok: false, message: "No workspace configured. Run `plinth login --workspace <slug>` first." };
+  }
+  const slug = explicitSlug ?? config2.active_workspace;
+  const entry2 = config2.workspaces[slug];
+  if (!entry2) {
+    return {
+      ok: false,
+      message: explicitSlug === undefined ? "No workspace configured. Run `plinth login --workspace <slug>` first." : `Workspace "${slug}" not found. Run \`plinth login --workspace ${slug}\` first.`
+    };
+  }
+  return { ok: true, slug, member: explicitMember ?? entry2.user_id ?? null };
+}
+function isDecision(value) {
+  return MEMORY_GATE_DECISIONS.includes(value);
+}
+async function runMemoryGateLog(args, deps = {}) {
+  const out = new Output({ sink: deps.sink, noColor: deps.noColor ?? args.noColor });
+  const env3 = deps.env ?? process.env;
+  const now = (deps.now ?? (() => new Date))();
+  const nothing = args.nothingProposed === true;
+  const hasDecisionArgs = args.proposed !== undefined || args.decision !== undefined;
+  if (nothing && hasDecisionArgs) {
+    out.error("--nothing-proposed records a close that proposed nothing; it cannot be combined with --proposed/--decision.");
+    return { exitCode: 1 };
+  }
+  if (!nothing && !hasDecisionArgs) {
+    out.error("Nothing to log. Pass --proposed and --decision for one decision, or --nothing-proposed for a close that had nothing to bank.");
+    return { exitCode: 1 };
+  }
+  const target = resolveTarget2(args.workspace, args.member, deps.loadConfigFn ?? loadConfig);
+  if (!target.ok) {
+    out.error(target.message);
+    return { exitCode: 1 };
+  }
+  const sessionId = typeof env3.CLAUDE_CODE_SESSION_ID === "string" && env3.CLAUDE_CODE_SESSION_ID.length > 0 ? env3.CLAUDE_CODE_SESSION_ID : null;
+  const append = deps.appendFn ?? appendMemoryGateRecord;
+  if (nothing) {
+    try {
+      append(target.slug, buildNothingProposedRecord({ sessionId, member: target.member, now }));
+    } catch (err) {
+      out.error(`Could not write the memory-gate log: ${err.message}`);
+      return { exitCode: 1 };
+    }
+    out.info("Logged: this close proposed nothing for shared memory.");
+    return { exitCode: 0 };
+  }
+  const proposed = args.proposed?.trim() ?? "";
+  if (proposed.length === 0) {
+    out.error("--proposed must carry the line as it was put to the user.");
+    return { exitCode: 1 };
+  }
+  const decisionRaw = args.decision?.trim() ?? "";
+  if (!isDecision(decisionRaw)) {
+    out.error(`--decision must be one of ${MEMORY_GATE_DECISIONS.join(", ")} (got ${decisionRaw === "" ? "nothing" : `"${decisionRaw}"`}).`);
+    return { exitCode: 1 };
+  }
+  const finalArg = args.final?.trim() ?? "";
+  if (decisionRaw === "edit" && finalArg.length === 0) {
+    out.error("--decision edit needs --final: the user's rewritten line is the record.");
+    return { exitCode: 1 };
+  }
+  if (decisionRaw !== "edit" && finalArg.length > 0) {
+    out.error(`--final applies to --decision edit only (accept records the proposed line, reject records none).`);
+    return { exitCode: 1 };
+  }
+  try {
+    append(target.slug, buildDecisionRecord({
+      proposed,
+      decision: decisionRaw,
+      final: finalArg.length > 0 ? finalArg : null,
+      sessionId,
+      member: target.member,
+      now
+    }));
+  } catch (err) {
+    out.error(`Could not write the memory-gate log: ${err.message}`);
+    return { exitCode: 1 };
+  }
+  out.info(`Logged ${decisionRaw} for shared memory (${target.slug}).`);
+  return { exitCode: 0 };
+}
+async function runMemoryGateShow(args, deps = {}) {
+  const out = new Output({ sink: deps.sink, noColor: deps.noColor ?? args.noColor });
+  const target = resolveTarget2(args.workspace, args.member, deps.loadConfigFn ?? loadConfig);
+  if (!target.ok) {
+    out.error(target.message);
+    return { exitCode: 1 };
+  }
+  const { records, skipped } = (deps.readFn ?? readMemoryGateLog)(target.slug);
+  const limit = args.limit !== undefined && args.limit > 0 ? args.limit : undefined;
+  const shown = limit === undefined ? records : records.slice(-limit);
+  if (args.json) {
+    out.info(JSON.stringify({
+      workspace_slug: target.slug,
+      path: memoryGateLogPath(target.slug),
+      records: shown,
+      withheld: records.length - shown.length,
+      unreadable: skipped
+    }, null, 2));
+    return { exitCode: 0 };
+  }
+  if (shown.length === 0) {
+    out.info(`No memory-gate records for ${target.slug}.`);
+  }
+  for (const record2 of shown) {
+    if (record2.kind === "nothing-proposed") {
+      out.info(`${record2.at} · nothing proposed`);
+      continue;
+    }
+    const tail = record2.final === null ? "" : ` → ${record2.final}`;
+    out.info(`${record2.at} · ${record2.decision} · ${record2.proposed}${tail}`);
+  }
+  if (records.length - shown.length > 0) {
+    out.info(`${records.length - shown.length} earlier record(s) not shown (--limit).`);
+  }
+  if (skipped > 0) {
+    out.info(`${skipped} line(s) could not be read and are not counted above.`);
+  }
+  return { exitCode: 0 };
+}
+var memoryGateCommand = defineCommand({
+  meta: {
+    name: "memory-gate",
+    description: "Record what a /close ritual proposed for shared memory, and what the user decided"
+  },
+  subCommands: {
+    log: defineCommand({
+      meta: {
+        name: "log",
+        description: "Append one decision (or a nothing-proposed close) to the local memory-gate log. Machine-local: nothing under ~/.plinth syncs."
+      },
+      args: {
+        workspace: { type: "string", description: "Workspace slug" },
+        proposed: { type: "string", description: "The line as it was put to the user" },
+        decision: { type: "string", description: `One of ${MEMORY_GATE_DECISIONS.join(", ")}` },
+        final: { type: "string", description: "The user's rewritten line (--decision edit only)" },
+        "nothing-proposed": {
+          type: "boolean",
+          description: "Record a close that proposed nothing for shared memory"
+        },
+        member: { type: "string", description: "Override the member id (defaults to this login's user)" },
+        "no-color": { type: "boolean", description: "Disable colour" }
+      },
+      async run({ args }) {
+        const result = await runMemoryGateLog({
+          workspace: args.workspace,
+          proposed: args.proposed,
+          decision: args.decision,
+          final: args.final,
+          nothingProposed: args["nothing-proposed"],
+          member: args.member
+        }, { noColor: noColorFromArgs(args) });
+        process.exitCode = result.exitCode;
+      }
+    }),
+    show: defineCommand({
+      meta: {
+        name: "show",
+        description: "Read the local memory-gate log back. Machine-local: nothing under ~/.plinth syncs."
+      },
+      args: {
+        workspace: { type: "string", description: "Workspace slug" },
+        json: { type: "boolean", description: "Machine-readable output" },
+        limit: { type: "string", description: "Show only the most recent N records" },
+        "no-color": { type: "boolean", description: "Disable colour" }
+      },
+      async run({ args }) {
+        const rawLimit = args.limit;
+        const parsed = rawLimit === undefined ? undefined : Number.parseInt(rawLimit, 10);
+        const result = await runMemoryGateShow({
+          workspace: args.workspace,
+          json: args.json,
+          limit: parsed !== undefined && Number.isInteger(parsed) ? parsed : undefined
+        }, { noColor: noColorFromArgs(args) });
+        process.exitCode = result.exitCode;
+      }
+    })
+  }
+});
+
+// src/lib/context/artist-context.ts
+import { existsSync } from "node:fs";
+
+// src/lib/context/command-paths.ts
+var WORKSPACE_COMMANDS_DIR = ".claude/commands/plinth";
+var WORKSPACE_COMMANDS_SUBFOLDER = WORKSPACE_COMMANDS_DIR.split("/").pop() ?? "";
+var START_COMMAND_REL = `${WORKSPACE_COMMANDS_DIR}/start.md`;
+var CLOSE_COMMAND_REL = `${WORKSPACE_COMMANDS_DIR}/close.md`;
+function invocationFor(relPath) {
+  const parts = relPath.split("/");
+  const name = (parts.pop() ?? "").replace(/\.md$/, "");
+  const namespace = parts.pop() ?? "";
+  return `/${namespace}:${name}`;
+}
+var START_COMMAND_INVOCATION = invocationFor(START_COMMAND_REL);
+var CLOSE_COMMAND_INVOCATION = invocationFor(CLOSE_COMMAND_REL);
+
+// src/lib/context/entity-catalog.ts
+var ENTITY_CATALOG = [
+  { label: "artists", blurb: "roster acts; one folder per artist under `artists/<slug>/`", file: true },
+  { label: "projects", blurb: "campaigns, releases, and workstreams", file: true },
+  { label: "tasks", blurb: "actionable to-dos, optionally tied to an artist or project", file: true },
+  { label: "meetings + meeting_notes", blurb: "meeting records and their attached notes", file: true },
+  { label: "documents", blurb: "notes, briefs, bios, transcripts, context docs (markdown bodies, not attachments)", file: true },
+  {
+    label: "workspace_files",
+    blurb: "the free-form document store: PDFs, executed agreements, spreadsheets, " + "anything that is a FILE rather than an entity. Mirrored byte-for-byte " + "both ways under `files/`, folders and all. Look here for contracts",
+    file: true
+  },
+  {
+    label: "threads + thread_messages",
+    blurb: "threaded discussions, one folder per thread anchored at " + "`threads/<slug>/_thread.md`; messages live in Plinth, not the mirror, and " + "the anchor's own body is a local scratchpad that never pushes",
+    file: true
+  },
+  { label: "key_dates", blurb: "calendar milestones and release dates", file: false },
+  { label: "comments", blurb: "comments anchored to any entity", file: false },
+  { label: "tracks", blurb: "track and release metadata", file: false },
+  { label: "social_posts", blurb: "planned and published social content", file: false },
+  { label: "useful_links", blurb: "bookmarked links per artist or workspace", file: false },
+  { label: "financial_entries", blurb: "income and cost ledger rows", file: false },
+  { label: "commissions", blurb: "agent, sync, streaming, publishing & other statements", file: false }
+];
+var MCP_INTROSPECTION_POINTER = "ask the `mcp__plinth__*` tools for exact fields & enum values (the " + "platform is the schema source of truth)";
+var MCP_AVAILABILITY_POINTER = "Other MCP servers may be connected on this machine: `claude mcp list` " + "names them and their connection status, though that command is blocked " + "inside the Plinth cockpit (it denies `Bash(claude:*)`), so in the cockpit " + "ask the user instead of concluding there are none. Plinth neither " + "configures nor ships them.";
+var SKILL_LOCATIONS = [
+  {
+    label: "workspace",
+    detail: "`.claude/commands/` in this folder; this machine only, the daemon does not sync it. " + `Plinth generates two into \`${WORKSPACE_COMMANDS_SUBFOLDER}/\` on every sync: ` + `**${START_COMMAND_INVOCATION}** to open a session and **${CLOSE_COMMAND_INVOCATION}** to ` + "bank what it learned before the context is gone. Anything else in the folder is yours and is never touched"
+  },
+  { label: "personal", detail: "`~/.claude/commands/`; your own, available everywhere" }
+];
+var SECURITY_NOTE = "Scoped to a single Plinth workspace: do not read or write across " + "workspace folders; each has its own token and isolation boundary.";
+
+// src/lib/context/generated-at.ts
+var GENERATED_AT_PLACEHOLDER = "{{plinth-generated-at}}";
+var GENERATED_AT_PREFIX = "Content built ";
+var STAMP_RE = /\d{4}-\d{2}-\d{2} \d{2}:\d{2} [+-]\d{2}:\d{2}/;
+function escapeRegExp(literal2) {
+  return literal2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var STAMP_SLOT_RE = new RegExp(escapeRegExp(GENERATED_AT_PREFIX) + "(?:" + STAMP_RE.source + "|" + escapeRegExp(GENERATED_AT_PLACEHOLDER) + ")");
+function pad2(n2) {
+  return String(n2).padStart(2, "0");
+}
+function formatGeneratedAt(d2) {
+  const date5 = `${d2.getFullYear()}-${pad2(d2.getMonth() + 1)}-${pad2(d2.getDate())}`;
+  const time3 = `${pad2(d2.getHours())}:${pad2(d2.getMinutes())}`;
+  const offsetMinutes = -d2.getTimezoneOffset();
+  const sign = offsetMinutes < 0 ? "-" : "+";
+  const abs = Math.abs(offsetMinutes);
+  return `${date5} ${time3} ${sign}${pad2(Math.floor(abs / 60))}:${pad2(abs % 60)}`;
+}
+function renderGeneratedAt(content, at) {
+  return content.replace(GENERATED_AT_PLACEHOLDER, formatGeneratedAt(at));
+}
+function normaliseGeneratedAt(content) {
+  return content.replace(STAMP_SLOT_RE, GENERATED_AT_PREFIX + GENERATED_AT_PLACEHOLDER);
+}
+
+// src/lib/context/markers.ts
+var USER_BLOCK_BEGIN = "<!-- BEGIN: user-customisable -->";
+var USER_BLOCK_END = "<!-- END -->";
+var USER_BLOCK_PLACEHOLDER = "_Add workspace-specific guidance here. This block is the only part of " + "the file Plinth preserves across regenerations._";
+function extractUserBlock(content) {
+  const beginIdx = content.indexOf(USER_BLOCK_BEGIN);
+  if (beginIdx === -1)
+    return null;
+  const afterBegin = beginIdx + USER_BLOCK_BEGIN.length;
+  const endIdx = content.indexOf(USER_BLOCK_END, afterBegin);
+  if (endIdx === -1)
+    return null;
+  return content.slice(afterBegin, endIdx);
+}
+function injectUserBlock(generated, preserved) {
+  const beginIdx = generated.indexOf(USER_BLOCK_BEGIN);
+  if (beginIdx === -1) {
+    throw new Error("injectUserBlock: generated content has no BEGIN marker");
+  }
+  const afterBegin = beginIdx + USER_BLOCK_BEGIN.length;
+  const endIdx = generated.indexOf(USER_BLOCK_END, afterBegin);
+  if (endIdx === -1) {
+    throw new Error("injectUserBlock: generated content has no END marker");
+  }
+  return generated.slice(0, afterBegin) + preserved + generated.slice(endIdx);
+}
+
+// src/lib/context/artist-claude-md.ts
+var CONTEXT_VERSION_HEADER = "plinth-context-version";
+var TASK_DISPLAY_CAP = 10;
+var PRIORITY_RANK = {
+  urgent: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function buildArtistClaudeMd(input) {
+  const body = buildBody(input);
+  const version2 = stableHash(body).slice(0, 12);
+  return `<!-- ${CONTEXT_VERSION_HEADER}: ${version2} -->
+${body}`;
+}
+function buildBody(input) {
+  const { slug, name, status, uuid: uuid3, profile, projects, tasks } = input;
+  const lines = [];
+  lines.push(`<!-- Auto-generated by Plinth. ${GENERATED_AT_PREFIX}${GENERATED_AT_PLACEHOLDER}; ` + `that stamp moves only when this file's content changes, so an unchanged file keeps an older one ` + `and is still re-checked against Plinth on every sync. Run \`plinth status\` for when the mirror last synced. ` + `Edit only between the BEGIN/END markers below; everything else is overwritten on sync. -->`);
+  lines.push("");
+  lines.push(`# ${name} · Plinth artist`);
+  lines.push("");
+  const statusPart = status ? `, status ${status}` : "";
+  const bioPart = profile.bio ? ` ${profile.bio}` : "";
+  lines.push(`${name} (artist \`${slug}\`${statusPart}).${bioPart}`);
+  lines.push(`Working dir for ${name}-scoped AI sessions. ${SECURITY_NOTE}`);
+  lines.push("");
+  const links = buildLinks(profile);
+  if (links) {
+    lines.push(`## Links`);
+    lines.push(links);
+    lines.push("");
+  }
+  const sortedProjects = sortProjects(projects);
   const names = sortedProjects.map((p) => p.name).join(", ");
   lines.push(`## Active projects (${sortedProjects.length})${names ? `: ${names}` : ""}`);
   if (sortedProjects.length === 0) {
@@ -27877,7 +28659,8 @@ function buildBody(input) {
   lines.push(`- Master context (stable profile + current state) → \`./_artist.md\`; edit its body and the daemon syncs both ways. Blocks labelled "rendered from Plinth" are the exception: they are overwritten on the next sync`);
   lines.push(`- Closed/archived, meetings & full lists: \`mcp__plinth__list_projects\` / \`mcp__plinth__list_tasks\`${artistIdHint(uuid3)}`);
   lines.push(`- Schema: ${MCP_INTROSPECTION_POINTER}`);
-  lines.push(`- Long-term facts → \`./memory.md\` · daily activity → \`./daily-log.md\``);
+  lines.push(`- Long-term facts → \`./memory.md\`, which syncs to this artist's Plinth record. Most artists have none yet: the file appears once the record carries memory, and creating it here is how you start one. One line per fact with its source and an absolute date; when a fact goes wrong, edit that line rather than adding a second`);
+  lines.push(`- Rolling day-to-day activity → \`./daily-log.md\`, local to this machine and never synced. Durable facts do not belong here; they belong in \`./memory.md\` above`);
   lines.push("");
   lines.push(USER_BLOCK_BEGIN);
   lines.push(USER_BLOCK_PLACEHOLDER);
@@ -27950,7 +28733,7 @@ function datePart(value) {
 
 // src/lib/context/artist-data.ts
 var import_gray_matter5 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 function artistUuidBySlug(state) {
   const map2 = new Map;
   for (const entry2 of Object.values(state.entries.artists ?? {})) {
@@ -28062,7 +28845,7 @@ function readEntityFrontmatter(workspaceSlug, entityType, slug) {
   }
   let raw;
   try {
-    raw = readFileSync6(path3, "utf8");
+    raw = readFileSync9(path3, "utf8");
   } catch {
     return null;
   }
@@ -28090,6 +28873,7 @@ function readSchemaVersion(content) {
 // src/lib/context/regen.ts
 function decideRegen(input) {
   const { existing, currentVersion, generated, force } = input;
+  const normalise = input.normalise ?? ((c3) => c3);
   if (existing === null || existing.trim() === "") {
     return { action: "create", content: generated };
   }
@@ -28103,7 +28887,7 @@ function decideRegen(input) {
     return { action: "backup-regen", content: generated, backup: existing };
   }
   const merged = injectUserBlock(generated, preserved);
-  if (merged === existing) {
+  if (normalise(merged) === normalise(existing)) {
     return { action: "skip", content: null };
   }
   return { action: "regen", content: merged };
@@ -28111,18 +28895,18 @@ function decideRegen(input) {
 
 // src/lib/context/roster.ts
 var import_gray_matter6 = __toESM(require_gray_matter(), 1);
-import { readdirSync as readdirSync3, readFileSync as readFileSync7 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
+import { join as join8 } from "node:path";
 function readRoster(workspaceSlug) {
   let artistsDir;
   try {
-    artistsDir = join5(workspaceMirrorPath(workspaceSlug), "artists");
+    artistsDir = join8(workspaceMirrorPath(workspaceSlug), "artists");
   } catch {
     return [];
   }
   let slugs;
   try {
-    slugs = readdirSync3(artistsDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => d2.name).sort();
+    slugs = readdirSync4(artistsDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => d2.name).sort();
   } catch {
     return [];
   }
@@ -28130,7 +28914,7 @@ function readRoster(workspaceSlug) {
   for (const slug of slugs) {
     let raw;
     try {
-      raw = readFileSync7(join5(artistsDir, slug, "_artist.md"), "utf8");
+      raw = readFileSync10(join8(artistsDir, slug, "_artist.md"), "utf8");
     } catch {
       continue;
     }
@@ -28147,9 +28931,9 @@ function readRoster(workspaceSlug) {
 }
 
 // src/lib/context/session-hook.ts
-import { execFileSync } from "node:child_process";
-import { accessSync, constants, realpathSync, statSync } from "node:fs";
-import { basename } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { accessSync, constants, realpathSync, statSync as statSync3 } from "node:fs";
+import { basename as basename2 } from "node:path";
 var SETTINGS_REL = ".claude/settings.json";
 var MANAGED_KEY = "_plinth";
 var COMMENT_SENTINEL = 'Managed by plinth-cli. Entries tagged "_plinth" are REGENERATED on every sync:';
@@ -28157,8 +28941,32 @@ var MANAGED_COMMENT = [
   COMMENT_SENTINEL,
   "edits to them are overwritten without warning. Add your own hooks as separate",
   "entries in this file (they are preserved verbatim, including their matchers)",
-  "or in .claude/settings.local.json."
+  "or in .claude/settings.local.json.",
+  "The permissions.deny entries below are managed the same way. They stop an agent",
+  "in this workspace sending, replying to or forwarding mail and writing a calendar;",
+  "drafting and reading stay allowed. Your own allow list is untouched, and your own",
+  "deny rules are kept and listed first. One exception, stated because it is",
+  "visible: if you write a deny rule whose text is identical to one of ours, it is",
+  "kept once, in our section, rather than twice. A deny always beats an allow,",
+  "including your own."
 ];
+var MANAGED_DENY = [
+  "mcp__claude_ai_Gmail__send_message",
+  "mcp__claude_ai_Gmail__reply",
+  "mcp__claude_ai_Gmail__forward",
+  "mcp__claude_ai_Google_Calendar__create_event",
+  "mcp__claude_ai_Google_Calendar__update_event",
+  "mcp__claude_ai_Google_Calendar__delete_event",
+  "mcp__claude_ai_Google_Calendar__respond_to_event",
+  "mcp__*__send_message",
+  "mcp__*__reply",
+  "mcp__*__forward",
+  "mcp__*__create_event",
+  "mcp__*__update_event",
+  "mcp__*__delete_event",
+  "mcp__*__respond_to_event"
+];
+var RETIRED_DENY = [];
 var BIN_SENTINEL = "__PLINTH_BIN__";
 var ALL_SENTINEL = "__PLINTH_ALL__";
 var RESOLVE_SCRIPT = `printf '%s
@@ -28189,7 +28997,7 @@ function resolveOverride(override, deps) {
 }
 function resolveUncached(deps) {
   const shell = deps.shell ?? process.env.SHELL ?? "/bin/zsh";
-  const exec = deps.exec ?? ((sh, args) => execFileSync(sh, args, {
+  const exec = deps.exec ?? ((sh, args) => execFileSync2(sh, args, {
     encoding: "utf8",
     timeout: 5000,
     stdio: ["ignore", "pipe", "ignore"]
@@ -28252,13 +29060,13 @@ function probe(run, usable) {
 function isPlinthBinary(candidate, usable) {
   if (!candidate.startsWith("/"))
     return false;
-  if (basename(candidate) !== "plinth")
+  if (basename2(candidate) !== "plinth")
     return false;
   return usable(candidate);
 }
 function defaultIsExecutableFile(path3) {
   try {
-    if (!statSync(path3).isFile())
+    if (!statSync3(path3).isFile())
       return false;
     accessSync(path3, constants.X_OK);
     return true;
@@ -28269,10 +29077,6 @@ function defaultIsExecutableFile(path3) {
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-var VOICE_GATE_MATCHERS = [
-  "Bash",
-  "mcp__.*[Gg]mail.*__(create|update)_draft"
-];
 function managedEntry(id, invocation, subcommand, workspaceSlug) {
   return {
     type: "command",
@@ -28284,24 +29088,41 @@ function buildManagedBlocks(invocation, workspaceSlug) {
   return {
     SessionStart: [
       {
-        hooks: [managedEntry("grounding", invocation, "grounding", workspaceSlug)]
+        hooks: [
+          managedEntry("grounding", invocation, "grounding", workspaceSlug),
+          managedEntry("sessions", invocation, "session register", workspaceSlug)
+        ]
       }
-    ],
-    PreToolUse: VOICE_GATE_MATCHERS.map((matcher) => ({
-      matcher,
-      hooks: [
-        managedEntry("voice-gate", invocation, "voice-gate --hook", workspaceSlug)
-      ]
-    }))
+    ]
   };
 }
+function mergePermissions(existing) {
+  if (existing !== undefined && existing !== null && !isEntry(existing)) {
+    throw new Error("`permissions` is not a JSON object");
+  }
+  const base2 = existing ? { ...existing } : {};
+  const currentDeny = base2.deny;
+  if (currentDeny !== undefined && currentDeny !== null && !Array.isArray(currentDeny)) {
+    throw new Error("`permissions.deny` is not an array");
+  }
+  const ours = new Set([...MANAGED_DENY, ...RETIRED_DENY]);
+  const kept = (Array.isArray(currentDeny) ? currentDeny : []).filter((rule) => typeof rule !== "string" || !ours.has(rule));
+  base2.deny = [...kept, ...MANAGED_DENY];
+  return base2;
+}
 var LEGACY_GROUNDING = /^'[^']*'\s+'[^']*'\s+grounding(\s|$)/;
+var OWNED_EVENTS = {
+  grounding: "SessionStart",
+  sessions: "SessionStart",
+  "voice-gate": "PreToolUse"
+};
 function isManaged(entry2, event) {
   if (!isEntry(entry2))
     return false;
   const marker = entry2[MANAGED_KEY];
-  if (marker === "grounding" || marker === "voice-gate")
+  if (typeof marker === "string" && OWNED_EVENTS[marker] === event) {
     return true;
+  }
   if (event === "SessionStart" && typeof entry2.command === "string") {
     return LEGACY_GROUNDING.test(entry2.command);
   }
@@ -28317,17 +29138,18 @@ function mergeSettings(existing, managed) {
   const base2 = existing ? { ...existing } : {};
   const existingHooks = typeof base2.hooks === "object" && base2.hooks !== null && !Array.isArray(base2.hooks) ? base2.hooks : {};
   const hooks = {};
-  for (const [event, value] of Object.entries(existingHooks)) {
-    hooks[event] = asArray(value);
-  }
-  for (const [event, managedBlocks] of Object.entries(managed)) {
-    const kept = asArray(hooks[event]).filter(isEntry).map((block) => ({
+  const events = new Set([...Object.keys(existingHooks), ...Object.keys(managed)]);
+  for (const event of events) {
+    const kept = asArray(existingHooks[event]).filter(isEntry).map((block) => ({
       ...block,
       hooks: asArray(block.hooks).filter((entry2) => isEntry(entry2) && !isManaged(entry2, event))
     })).filter((block) => block.hooks.length > 0);
-    hooks[event] = [...kept, ...managedBlocks];
+    const merged = [...kept, ...managed[event] ?? []];
+    if (merged.length > 0)
+      hooks[event] = merged;
   }
   base2.hooks = hooks;
+  base2.permissions = mergePermissions(base2.permissions);
   const current = base2.$comment;
   const isOurs = Array.isArray(current) && current[0] === COMMENT_SENTINEL;
   if (current === undefined || isOurs) {
@@ -28355,7 +29177,7 @@ function ensureSessionHook(workspaceSlug, baseRelDir, out, resolved) {
       parsed = raw;
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
-      out.error(`${rel} could not be parsed (${msg}), so the Plinth session-grounding ` + `and voice-gate hooks were NOT installed there. Fix or remove the ` + `file and re-run — until then this workspace is ungrounded and ` + `agent-originated drafts are UNGATED.`);
+      out.error(`${rel} could not be parsed (${msg}), so the Plinth session-grounding ` + `hook, the session-visibility hook and the permissions.deny list were ` + `NOT installed there. Fix or remove the file and re-run — until then ` + `this workspace is ungrounded and an agent here can SEND mail and ` + `write calendars.`);
       return "skipped";
     }
   }
@@ -28364,16 +29186,16 @@ function ensureSessionHook(workspaceSlug, baseRelDir, out, resolved) {
     generated = buildSettingsJson(resolved.invocation, workspaceSlug, parsed);
   } catch (err) {
     const msg = err instanceof Error ? err.message : "unknown error";
-    out.error(`${rel} has a structure the generator could not merge into (${msg}), so ` + `the Plinth session-grounding and voice-gate hooks were NOT installed ` + `there. This workspace is ungrounded and agent-originated drafts are ` + `UNGATED. Fix or remove the file and re-run.`);
+    out.error(`${rel} has a structure the generator could not merge into (${msg}), so ` + `the Plinth session-grounding hook, the session-visibility hook and the ` + `permissions.deny list were NOT installed there. This workspace is ` + `ungrounded and an agent here can SEND mail and write calendars. Fix or ` + `remove the file and re-run.`);
     return "skipped";
   }
   if (existing === generated)
     return "unchanged";
   writeContextFile(workspaceSlug, rel, generated);
   if (existing === null) {
-    out.info(`Generated Plinth session hooks (${rel}).`);
+    out.info(`Generated Plinth session settings (${rel}).`);
   } else {
-    out.info(`Refreshed the Plinth session hooks in ${rel} (your entries kept).`);
+    out.info(`Refreshed the Plinth session settings in ${rel} (your entries kept).`);
   }
   return "written";
 }
@@ -28390,7 +29212,7 @@ function reportResolution(out, resolved) {
   }
 }
 function warnUnresolvedBinary(out) {
-  out.error("Could not locate an installed `plinth` binary, so no Claude Code hooks " + "were written for this workspace — sessions will be UNGROUNDED and " + "agent-originated drafts UNGATED. Install the CLI globally " + "(`npm i -g @plinth-music/cli`) so `command -v plinth` resolves, then " + "re-run `plinth refresh-context`.");
+  out.error("Could not locate an installed `plinth` binary, so no Claude Code settings " + "were written for this workspace — sessions will be UNGROUNDED and an " + "agent here can SEND mail and write calendars. Install the CLI globally " + "(`npm i -g @plinth-music/cli`) so `command -v plinth` resolves, then " + "re-run `plinth refresh-context`.");
 }
 
 // src/lib/context/artist-context.ts
@@ -28441,35 +29263,249 @@ function ensurePerArtistContext(deps) {
 function regenerateClaudeMd(workspaceSlug, artistSlug, generated, force, out, now) {
   const claudeRel = `artists/${artistSlug}/${ARTIST_CLAUDE_MD}`;
   const existing = readContextFile(workspaceSlug, claudeRel);
-  const decision = decideRegen({ existing, currentVersion: "", generated, force });
+  const decision = decideRegen({
+    existing,
+    currentVersion: "",
+    generated,
+    force,
+    normalise: normaliseGeneratedAt
+  });
   if (decision.action === "backup-regen" && decision.backup !== undefined) {
     const bakRel = `${claudeRel}.bak-${backupStamp(now())}`;
     writeContextFile(workspaceSlug, bakRel, decision.backup);
     out.warn(`artists/${artistSlug}/${ARTIST_CLAUDE_MD} had no recognisable BEGIN/END ` + `markers; backed your copy up to ${bakRel} before regenerating.`);
   }
-  if (decision.content !== null) {
-    writeContextFile(workspaceSlug, claudeRel, decision.content);
+  if (decision.content !== null) {
+    writeContextFile(workspaceSlug, claudeRel, renderGeneratedAt(decision.content, now()));
+  }
+  return decision.action === "create";
+}
+function ensureStub(workspaceSlug, relativePath, content) {
+  if (existsSync(contextFilePath(workspaceSlug, relativePath)))
+    return;
+  writeContextFile(workspaceSlug, relativePath, content);
+}
+function dailyLogStub(name) {
+  return `# ${name} - Daily log
+
+` + `<!-- Rolling activity, newest first; edit freely, Plinth never overwrites this file. -->
+` + `<!-- Durable facts do not belong here - they go in ./memory.md, which syncs to this artist's Plinth record. -->
+`;
+}
+function backupStamp(d2) {
+  return d2.toISOString().replace(/[-:.]/g, "").replace("Z", "");
+}
+
+// src/lib/context/generate.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// src/lib/context/skill-commands.ts
+var COMMAND_USER_BLOCK_PLACEHOLDER = "_This workspace's own steps go here: anything specific to your team, your " + "tools or your data. Plinth preserves this block verbatim on every " + "regeneration; everything outside it is overwritten._";
+var OWNERSHIP_NOTE = "<!-- Auto-generated by Plinth into every mirror on every sync. Edit only " + "between the BEGIN/END markers at the foot; everything else is overwritten. " + "Your own commands in `.claude/commands/` are never read or touched by " + "Plinth, only this `plinth/` folder is generated. -->";
+function withUserBlock(lines) {
+  return [...lines, "", USER_BLOCK_BEGIN, COMMAND_USER_BLOCK_PLACEHOLDER, USER_BLOCK_END].join(`
+`) + `
+`;
+}
+function buildStartCommandMd() {
+  return withUserBlock([
+    "---",
+    "description: Open a Plinth session in this workspace. Reads both memory files, pulls what is unread, reads the projected calendar, gives a three-line brief, then asks what you want to work on.",
+    "---",
+    "",
+    OWNERSHIP_NOTE,
+    "",
+    "# Start",
+    "",
+    "Get oriented in this Plinth workspace in a few seconds, then load context for whatever the user names.",
+    "",
+    "**Do not re-run `date`, and do not restate the grounding rules.** The Plinth SessionStart hook has already injected today's date, the entity-resolution rule and the write-confirmation rule, and the workspace `CLAUDE.md` (roster and folder map) is already in context. Repeating them spends the budget this command exists to protect.",
+    "",
+    "## Step 1: use the two memory indexes you were already given",
+    "",
+    "The SessionStart hook injects **both memory indexes in full**, above: the workspace index (durable facts and conventions that hold for anyone here) and your personal index (facts true of **this member**: their email address, how they write, how they work). **Do not re-read `workspace-memory.md` or `user-memory.md`.** They are already in this context window, and re-reading them is the single most expensive thing this command could do for nothing.",
+    "",
+    "**Use the second one. It is the one that gets skipped**, and it is the one carrying the member's own identity, including the email address that every task assignment needs. An agent that ignores it asks the user for something the workspace already told it.",
+    "",
+    "If neither index appears above, the hook did not run - then, and only then, read the two files at the **mirror root**, the workspace folder holding `CLAUDE.md` (if this session started inside `artists/<slug>/`, that is the parent). Read them silently; do not dump either file into the conversation.",
+    "",
+    "## Step 2: what has landed",
+    "",
+    "Pull **unread notifications** from the Plinth MCP (`list_notifications`). If the Plinth MCP is not connected, say so in one line and carry on from the injected indexes rather than failing.",
+    "",
+    "**That one call plus the single file read in Step 3 are the whole budget, and the list below is exhaustive rather than indicative.** Do not sweep tasks, do not list projects, do not open a calendar, do not read an artist folder, and do not re-read the memory files. If a fact is not in the two injected indexes, in the notifications, or in that one file, it does not belong in this brief.",
+    "",
+    "## Step 3: what is coming up",
+    "",
+    "Read **one file**: `views/calendar/upcoming.md` at the mirror root. It is Plinth's projection of every artist's calendar, written into the mirror by the daemon.",
+    "",
+    "**This is a FILE READ, not a calendar call, and the rule in Step 2 stands unchanged: you still never open a calendar tool.** The file is here so that you do not have to.",
+    "",
+    '**Brief it as of its own `generated_at` stamp, and say the stamp.** A projection is a cache. It is exactly as current as the header says it is and no more, so "nothing on this week" is only ever true as of that moment.',
+    "",
+    "**Read its calendar-status list before you read the dates, and escalate anything that was not read.** A calendar Plinth could not reach is UNKNOWN, not empty, and the file says which. Briefing an unread calendar as a clear diary is the one failure this file exists to prevent - if a line says NOT READ, say so out loud in the brief.",
+    "",
+    "If the file carries `fetch_state: stale`, the last refresh failed: say how old the dates are rather than reporting them as current. If the file is absent altogether, say the projection has not run yet and carry on without it.",
+    "",
+    "**Dates are read here and changed by a person, in Plinth's calendar view.** If something needs moving, say what the change is and hand it over.",
+    "",
+    "## Step 4: brief, in three lines",
+    "",
+    "Then stop reading and report. **Three lines, and not a summary of what you read:**",
+    "",
+    "1. Today, and anything with a clock on it that the injected indexes, the notifications or the calendar file **have already named** - with the calendar's own stamp when you use it. Do not go looking for more.",
+    "2. The unread count, and the one or two that actually matter.",
+    "3. Anything blocked or waiting on someone.",
+    "",
+    'Then ask: **"What do you want to work on?"** If the user already said so in the same message, skip the question and load that context now.',
+    "",
+    "## Step 5: offer the sweep, do not run it",
+    "",
+    `A full roster sweep, every artist's overdue and upcoming work plus calendars and project status, is useful and it is **not** part of opening a session. **Offer it in one clause ("want the roster sweep?") and stop there.** Reporting a sweep you ran anyway is the failure this step exists to prevent: it is the same cost the user did not ask for, with the offer bolted on afterwards.`,
+    "",
+    "**The budget is the one call in Step 2 and the one file read in Step 3, and it is a ceiling rather than a target.** Every new session pays this command before the user has asked for anything, so a second call needs a reason you would defend out loud. An opener that takes half a minute gets turned off, and an opener nobody runs banks nothing at the other end.",
+    "",
+    "## Loading area context",
+    "",
+    "Once the user names something, resolve it against the workspace before answering: search the Plinth MCP, or read the roster in `CLAUDE.md`. **Never answer from name recognition alone.** Then read the surfaces that carry it. An artist's master context is `artists/<slug>/_artist.md`, their durable facts are `artists/<slug>/memory.md`, their recent activity is `artists/<slug>/daily-log.md`. Brief on what is live, not on what you opened.",
+    "",
+    "If nothing resolves, say so plainly and ask. Do not invent an entity.",
+    "",
+    "## Write discipline",
+    "",
+    "This command is read-only orientation. If the session moves into changes, follow the injected grounding: prose and context through the mirror file, structured fields through the Plinth MCP, the exact write stated before the first mutation, and never the database directly.",
+    "",
+    `When the session is finished, \`${CLOSE_COMMAND_INVOCATION}\` is the other half of this one: it banks what was learned before the context is gone.`
+  ]);
+}
+function buildCloseCommandMd() {
+  return withUserBlock([
+    "---",
+    "description: Close a Plinth session. Verifies what you wrote landed, routes follow-ups to a durable surface, asks before anything reaches shared memory, and logs what was decided.",
+    "---",
+    "",
+    OWNERSHIP_NOTE,
+    "",
+    "# Close",
+    "",
+    "End a working session cleanly: everything done this session is on a durable surface, nothing is half-written, and the next session can pick up cold.",
+    "",
+    "Trust the date the session hook injected. Do not re-derive it.",
+    "",
+    "## Step 1: reconstruct the session",
+    "",
+    "From the **transcript**, not from your memory of it. Which entities were touched, which writes were made, what was decided, what was learned. If the session was pure reading with no changes, say so and go to Step 4 anyway: a read-only close still logs, and the `--nothing-proposed` rule below is why.",
+    "",
+    "## Step 2: verify each write landed",
+    "",
+    "For every intended write, confirm it actually happened: the tool returned success, or the file on disk reflects it. Re-read the file if you are unsure. **A change that exists only in this conversation is lost the moment it ends.**",
+    "",
+    "Flag anything left in flight: an unsent draft, a quarantined edit awaiting `plinth confirm`, a task created with no owner or due date, something agreed out loud and written nowhere.",
+    "",
+    "## Step 3: route the follow-ups",
+    "",
+    "Each loose end goes to the surface that holds it, and nowhere else:",
+    "",
+    "- **Something to do** goes to a Plinth task, scoped to its artist or project, with an owner and a real due date where one exists. Fold it into the existing umbrella task rather than adding a second.",
+    "- **State or context that changed** goes to the artist's master context, the body of `artists/<slug>/_artist.md`, or to the project's summary. Prose goes through the mirror file.",
+    "- **What happened today** goes to `artists/<slug>/daily-log.md`, a dated entry per artist touched. Local-only and rolling, and never the place for a durable fact.",
+    "",
+    "## Step 4: memory, in two piles",
+    "",
+    "The two piles are treated differently on purpose, and the difference is not politeness. A wrong line in **shared** memory reaches every member on every machine and is injected into every future session. A wrong line in a member's **own** memory is theirs to prune.",
+    "",
+    "### Private: `user-memory.md` at the mirror root. Write it directly.",
+    "",
+    "Facts true of this member: how they write, how they sign off, what they prefer, their own identifiers. No gate. **List what you wrote in the closing summary**, so it is visible without opening the file.",
+    "",
+    "### Shared: `workspace-memory.md` at the mirror root. Propose. Never write unasked.",
+    "",
+    "Draft the candidate lines first: durable facts about this workspace that would change how a future session behaves, not this session's detail.",
+    "",
+    "**Each line has a required shape, and it is the file's own, not this command's.** `workspace-memory.md` is an INDEX, and the grounding block tells every future session that each line is a one-line hook pointing via a `[[wikilink]]` to the warm store where the full detail lives. So a line carries: the hook, a `[[wikilink]]` to where the detail actually is, an **absolute** date (turn \"last week\" into a real one), and what taught you it. **A line with no warm store behind it makes the grounding block lie to every session that loads it.** Read the file's header comment and follow the conventions there; where it and this command disagree, the file wins.",
+    "",
+    "Then put the candidates to the user with **`AskUserQuestion`**:",
+    "",
+    "- **One multi-select question, one option per proposed line.** Selected means bank it. Unselected means rejected.",
+    '- **The free-text "Other" choice is how the user rewrites a line in their own words.** Their wording wins over yours, always.',
+    "- The tool takes **four options per question and four questions**. If you have more than four candidate lines, you are banking session detail rather than durable facts: **say so and cut the list. Do not paginate.**",
+    "",
+    "**An accepted line that contradicts one already in the file supersedes it in place.** Edit the wrong line. Never leave two lines disagreeing.",
+    "",
+    "## Step 5: log every decision, then write the file",
+    "",
+    "**In that order.** The log is the record of what was decided; the file is the consequence.",
+    "",
+    "```sh",
+    'plinth memory-gate log --proposed "<the line as you put it>" --decision accept',
+    'plinth memory-gate log --proposed "<the line as you put it>" --decision reject',
+    'plinth memory-gate log --proposed "<the line as you put it>" --decision edit --final "<their rewrite>"',
+    "```",
+    "",
+    "A close that proposed nothing still logs, because *gated and proposed nothing* has to stay distinguishable from *never gated*:",
+    "",
+    "```sh",
+    "plinth memory-gate log --nothing-proposed",
+    "```",
+    "",
+    "`plinth memory-gate show [--json]` reads the log back.",
+    "",
+    "**Four rules. Break one and a decision is lost:**",
+    "",
+    "1. `--decision edit` **requires** `--final`. The rewrite is the record: it is the user's own words for their own standard, and it is the most valuable row in the log.",
+    "2. `--final` is **refused** on `accept` and `reject`. An accept records the proposed line; a reject records none.",
+    "3. `--nothing-proposed` **cannot** be combined with `--proposed` or `--decision`.",
+    '4. **`memory-gate` fails LOUD**: exit 1, with a message on stderr. **Surface it. Never swallow it.** A silently dropped decision produces exactly the "never gated" state the log exists to make visible, while looking like a clean close. If it fails, tell the user, and do not report the line as banked.',
+    "",
+    "**Never write this log by hand.** The CLI owns the format so it can still be read back in a year.",
+    "",
+    "Only once the decisions are logged, write the accepted lines into `workspace-memory.md`.",
+    "",
+    "## Step 6: summarise, then end the session",
+    "",
+    "**Four to six lines**, and no file-by-file dump: what now lives on a durable surface, what is still in flight and on whom, what was banked to memory (private and shared), and the obvious next move.",
+    "",
+    "Then, as the **very last step**:",
+    "",
+    "```sh",
+    'plinth session end --summary "<one line>"',
+    "```",
+    "",
+    "This is the opposite of `memory-gate`: it **always exits 0 and always prints nothing**, whatever happens. It marks this session ended, and when it is running inside the Plinth desktop dock it tells the dock the session is finished so the tab can close itself. **Outside the dock it does nothing visible, and that is correct.** Nothing in this command depends on the dock; it runs the same in a bare terminal."
+  ]);
+}
+function ensureWorkspaceCommands(deps) {
+  const { workspaceSlug, force, out, now } = deps;
+  const created = [];
+  const refreshed = [];
+  const targets = [
+    [START_COMMAND_REL, buildStartCommandMd()],
+    [CLOSE_COMMAND_REL, buildCloseCommandMd()]
+  ];
+  for (const [rel, generated] of targets) {
+    const existing = readContextFile(workspaceSlug, rel);
+    const decision = decideRegen({ existing, currentVersion: "", generated, force });
+    if (decision.action === "backup-regen" && decision.backup !== undefined) {
+      const bakRel = `${rel}.bak-${backupStamp2(now())}`;
+      writeContextFile(workspaceSlug, bakRel, decision.backup);
+      out.warn(`${rel} had no recognisable BEGIN/END markers; backed your copy up to ` + `${bakRel} before regenerating.`);
+    }
+    if (decision.content !== null) {
+      writeContextFile(workspaceSlug, rel, decision.content);
+      (decision.action === "create" ? created : refreshed).push(invocationFor(rel));
+    }
+  }
+  if (created.length > 0) {
+    out.info(`Generated ${created.join(" and ")}.`);
+  }
+  if (refreshed.length > 0) {
+    out.info(`Refreshed ${refreshed.join(" and ")} (your edits preserved).`);
   }
-  return decision.action === "create";
-}
-function ensureStub(workspaceSlug, relativePath, content) {
-  if (existsSync(contextFilePath(workspaceSlug, relativePath)))
-    return;
-  writeContextFile(workspaceSlug, relativePath, content);
-}
-function dailyLogStub(name) {
-  return `# ${name} - Daily log
-
-` + `<!-- Rolling activity, newest first; edit freely, Plinth never overwrites this file. -->
-`;
 }
-function backupStamp(d2) {
+function backupStamp2(d2) {
   return d2.toISOString().replace(/[-:.]/g, "").replace("Z", "");
 }
 
-// src/lib/context/generate.ts
-import { existsSync as existsSync2 } from "node:fs";
-
 // src/lib/context/workspace-claude-md.ts
 function rosterBlock(roster, activeProjectCountBySlug) {
   if (roster.length === 0)
@@ -28495,7 +29531,7 @@ function buildWorkspaceClaudeMd(input) {
   const skillCount = SKILL_LOCATIONS.length;
   const lines = [
     `<!-- plinth-schema-version: ${schemaVersion} -->`,
-    `<!-- Auto-generated by Plinth. Edit only between the BEGIN/END markers below; everything else is overwritten on sync. -->`,
+    `<!-- Auto-generated by Plinth. ${GENERATED_AT_PREFIX}${GENERATED_AT_PLACEHOLDER}; ` + `that stamp moves only when this file's content changes, so an unchanged file keeps an older one ` + `and is still re-checked against Plinth on every sync. Run \`plinth status\` for when the mirror last synced. ` + `Edit only between the BEGIN/END markers below; everything else is overwritten on sync. -->`,
     ``,
     `# ${workspaceName} · Plinth workspace`,
     ``,
@@ -28503,17 +29539,20 @@ function buildWorkspaceClaudeMd(input) {
     ``,
     `> **Session grounding**: the current date, an entity-resolution rule, and a write-confirmation rule are injected at every session start by the Plinth hook in \`.claude/settings.json\` (and each \`artists/<slug>/.claude/settings.json\`).`,
     ``,
+    `> **Filing a file the user hands you - BOTH halves, and the first one is unconditional**: put a copy in \`files/\`, which is how Plinth gets the text (folder map below) - do this even if everything else here fails. Then put the **original** in the user's own file storage with whatever tool you have for that, and write down where it went somewhere durable: \`artists/<slug>/memory.md\` if it is that artist's, otherwise \`workspace-memory.md\`. A pointer that exists only in this conversation is lost when it ends. If you have no tool that reaches their file storage, SAY SO - do not leave them believing the original was filed.`,
+    ``,
     `## Folder map`,
     `- \`artists/<slug>/\` one folder per artist, the working dir for artist-scoped sessions · \`threads/<slug>/_thread.md\` one folder per thread`,
     `- \`projects/\` \`tasks/\` \`documents/\` \`meetings/\` workspace-root flat entity files (one \`.md\` per entity, NOT nested under \`artists/\`)`,
     `- \`files/\` free-form document store: PDFs, executed agreements, spreadsheets, anything that is a FILE rather than an entity. Mirrored byte-for-byte both ways, folders and all`,
-    `- \`.claude/commands/\` local skills · at the mirror root: \`workspace-memory.md\` \`workspace-rules.md\` (workspace-wide) + \`user-memory.md\` (yours), synced to Plinth · \`CLAUDE.local.md\` private, gitignored`,
+    `- \`${extractedTextRelPath("<path>")}\` where \`<path>\` is the file's path under \`files/\`: the text Plinth extracted from that file, so a PDF's contents can be searched. Not every file has one - text files are already their own text, and extraction can fail. Where it produced junk the file exists and says so instead of carrying it, so read what is there before trusting a silence. Derived: edits here are overwritten and never reach Plinth`,
+    `- \`.claude/commands/\` local skills, incl. generated \`${START_COMMAND_INVOCATION}\` + \`${CLOSE_COMMAND_INVOCATION}\` · at the mirror root: \`workspace-memory.md\` \`workspace-rules.md\` (workspace-wide) + \`user-memory.md\` (yours), synced to Plinth · \`CLAUDE.local.md\` private, gitignored`,
     ``,
     `## Where key context lives: look here before hunting`,
     `- Each artist's **master context** (stable profile + current state) → \`artists/<slug>/_artist.md\`; edit its body and the daemon syncs both ways. Blocks labelled "rendered from Plinth" are the exception: they are overwritten on the next sync`,
     `- **Contracts, executed agreements & any PDF** → \`files/\` (search here first; \`documents/\` holds markdown bodies, not attachments)`,
     `- Workspace-wide **notes, briefs, bios & context docs** → \`documents/\` (one markdown file per doc, shared across artists)`,
-    `- Per-artist long-term facts → \`artists/<slug>/memory.md\` · daily activity → \`artists/<slug>/daily-log.md\``,
+    `- Per-artist long-term facts → \`artists/<slug>/memory.md\`, which syncs to that artist's Plinth record; most have none yet, and creating the file is how you start one · rolling activity → \`artists/<slug>/daily-log.md\`, local-only and never the place for a durable fact`,
     `- ${MCP_AVAILABILITY_POINTER}`,
     ``,
     `## Entity model: ${MCP_INTROSPECTION_POINTER}`,
@@ -28571,19 +29610,21 @@ function ensureWorkspaceContext(deps) {
     existing,
     currentVersion: "",
     generated,
-    force
+    force,
+    normalise: normaliseGeneratedAt
   });
   if (decision.action === "backup-regen" && decision.backup !== undefined) {
-    const bakRel = `${CLAUDE_MD}.bak-${backupStamp2(now())}`;
+    const bakRel = `${CLAUDE_MD}.bak-${backupStamp3(now())}`;
     writeContextFile(workspaceSlug, bakRel, decision.backup);
     out.warn(`${CLAUDE_MD} had no recognisable BEGIN/END markers; backed your copy ` + `up to ${bakRel} before regenerating.`);
   }
   if (decision.content !== null) {
-    writeContextFile(workspaceSlug, CLAUDE_MD, decision.content);
+    writeContextFile(workspaceSlug, CLAUDE_MD, renderGeneratedAt(decision.content, now()));
   }
   if (!existsSync2(contextFilePath(workspaceSlug, CLAUDE_LOCAL_MD))) {
     writeContextFile(workspaceSlug, CLAUDE_LOCAL_MD, CLAUDE_LOCAL_STUB);
   }
+  ensureWorkspaceCommands({ workspaceSlug, force, out, now });
   ensureGitignore(workspaceSlug);
   const resolved = resolvePlinthBinary();
   reportResolution(out, resolved);
@@ -28615,7 +29656,7 @@ function ensureGitignore(workspaceSlug) {
 `;
   writeContextFile(workspaceSlug, GITIGNORE, `${existing}${lead}${block}`);
 }
-function backupStamp2(d2) {
+function backupStamp3(d2) {
   return d2.toISOString().replace(/[-:.]/g, "").replace("Z", "");
 }
 
@@ -28824,12 +29865,12 @@ function classify(facts) {
 }
 
 // src/lib/review-tier/collect.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import fs2 from "node:fs";
 import path3 from "node:path";
 function execGit(args, cwd) {
   try {
-    const stdout2 = execFileSync2("git", args, {
+    const stdout2 = execFileSync3("git", args, {
       cwd,
       encoding: "utf8",
       maxBuffer: 64 * 1024 * 1024,
@@ -29047,16 +30088,280 @@ var reviewTierCommand = defineCommand({
   }
 });
 
+// src/commands/session.ts
+init_output();
+async function defaultReadStdin() {
+  if (process.stdin.isTTY)
+    return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function resolveSlug(explicit) {
+  let config2;
+  try {
+    config2 = loadConfig();
+  } catch {
+    return { ok: false, reason: "unconfigured" };
+  }
+  if (!config2)
+    return { ok: false, reason: "unconfigured" };
+  const slug = explicit ?? config2.active_workspace;
+  if (!config2.workspaces[slug]) {
+    return explicit === undefined ? { ok: false, reason: "unconfigured" } : { ok: false, reason: "unknown-workspace", slug };
+  }
+  return { ok: true, slug };
+}
+async function runSessionRegister(args, deps = {}) {
+  const env3 = deps.env ?? process.env;
+  const raw = await (deps.readStdin ?? defaultReadStdin)().catch(() => "");
+  let payload = {};
+  if (raw.trim().length > 0) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        payload = parsed;
+      }
+    } catch {}
+  }
+  const sessionId = asString(payload.session_id) ?? asString(env3.CLAUDE_CODE_SESSION_ID);
+  const cwd = asString(payload.cwd) ?? (deps.cwd ?? process.cwd)();
+  const transcriptPath = asString(payload.transcript_path);
+  const tabId = asString(env3.PLINTH_DOCK_TAB_ID);
+  const pidRaw = asString(env3.CLAUDE_PID);
+  const pid = pidRaw !== null ? Number.parseInt(pidRaw, 10) : Number.NaN;
+  if (sessionId === null || !isSafeSegment(sessionId))
+    return { exitCode: 0 };
+  if (!Number.isInteger(pid) || pid <= 0)
+    return { exitCode: 0 };
+  const resolved = resolveSlug(args.workspace);
+  if (!resolved.ok)
+    return { exitCode: 0 };
+  try {
+    registerSession({
+      sessionId,
+      pid,
+      cwd,
+      workspaceSlug: resolved.slug,
+      transcriptPath,
+      tabId,
+      now: (deps.now ?? (() => new Date))(),
+      startTimeFn: deps.startTimeFn
+    });
+  } catch {}
+  return { exitCode: 0 };
+}
+function buildSessionListJson(workspaceSlug, live, reaped, unchecked, selfPid, selfSessionId, ended = 0) {
+  return {
+    workspace_slug: workspaceSlug,
+    self_pid: selfPid,
+    self_session_id: selfSessionId,
+    sessions: live.map((s2) => ({
+      session_id: s2.record.session_id,
+      pid: s2.record.pid,
+      cwd: s2.record.cwd,
+      started_at: s2.record.started_at,
+      last_activity: s2.lastActivityMs === null ? null : new Date(s2.lastActivityMs).toISOString(),
+      is_self: s2.record.session_id === selfSessionId || selfPid !== null && s2.record.pid === selfPid,
+      tab_id: s2.record.tab_id
+    })),
+    reaped,
+    unchecked,
+    ended,
+    scope: "machine-local"
+  };
+}
+async function runSessionList(args, deps = {}) {
+  const out = new Output({ sink: deps.sink, noColor: deps.noColor ?? args.noColor });
+  const env3 = deps.env ?? process.env;
+  const resolved = resolveSlug(args.workspace);
+  if (!resolved.ok) {
+    out.error(resolved.reason === "unknown-workspace" ? `Workspace "${resolved.slug}" not found. Run \`plinth login --workspace ${resolved.slug}\` first.` : "No workspace configured. Run `plinth login --workspace <slug>` first.");
+    return { exitCode: 1 };
+  }
+  const slug = resolved.slug;
+  const { live, reaped, unknown: unknown2, ended } = listSessions(slug, deps);
+  const selfPidRaw = asString(env3.CLAUDE_PID);
+  const selfPid = selfPidRaw !== null ? Number.parseInt(selfPidRaw, 10) : null;
+  const selfSessionId = asString(env3.CLAUDE_CODE_SESSION_ID);
+  if (args.json) {
+    out.info(JSON.stringify(buildSessionListJson(slug, live, reaped, unknown2, Number.isInteger(selfPid) ? selfPid : null, selfSessionId, ended), null, 2));
+    return { exitCode: 0 };
+  }
+  const now = (deps.now ?? (() => new Date))();
+  for (const line of renderSessionLines(live, now, selfPid, selfSessionId)) {
+    out.info(line);
+  }
+  for (const line of sessionCaveats(live.length, unknown2, ended))
+    out.info(line);
+  return { exitCode: 0 };
+}
+var DOCK_CLOSED_ROUTE = "/closed";
+var DOCK_SIGNAL_TIMEOUT_MS = 1000;
+var SUMMARY_MAX_CHARS = 2000;
+function readDockSignalEnv(env3) {
+  const port = asString(env3.PLINTH_DOCK_SIGNAL_PORT);
+  const token = asString(env3.PLINTH_DOCK_SIGNAL_TOKEN);
+  const tabId = asString(env3.PLINTH_DOCK_TAB_ID);
+  if (port === null || token === null || tabId === null)
+    return null;
+  if (!/^[0-9]{1,5}$/.test(port))
+    return null;
+  return { port, token, tabId };
+}
+function normaliseSummary(raw) {
+  if (raw === undefined)
+    return null;
+  const folded = raw.replace(/\s+/g, " ").trim();
+  if (folded.length === 0)
+    return null;
+  return folded.length > SUMMARY_MAX_CHARS ? folded.slice(0, SUMMARY_MAX_CHARS) : folded;
+}
+var defaultFetch = (url2, init2) => fetch(url2, init2);
+async function runSessionEnd(args, deps = {}) {
+  const env3 = deps.env ?? process.env;
+  const now = (deps.now ?? (() => new Date))();
+  const sessionId = asString(env3.CLAUDE_CODE_SESSION_ID);
+  if (sessionId !== null && isSafeSegment(sessionId)) {
+    const resolved = resolveSlug(args.workspace);
+    if (resolved.ok) {
+      try {
+        endSession(resolved.slug, sessionId, now);
+      } catch {}
+    }
+  }
+  const dock = readDockSignalEnv(env3);
+  if (dock === null)
+    return { exitCode: 0 };
+  const body = JSON.stringify({ summary: normaliseSummary(args.summary) });
+  try {
+    await (deps.fetchFn ?? defaultFetch)(`http://127.0.0.1:${dock.port}${DOCK_CLOSED_ROUTE}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-plinth-token": dock.token,
+        "x-plinth-tab": dock.tabId
+      },
+      body,
+      signal: AbortSignal.timeout(DOCK_SIGNAL_TIMEOUT_MS)
+    });
+  } catch {}
+  return { exitCode: 0 };
+}
+function renderSessionLines(live, now, selfPid, selfSessionId, formatRelative = defaultRelative) {
+  if (live.length === 0)
+    return ["No Claude sessions registered on this machine."];
+  return live.map((s2) => {
+    const isSelf = s2.record.session_id === selfSessionId || selfPid !== null && s2.record.pid === selfPid;
+    const activity = s2.lastActivityMs === null ? "activity unknown" : `active ${formatRelative(now.getTime() - s2.lastActivityMs)}`;
+    const tag = isSelf ? " (this session)" : "";
+    const tab = s2.record.tab_id === null ? "" : ` · tab ${s2.record.tab_id}`;
+    return `${s2.record.session_id.slice(0, 8)} · pid ${s2.record.pid}${tab} · ${activity} · ${s2.record.cwd}${tag}`;
+  });
+}
+function sessionCaveats(liveCount, unknown2, ended = 0) {
+  const lines = [];
+  if (liveCount > 1) {
+    lines.push("Visibility only - nothing here prevents a conflicting write.");
+  }
+  if (ended > 0) {
+    lines.push(`${ended} session${ended === 1 ? " has" : "s have"} run \`plinth session end\` but ${ended === 1 ? "its process is" : "their processes are"} still alive - not listed above.`);
+  }
+  if (unknown2 > 0) {
+    lines.push(`${unknown2} record${unknown2 === 1 ? "" : "s"} could not be checked and ${unknown2 === 1 ? "is" : "are"} not listed.`);
+  }
+  lines.push("Machine-local - a session on another machine is not counted.");
+  return lines;
+}
+function defaultRelative(deltaMs) {
+  const s2 = Math.floor(Math.max(0, deltaMs) / 1000);
+  if (s2 < 60)
+    return `${s2}s ago`;
+  const m2 = Math.floor(s2 / 60);
+  if (m2 < 60)
+    return `${m2}m ago`;
+  const h2 = Math.floor(m2 / 60);
+  if (h2 < 24)
+    return `${h2}h ago`;
+  return `${Math.floor(h2 / 24)}d ago`;
+}
+var sessionCommand = defineCommand({
+  meta: {
+    name: "session",
+    description: "Concurrent Claude session visibility for this workspace"
+  },
+  subCommands: {
+    register: defineCommand({
+      meta: {
+        name: "register",
+        description: "Record this Claude session (SessionStart hook; fail-quiet)"
+      },
+      args: {
+        workspace: { type: "string", description: "Workspace slug" }
+      },
+      async run({ args }) {
+        const result = await runSessionRegister({
+          workspace: args.workspace
+        });
+        process.exitCode = result.exitCode;
+      }
+    }),
+    list: defineCommand({
+      meta: {
+        name: "list",
+        description: "List live Claude sessions writing this workspace"
+      },
+      args: {
+        workspace: { type: "string", description: "Workspace slug" },
+        json: { type: "boolean", description: "Machine-readable output" },
+        "no-color": { type: "boolean", description: "Disable colour" }
+      },
+      async run({ args }) {
+        const result = await runSessionList({
+          workspace: args.workspace,
+          json: args.json
+        }, { noColor: noColorFromArgs(args) });
+        process.exitCode = result.exitCode;
+      }
+    }),
+    end: defineCommand({
+      meta: {
+        name: "end",
+        description: "Mark this Claude session ended and, inside the desktop dock, tell the dock (last step of /close; fail-quiet)"
+      },
+      args: {
+        workspace: { type: "string", description: "Workspace slug" },
+        summary: {
+          type: "string",
+          description: "One-line summary of the session, forwarded to the dock"
+        }
+      },
+      async run({ args }) {
+        const result = await runSessionEnd({
+          workspace: args.workspace,
+          summary: args.summary
+        });
+        process.exitCode = result.exitCode;
+      }
+    })
+  }
+});
+
 // src/commands/start.ts
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync18, statSync as statSync10 } from "node:fs";
+import { readFileSync as readFileSync20, statSync as statSync12 } from "node:fs";
 
 // src/lib/daemon-log.ts
-import { appendFileSync, mkdirSync as mkdirSync5, renameSync as renameSync5, statSync as statSync2 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8, renameSync as renameSync7, statSync as statSync4 } from "node:fs";
+import { dirname as dirname6, join as join9 } from "node:path";
 var DEFAULT_DAEMON_LOG_MAX_BYTES = 5000000;
 function daemonLogPath() {
-  return join6(plinthHome(), "daemon.log");
+  return join9(plinthHome(), "daemon.log");
 }
 function daemonLogMaxBytes() {
   const raw = process.env.PLINTH_DAEMON_LOG_MAX_BYTES;
@@ -29078,10 +30383,10 @@ class DaemonLog {
     this.now = opts.now ?? (() => new Date);
     this.maxBytes = opts.maxBytes ?? daemonLogMaxBytes();
     try {
-      mkdirSync5(dirname4(this.path), { recursive: true });
+      mkdirSync8(dirname6(this.path), { recursive: true });
     } catch {}
     try {
-      this.bytesWritten = statSync2(this.path).size;
+      this.bytesWritten = statSync4(this.path).size;
     } catch {
       this.bytesWritten = 0;
     }
@@ -29094,7 +30399,7 @@ class DaemonLog {
     const bytes = Buffer.byteLength(line);
     try {
       this.maybeRotate(bytes);
-      appendFileSync(this.path, line);
+      appendFileSync2(this.path, line);
       this.bytesWritten += bytes;
     } catch {
       try {
@@ -29108,97 +30413,16 @@ class DaemonLog {
   }
   rotate() {
     try {
-      renameSync5(this.path, `${this.path}.1`);
+      renameSync7(this.path, `${this.path}.1`);
     } catch {}
     this.bytesWritten = 0;
   }
 }
 
-// src/lib/daemon-pid.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync8, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname5, join as join7 } from "node:path";
-var DaemonPidSchema = exports_external.object({
-  version: exports_external.literal(1),
-  pid: exports_external.number().int().positive(),
-  workspace_slug: exports_external.string().min(1),
-  started_at: exports_external.string().min(1)
-});
-function daemonPidPath(workspaceSlug) {
-  return join7(plinthHome(), `daemon-${workspaceSlug}.pid`);
-}
-function daemonPidTmpPath(workspaceSlug) {
-  return join7(plinthHome(), `daemon-${workspaceSlug}.pid.tmp`);
-}
-function writeDaemonPid(workspaceSlug, pid, startedAt) {
-  const file2 = {
-    version: 1,
-    pid,
-    workspace_slug: workspaceSlug,
-    started_at: startedAt.toISOString()
-  };
-  const target = daemonPidPath(workspaceSlug);
-  const tmp = daemonPidTmpPath(workspaceSlug);
-  mkdirSync6(dirname5(target), { recursive: true, mode: 448 });
-  writeFileSync5(tmp, JSON.stringify(file2, null, 2) + `
-`, { mode: 384 });
-  try {
-    renameSync6(tmp, target);
-  } catch (err) {
-    try {
-      unlinkSync5(tmp);
-    } catch {}
-    throw err;
-  }
-}
-function readDaemonPid(workspaceSlug) {
-  let raw;
-  try {
-    raw = readFileSync8(daemonPidPath(workspaceSlug), "utf8");
-  } catch (err) {
-    if (err?.code === "ENOENT")
-      return null;
-    throw err;
-  }
-  let json2;
-  try {
-    json2 = JSON.parse(raw);
-  } catch {
-    return null;
-  }
-  const parsed = DaemonPidSchema.safeParse(json2);
-  return parsed.success ? parsed.data : null;
-}
-function clearDaemonPid(workspaceSlug) {
-  try {
-    unlinkSync5(daemonPidPath(workspaceSlug));
-  } catch (err) {
-    if (err?.code === "ENOENT")
-      return;
-    throw err;
-  }
-}
-function isPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err?.code === "EPERM";
-  }
-}
-function readLiveDaemon(workspaceSlug, aliveFn = isPidAlive) {
-  const pidFile = readDaemonPid(workspaceSlug);
-  if (!pidFile)
-    return null;
-  if (aliveFn(pidFile.pid))
-    return pidFile;
-  clearDaemonPid(workspaceSlug);
-  return null;
-}
-
 // src/lib/destructive-gate.ts
 var import_gray_matter7 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync9, statSync as statSync3 } from "node:fs";
-import { basename as basename2 } from "node:path";
+import { readFileSync as readFileSync11, statSync as statSync5 } from "node:fs";
+import { basename as basename3 } from "node:path";
 var GUTTING_RATIO_DEFAULT = 0.5;
 var GUTTING_MIN_PRIOR_BYTES = 200;
 function envFloat(name, def) {
@@ -29241,10 +30465,10 @@ function classifyDestructive(event, entityType, state, deps = {}) {
       absolutePath: event.absolutePath
     };
   }
-  const readFile = deps.readFile ?? ((p) => readFileSync9(p, "utf8"));
+  const readFile = deps.readFile ?? ((p) => readFileSync11(p, "utf8"));
   const statInode = deps.statInode ?? ((p) => {
     try {
-      return statSync3(p).ino;
+      return statSync5(p).ino;
     } catch {
       return;
     }
@@ -29263,7 +30487,7 @@ function classifyDestructive(event, entityType, state, deps = {}) {
     return null;
   }
   const liveInode = statInode(event.absolutePath);
-  const slug = basename2(event.absolutePath, ".md");
+  const slug = basename3(event.absolutePath, ".md");
   const entry2 = (liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined) ?? getEntryBySlug(state, entityType, slug);
   if (!entry2)
     return null;
@@ -29368,40 +30592,40 @@ class DestructiveGate {
 }
 
 // src/lib/resolve-pending.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 
 // src/lib/conflicts.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname7, join as join10 } from "node:path";
 function conflictsRoot(workspaceSlug) {
-  return join8(plinthHome(), "_conflicts", workspaceSlug);
+  return join10(plinthHome(), "_conflicts", workspaceSlug);
 }
 function conflictFilePath(args) {
   const { workspaceSlug, entityType, entitySlug, timestamp } = args;
   const iso = timestamp.toISOString().replace(/[:.]/g, "-");
-  return join8(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.md`);
+  return join10(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.md`);
 }
 function stashConflict(args) {
   const target = conflictFilePath(args);
-  mkdirSync7(dirname6(target), { recursive: true, mode: 448 });
-  writeFileSync6(target, args.contents, { mode: 384 });
+  mkdirSync9(dirname7(target), { recursive: true, mode: 448 });
+  writeFileSync7(target, args.contents, { mode: 384 });
   return target;
 }
 function fileConflictPath(args) {
   const { workspaceSlug, relPath, timestamp } = args;
   const iso = timestamp.toISOString().replace(/[:.]/g, "-");
   const safe = relPath.replace(/[/\\]/g, "__");
-  return join8(conflictsRoot(workspaceSlug), `files.${safe}.${iso}`);
+  return join10(conflictsRoot(workspaceSlug), `files.${safe}.${iso}`);
 }
 function stashFileConflict(args) {
   const target = fileConflictPath(args);
-  mkdirSync7(dirname6(target), { recursive: true, mode: 448 });
-  writeFileSync6(target, args.bytes, { mode: 384 });
+  mkdirSync9(dirname7(target), { recursive: true, mode: 448 });
+  writeFileSync7(target, args.bytes, { mode: 384 });
   return target;
 }
 
 // src/lib/files/push.ts
-import { readFileSync as readFileSync10, statSync as statSync4 } from "node:fs";
+import { readFileSync as readFileSync12, statSync as statSync6 } from "node:fs";
 
 // src/lib/log-tokens.ts
 function categorizeError(err) {
@@ -29472,6 +30696,17 @@ function pullNoticeLine(kind) {
   const token = kind === "auth" ? "PULL_PAUSED" : "PULL_DEGRADED";
   return `[${token} reason=${kind}]`;
 }
+function calendarProjectedLine(f3) {
+  return `[CALENDAR_PROJECTED written=${f3.written} pruned=${f3.pruned} ` + `calendars=${f3.calendars} not_read=${f3.notRead}]`;
+}
+function calendarFailedLine(f3) {
+  const serverPart = f3.serverMessage ? ` server_msg="${f3.serverMessage}"` : "";
+  return `[CALENDAR_FAILED status=${f3.status} reason=${f3.reason} staled=${f3.staled}${serverPart}]`;
+}
+function calendarNoticeLine(kind) {
+  const token = kind === "auth" ? "CALENDAR_PAUSED" : kind === "unsupported" ? "CALENDAR_UNSUPPORTED" : "CALENDAR_DEGRADED";
+  return `[${token} reason=${kind}]`;
+}
 
 // src/lib/rejected.ts
 import { relative as relative3 } from "node:path";
@@ -29561,6 +30796,7 @@ function clearFileRejected(state, relPath) {
 // src/lib/files/api.ts
 var MAX_WORKSPACE_FILE_BYTES = 4000000;
 var HASH_RE = /^[0-9a-f]{64}$/;
+var TextQualitySchema = exports_external.enum(["ok", "partial", "garbled"]);
 var FileLiveSchema = exports_external.object({
   id: exports_external.string().uuid(),
   path: exports_external.string().min(1),
@@ -29571,8 +30807,25 @@ var FileLiveSchema = exports_external.object({
   project_id: exports_external.string().uuid().nullable(),
   updated_at: exports_external.string().datetime({ offset: true }),
   deleted_at: exports_external.null(),
-  last_edited_by: exports_external.string().uuid().nullable()
-});
+  last_edited_by: exports_external.string().uuid().nullable(),
+  content_quality: TextQualitySchema.nullable().optional().default(null).catch(null),
+  has_extracted_text: exports_external.boolean().optional().catch(undefined),
+  has_stored_bytes: exports_external.boolean().optional().catch(undefined)
+});
+function storedBytesSignal(row) {
+  if (row.has_stored_bytes === true)
+    return "present";
+  if (row.has_stored_bytes === false)
+    return "absent";
+  return "unknown";
+}
+function extractedTextSignal(row) {
+  if (row.has_extracted_text === true)
+    return "present";
+  if (row.has_extracted_text === false)
+    return "absent";
+  return "unknown";
+}
 var FileTombstoneSchema = exports_external.object({
   id: exports_external.string().uuid(),
   path: exports_external.string().min(1),
@@ -29585,7 +30838,18 @@ var FilesPageSchema = exports_external.object({
   next_cursor: exports_external.string().nullable()
 });
 var FileWithDownloadSchema = FileLiveSchema.extend({
-  download_url: exports_external.string().url()
+  download_url: exports_external.string().url().nullable()
+});
+var FileTextSchema = exports_external.object({
+  id: exports_external.string().uuid(),
+  path: exports_external.string().min(1),
+  mime_type: exports_external.string(),
+  updated_at: exports_external.string().datetime({ offset: true }),
+  content_quality: TextQualitySchema.nullable(),
+  source_uri: exports_external.string().nullable(),
+  text: exports_external.string().nullable(),
+  chars: exports_external.number().int().nonnegative(),
+  withheld: exports_external.enum(["bytes_are_text", "no_text"]).nullable()
 });
 var PreconditionSchema = exports_external.object({
   code: exports_external.literal("precondition_failed"),
@@ -29624,11 +30888,39 @@ async function syncFilesPage(args) {
   if (!parsed.success) {
     throw new ApiError(res.status, `sync files response did not match the expected shape: ${parsed.error.message}`);
   }
-  return { rows: parsed.data.files, next_cursor: parsed.data.next_cursor };
+  return { rows: parsed.data.files, next_cursor: parsed.data.next_cursor };
+}
+async function getFile(args) {
+  const { baseUrl, pat, id, fetchImpl = fetch } = args;
+  const url2 = `${baseUrl.replace(/\/$/, "")}/api/sync/files/${id}`;
+  let res;
+  try {
+    res = await fetchImpl(url2, { method: "GET", headers: baseHeaders(pat) });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "network error";
+    throw new ApiError(0, `Could not reach ${url2}: ${msg}`);
+  }
+  if (res.status === 404)
+    return { ok: false, code: 404 };
+  if (res.status === 401) {
+    throw new ApiError(401, "Token was rejected by the server.");
+  }
+  if (res.status === 429) {
+    throw new ApiError(429, "Rate limited by the server.", parseRetryAfterMs(res.headers.get("retry-after")));
+  }
+  if (!res.ok) {
+    throw new ApiError(res.status, `get file failed with HTTP ${res.status}`);
+  }
+  const body = await res.json();
+  const parsed = FileWithDownloadSchema.safeParse(body);
+  if (!parsed.success) {
+    throw new ApiError(res.status, `get file response did not match the expected shape`);
+  }
+  return { ok: true, row: parsed.data };
 }
-async function getFile(args) {
+async function getFileText(args) {
   const { baseUrl, pat, id, fetchImpl = fetch } = args;
-  const url2 = `${baseUrl.replace(/\/$/, "")}/api/sync/files/${id}`;
+  const url2 = `${baseUrl.replace(/\/$/, "")}/api/sync/files/${id}/text`;
   let res;
   try {
     res = await fetchImpl(url2, { method: "GET", headers: baseHeaders(pat) });
@@ -29639,18 +30931,18 @@ async function getFile(args) {
   if (res.status === 404)
     return { ok: false, code: 404 };
   if (res.status === 401) {
-    throw new ApiError(401, "Token was rejected by the server.");
+    throw new ApiError(401, "Token was rejected by the server. Run `plinth login --workspace <slug>` to refresh.");
   }
   if (res.status === 429) {
     throw new ApiError(429, "Rate limited by the server.", parseRetryAfterMs(res.headers.get("retry-after")));
   }
   if (!res.ok) {
-    throw new ApiError(res.status, `get file failed with HTTP ${res.status}`);
+    throw new ApiError(res.status, `get file text failed with HTTP ${res.status}`);
   }
   const body = await res.json();
-  const parsed = FileWithDownloadSchema.safeParse(body);
+  const parsed = FileTextSchema.safeParse(body);
   if (!parsed.success) {
-    throw new ApiError(res.status, `get file response did not match the expected shape`);
+    throw new ApiError(res.status, `get file text response did not match the expected shape: ${parsed.error.message}`);
   }
   return { ok: true, row: parsed.data };
 }
@@ -29845,13 +31137,13 @@ function dropFiles(state, relPath) {
 }
 function safeInode(absolutePath) {
   try {
-    return statSync4(absolutePath).ino;
+    return statSync6(absolutePath).ino;
   } catch {
     return;
   }
 }
 async function restoreFileFromCloud(args) {
-  const { workspaceSlug, baseUrl, pat, id, relPath, state, fetchImpl, suppressor } = args;
+  const { workspaceSlug, baseUrl, pat, id, relPath, state, fetchImpl, suppressor, output } = args;
   const got = await getFile({ baseUrl, pat, id, fetchImpl });
   const abs = filesSubtreePath(workspaceSlug, relPath);
   if (!got.ok) {
@@ -29859,12 +31151,17 @@ async function restoreFileFromCloud(args) {
     deleteFilesFile(workspaceSlug, relPath);
     return dropFiles(state, relPath);
   }
+  if (got.row.download_url === null) {
+    output?.warn(`files/${relPath}: Plinth holds no bytes for this file, so there is nothing to restore from cloud — the local copy and its state were left exactly as they are.`);
+    return state;
+  }
   const bytes = await downloadBytes(got.row.download_url, fetchImpl);
   suppressor?.registerWrite(abs, {
     bodyHash: got.row.content_hash,
     frontmatterHash: ""
   });
   writeFilesBytes(workspaceSlug, relPath, bytes);
+  deleteExtractedText(workspaceSlug, relPath);
   return persistFiles(state, {
     id: got.row.id,
     path: relPath,
@@ -29893,7 +31190,7 @@ async function pushFilesUpsert(args) {
   } else {
     let st;
     try {
-      st = statSync4(absolutePath);
+      st = statSync6(absolutePath);
     } catch (err) {
       if (err?.code === "ENOENT") {
         return pushFilesDelete({ workspaceSlug, baseUrl, pat, relPath, state, deps });
@@ -29928,7 +31225,7 @@ async function pushFilesUpsert(args) {
         state: next
       };
     }
-    bytes = readFileSync10(absolutePath);
+    bytes = readFileSync12(absolutePath);
     hash2 = sha256Bytes(bytes);
     inode = st.ino;
   }
@@ -29999,7 +31296,8 @@ async function pushFilesUpsert(args) {
       relPath,
       state,
       fetchImpl,
-      suppressor
+      suppressor,
+      output
     });
   }
   return { outcome: { kind: "conflict", relPath, stashPath }, state: nextState };
@@ -30036,7 +31334,8 @@ async function pushFilesDelete(args) {
     relPath,
     state,
     fetchImpl,
-    suppressor
+    suppressor,
+    output
   });
   return { outcome: { kind: "conflict", relPath, stashPath: "" }, state: nextState };
 }
@@ -30063,12 +31362,12 @@ class PerIdMutex {
 
 // src/lib/push.ts
 var import_gray_matter9 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync12, statSync as statSync5 } from "node:fs";
-import { basename as basename3, relative as relative4 } from "node:path";
+import { readFileSync as readFileSync14, statSync as statSync7 } from "node:fs";
+import { basename as basename4, relative as relative4 } from "node:path";
 
 // src/lib/pull-write.ts
 var import_gray_matter8 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 function computeMirrorHashes(strategy, content) {
   const parsed = import_gray_matter8.default(content);
   const fm = parsed.data ?? {};
@@ -30090,7 +31389,7 @@ function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor)
     const target = entityFilePath(workspaceSlug, strategy.type, doc2.slug);
     let existing = null;
     try {
-      existing = readFileSync11(target, "utf8");
+      existing = readFileSync13(target, "utf8");
     } catch (err) {
       if (err?.code !== "ENOENT")
         throw err;
@@ -30161,7 +31460,7 @@ function omitKeys(obj, keys) {
 }
 function safeInode2(absolutePath) {
   try {
-    return statSync5(absolutePath).ino;
+    return statSync7(absolutePath).ino;
   } catch {
     return;
   }
@@ -30181,7 +31480,7 @@ function dropEntry(state, entityType, id) {
 function stampStateFromMirror(args) {
   const { strategy, workspaceSlug, doc: doc2, state, priorMemoryHash } = args;
   const mirrorPath = entityFilePath(workspaceSlug, strategy.type, doc2.slug);
-  const mirrorRaw = readFileSync12(mirrorPath, "utf8");
+  const mirrorRaw = readFileSync14(mirrorPath, "utf8");
   const mirrorParsed = import_gray_matter9.default(mirrorRaw);
   const mirrorFm = mirrorParsed.data ?? {};
   const mirrorLifted = splitUserFrontmatter(strategy, mirrorFm);
@@ -30260,7 +31559,7 @@ async function pushFile(args) {
   }
   let raw;
   try {
-    raw = readFileSync12(absolutePath, "utf8");
+    raw = readFileSync14(absolutePath, "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") {
       return runPushDelete({
@@ -30294,7 +31593,7 @@ async function pushFile(args) {
     const rel = relative4(workspaceMirrorPath(workspaceSlug), absolutePath);
     parsedSlug = strategy.parseMirrorPath(rel)?.slug ?? null;
   } catch {}
-  const slugFromPath = parsedSlug ?? basename3(absolutePath, ".md");
+  const slugFromPath = parsedSlug ?? basename4(absolutePath, ".md");
   const slug = slugFromFm ?? slugFromPath;
   if (!slug) {
     return {
@@ -30377,9 +31676,9 @@ async function reconcileContextDocConflict(args) {
   let fileSlug;
   try {
     const rel = relative4(workspaceMirrorPath(workspaceSlug), absolutePath);
-    fileSlug = strategy.parseMirrorPath(rel)?.slug ?? basename3(absolutePath, ".md");
+    fileSlug = strategy.parseMirrorPath(rel)?.slug ?? basename4(absolutePath, ".md");
   } catch {
-    fileSlug = basename3(absolutePath, ".md");
+    fileSlug = basename4(absolutePath, ".md");
   }
   if (fileSlug !== existingSlug) {
     const stashPath = stashConflict({
@@ -31006,7 +32305,7 @@ async function runPushDelete(args) {
       const rel = relative4(workspaceMirrorPath(args.workspaceSlug), args.absolutePath);
       parsedSlug = strategy.parseMirrorPath(rel)?.slug ?? null;
     } catch {}
-    const lookupSlug = parsedSlug ?? basename3(args.absolutePath, ".md");
+    const lookupSlug = parsedSlug ?? basename4(args.absolutePath, ".md");
     const entry2 = getEntryBySlug(args.state, strategy.type, lookupSlug);
     if (entry2) {
       id = entry2.id;
@@ -31101,9 +32400,9 @@ async function pushRename(args) {
   let toSlug;
   try {
     const rel = relative4(workspaceMirrorPath(workspaceSlug), toPath);
-    toSlug = strategy.parseMirrorPath(rel)?.slug ?? basename3(toPath, ".md");
+    toSlug = strategy.parseMirrorPath(rel)?.slug ?? basename4(toPath, ".md");
   } catch {
-    toSlug = basename3(toPath, ".md");
+    toSlug = basename4(toPath, ".md");
   }
   return mutex.run(id, async () => {
     const live = getEntry(state, entityType, id);
@@ -31133,7 +32432,7 @@ async function pushRename(args) {
       };
       if (!updated.body_hash || !updated.frontmatter_hash) {
         try {
-          const mirrorRaw = readFileSync12(toPath, "utf8");
+          const mirrorRaw = readFileSync14(toPath, "utf8");
           const mirrorParsed = import_gray_matter9.default(mirrorRaw);
           const renameFm = mirrorParsed.data ?? {};
           const renameLifted = splitUserFrontmatter(strategy, renameFm);
@@ -31168,7 +32467,7 @@ async function pushRename(args) {
     if (patchResult.reason === "slug_conflict") {
       let contents2 = "";
       try {
-        contents2 = readFileSync12(toPath, "utf8");
+        contents2 = readFileSync14(toPath, "utf8");
       } catch {}
       const stashPath2 = stashConflict({
         workspaceSlug,
@@ -31208,7 +32507,7 @@ async function pushRename(args) {
     }
     let contents = "";
     try {
-      contents = readFileSync12(toPath, "utf8");
+      contents = readFileSync14(toPath, "utf8");
     } catch {}
     const stashPath = stashConflict({
       workspaceSlug,
@@ -31329,7 +32628,7 @@ async function discardBatchOps(batch, deps) {
         const path5 = opPath(deps.workspaceSlug, op);
         let local = null;
         try {
-          local = readFileSync13(path5, "utf8");
+          local = readFileSync15(path5, "utf8");
         } catch {
           local = null;
         }
@@ -31363,7 +32662,7 @@ async function discardFileOp(op, deps) {
   const abs = filesSubtreePath(deps.workspaceSlug, op.path);
   let local = null;
   try {
-    local = readFileSync13(abs);
+    local = readFileSync15(abs);
   } catch {
     local = null;
   }
@@ -31382,7 +32681,8 @@ async function discardFileOp(op, deps) {
     id: op.id,
     relPath: op.path,
     state: deps.getState(),
-    fetchImpl: deps.fetchImpl
+    fetchImpl: deps.fetchImpl,
+    output: deps.output
   });
   deps.setState(next);
 }
@@ -31544,10 +32844,10 @@ class FileDestructiveGate {
 }
 
 // src/lib/files/reconcile.ts
-import { readFileSync as readFileSync14, statSync as statSync7 } from "node:fs";
+import { readFileSync as readFileSync16, statSync as statSync9 } from "node:fs";
 
 // src/lib/unsynced.ts
-import { join as join9, relative as relative6 } from "node:path";
+import { join as join11, relative as relative6 } from "node:path";
 var RECORDABLE_REASONS = new Set([
   "rate_limit",
   "server",
@@ -31610,7 +32910,7 @@ async function drainUnsyncedOps(args) {
     attempted += 1;
     try {
       if (op.target === "entity") {
-        const absolutePath = join9(workspaceMirrorPath(workspaceSlug), op.path);
+        const absolutePath = join11(workspaceMirrorPath(workspaceSlug), op.path);
         const classified = classifyMirrorPath({ workspaceSlug, absolutePath });
         if (!classified) {
           clear("entity", op.path);
@@ -31856,10 +33156,10 @@ class ReaddirpStream extends Readable {
   }
   async _formatEntry(dirent, path5) {
     let entry2;
-    const basename4 = this._isDirent ? dirent.name : dirent;
+    const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path5, basename4));
-      entry2 = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      const fullPath = presolve(pjoin(path5, basename5));
+      entry2 = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry2[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -32386,9 +33686,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path5);
-    const basename5 = sp.basename(path5);
+    const basename6 = sp.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename5);
+    parent.add(basename6);
     const absolutePath = sp.resolve(path5);
     const options2 = {
       persistent: opts.persistent
@@ -32398,7 +33698,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options2.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      options2.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path5, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -32416,11 +33716,11 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname8 = sp.dirname(file2);
-    const basename5 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname8);
+    const dirname9 = sp.dirname(file2);
+    const basename6 = sp.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname9);
     let prevStats = stats;
-    if (parent.has(basename5))
+    if (parent.has(basename6))
       return;
     const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -32445,9 +33745,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error52) {
-          this.fsw._remove(dirname8, basename5);
+          this.fsw._remove(dirname9, basename6);
         }
-      } else if (parent.has(basename5)) {
+      } else if (parent.has(basename6)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -33301,7 +34601,7 @@ function watch(paths, options2 = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/lib/watcher.ts
-import { statSync as statSync6 } from "node:fs";
+import { statSync as statSync8 } from "node:fs";
 import { sep as sep5 } from "node:path";
 
 // src/lib/rename-classifier.ts
@@ -33517,7 +34817,7 @@ function startWatcher(opts, handler) {
     pairingWindowMs: opts.renamePairingWindowMs ?? DEFAULT_DEBOUNCE_MS,
     classifyPath: opts.classifyPath,
     getStateEntry: opts.getStateEntry,
-    statSync: opts.statSync ?? ((p) => ({ ino: statSync6(p).ino }))
+    statSync: opts.statSync ?? ((p) => ({ ino: statSync8(p).ino }))
   });
   const factory = opts.chokidarFactory ?? ((paths, watcherOpts) => chokidar_default.watch(paths, watcherOpts));
   const watcher = factory(workspaceRoot, {
@@ -33552,7 +34852,7 @@ function readBlobForPush(args) {
   const { absolutePath, relPath, output } = args;
   let st;
   try {
-    st = statSync7(absolutePath);
+    st = statSync9(absolutePath);
   } catch (err) {
     if (err?.code === "ENOENT")
       return { kind: "gone" };
@@ -33571,7 +34871,7 @@ function readBlobForPush(args) {
   }
   let bytes;
   try {
-    bytes = readFileSync14(absolutePath);
+    bytes = readFileSync16(absolutePath);
   } catch (err) {
     if (err?.code === "ENOENT")
       return { kind: "gone" };
@@ -34099,66 +35399,813 @@ class PullLoop {
       this.timer = null;
     }
   }
-  schedule(ms) {
-    if (this.stopped)
-      return;
-    this.timer = this.setTimer(() => {
-      this.tick();
-    }, ms);
+  schedule(ms) {
+    if (this.stopped)
+      return;
+    this.timer = this.setTimer(() => {
+      this.tick();
+    }, ms);
+  }
+  async tick() {
+    if (this.stopped || this.inFlight)
+      return;
+    this.inFlight = true;
+    let nextDelay;
+    try {
+      const result = await this.runOnce();
+      nextDelay = result.exitCode === 0 ? this.onSuccess(result) : this.onFailure(result.failure);
+    } catch {
+      nextDelay = this.onFailure({ kind: "transient", status: 0 });
+    } finally {
+      this.inFlight = false;
+    }
+    this.schedule(nextDelay);
+  }
+  onSuccess(result) {
+    this.failures = 0;
+    this.capStreak = 0;
+    this.degradedAnnounced = false;
+    this.authAnnounced = false;
+    if (result.applied !== undefined && result.applied > 0) {
+      this.onApplied(result.applied);
+    }
+    this.afterPoll();
+    return this.intervalMs;
+  }
+  onFailure(failure) {
+    const kind = failure?.kind ?? "transient";
+    if (kind === "auth") {
+      if (!this.authAnnounced) {
+        this.authAnnounced = true;
+        this.notice("auth", `Pull sync paused — the server rejected the token. Run \`${this.loginHint}\`; ` + `it resumes automatically on the next retry once the token is valid, or on daemon restart.`);
+      }
+      return this.authRetryMs;
+    }
+    this.failures += 1;
+    let delay;
+    if (failure?.kind === "rate_limit" && failure.retryAfterMs !== undefined) {
+      delay = Math.min(Math.max(failure.retryAfterMs, 1000), this.capMs);
+    } else {
+      delay = Math.min(this.intervalMs * 2 ** (this.failures - 1), this.capMs);
+    }
+    this.trackCap(delay);
+    return delay;
+  }
+  trackCap(delay) {
+    this.capStreak = delay >= this.capMs ? this.capStreak + 1 : 0;
+    if (this.capStreak >= DEGRADED_CAP_STREAK && !this.degradedAnnounced) {
+      this.degradedAnnounced = true;
+      const mins = Math.round(this.capMs / 60000);
+      this.notice("degraded", `Pull sync degraded — repeated failures, retrying about every ${mins}m. ` + `Local edits still push; the mirror may be stale until the cloud is reachable again.`);
+    }
+  }
+}
+
+// src/lib/calendar-loop.ts
+var DEFAULT_CALENDAR_INTERVAL_MS = 900000;
+var CALENDAR_BACKOFF_CAP_MS = 3600000;
+var CALENDAR_AUTH_RETRY_MS = 300000;
+function calendarIntervalMs() {
+  const raw = process.env.PLINTH_CALENDAR_INTERVAL_MS;
+  if (raw) {
+    const n2 = Number(raw);
+    if (Number.isFinite(n2) && n2 > 0)
+      return n2;
+  }
+  return DEFAULT_CALENDAR_INTERVAL_MS;
+}
+
+class CalendarLoop {
+  runOnce;
+  onProjected;
+  notice;
+  loginHint;
+  intervalMs;
+  capMs;
+  authRetryMs;
+  setTimer;
+  clearTimer;
+  timer = null;
+  inFlight = false;
+  stopped = false;
+  failures = 0;
+  authAnnounced = false;
+  degradedAnnounced = false;
+  constructor(deps) {
+    this.runOnce = deps.runOnce;
+    this.onProjected = deps.onProjected;
+    this.notice = deps.notice;
+    this.loginHint = deps.loginHint;
+    this.intervalMs = deps.intervalMs ?? calendarIntervalMs();
+    this.capMs = deps.capMs ?? CALENDAR_BACKOFF_CAP_MS;
+    this.authRetryMs = deps.authRetryMs ?? CALENDAR_AUTH_RETRY_MS;
+    this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = deps.clearTimer ?? ((t2) => clearTimeout(t2));
+  }
+  startNow() {
+    this.tick();
+  }
+  start() {
+    this.schedule(this.intervalMs);
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer !== null) {
+      this.clearTimer(this.timer);
+      this.timer = null;
+    }
+  }
+  schedule(ms) {
+    if (this.stopped)
+      return;
+    this.timer = this.setTimer(() => {
+      this.tick();
+    }, ms);
+  }
+  async tick() {
+    if (this.stopped || this.inFlight)
+      return;
+    this.inFlight = true;
+    let nextDelay;
+    try {
+      const result = await this.runOnce();
+      nextDelay = result.ok ? this.onSuccess(result) : this.onFailure(result.failure);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : "unknown error";
+      nextDelay = this.onFailure({ kind: "transient", reason });
+    } finally {
+      this.inFlight = false;
+    }
+    if (nextDelay !== null)
+      this.schedule(nextDelay);
+  }
+  onSuccess(result) {
+    this.failures = 0;
+    this.authAnnounced = false;
+    this.degradedAnnounced = false;
+    if (result.written > 0 || result.pruned > 0) {
+      this.onProjected(result.written, result.pruned);
+    }
+    return this.intervalMs;
+  }
+  onFailure(failure) {
+    if (failure.kind === "unsupported") {
+      this.stop();
+      this.notice("unsupported", `Calendar projection is off: this Plinth server has no calendar route. ` + `Nothing under views/calendar/ will be written or updated. Restart the ` + `daemon once the server is up to date.`);
+      return null;
+    }
+    if (failure.kind === "auth") {
+      if (!this.authAnnounced) {
+        this.authAnnounced = true;
+        this.notice("auth", `Calendar refresh paused - the server rejected the token. Run ` + `\`${this.loginHint}\`, then RESTART the daemon: the token is read once ` + `at startup, so a re-login is not picked up until it does. Files ` + `under views/calendar/ keep their last good read and say they are stale.`);
+      }
+      return this.authRetryMs;
+    }
+    this.failures += 1;
+    let delay;
+    if (failure.kind === "rate_limit" && failure.retryAfterMs !== undefined) {
+      delay = Math.min(Math.max(failure.retryAfterMs, 1000), this.capMs);
+    } else {
+      delay = Math.min(this.intervalMs * 2 ** (this.failures - 1), this.capMs);
+    }
+    if (delay >= this.capMs && !this.degradedAnnounced) {
+      this.degradedAnnounced = true;
+      const mins = Math.round(this.capMs / 60000);
+      this.notice("degraded", `Calendar refresh degraded - repeated failures, retrying about every ` + `${mins}m. Files under views/calendar/ still show the last good read ` + `and say that they are stale.`);
+    }
+    return delay;
+  }
+}
+function classifyCalendarFailure(err) {
+  if (err instanceof ApiError) {
+    if (err.status === 404)
+      return { kind: "unsupported", reason: err.message };
+    if (err.status === 401 || err.status === 403) {
+      return { kind: "auth", reason: err.message };
+    }
+    if (err.status === 429) {
+      return {
+        kind: "rate_limit",
+        reason: err.message,
+        retryAfterMs: err.retryAfterMs
+      };
+    }
+    return { kind: "transient", reason: err.message };
+  }
+  return {
+    kind: "transient",
+    reason: err instanceof Error ? err.message : "unknown error"
+  };
+}
+
+// src/lib/calendar/api.ts
+class CalendarContractError extends ApiError {
+  constructor(status, message) {
+    super(status, message);
+    this.name = "CalendarContractError";
+  }
+}
+var CalendarEventSchema = exports_external.object({
+  id: exports_external.string(),
+  title: exports_external.string(),
+  start: exports_external.string().min(1),
+  end: exports_external.string().min(1),
+  all_day: exports_external.boolean(),
+  location: exports_external.string().nullish().transform((v2) => v2 ?? null),
+  booking_status: exports_external.enum(["confirmed", "hold"]),
+  url: exports_external.string()
+});
+var CALENDAR_STATUSES = [
+  "fetched",
+  "no-token",
+  "token-expired",
+  "google-error"
+];
+var CalendarRowSchema = exports_external.object({
+  artist_id: exports_external.string().nullable(),
+  artist_slug: exports_external.string().nullable(),
+  artist_name: exports_external.string().nullable(),
+  calendar_id: exports_external.string(),
+  calendar_name: exports_external.string(),
+  status: exports_external.enum(CALENDAR_STATUSES),
+  events: exports_external.array(CalendarEventSchema).nullable(),
+  error: exports_external.object({ upstream_status: exports_external.number(), message: exports_external.string() }).nullish().transform((v2) => v2 ?? null),
+  truncated: exports_external.boolean().optional().default(false)
+});
+var CalendarResponseSchema = exports_external.object({
+  generated_at: exports_external.string().min(1),
+  window: exports_external.object({
+    time_min: exports_external.string().min(1),
+    time_max: exports_external.string().min(1)
+  }),
+  artist_count: exports_external.number().int().nonnegative(),
+  mapped_artist_count: exports_external.number().int().nonnegative(),
+  calendars: exports_external.array(CalendarRowSchema)
+}).superRefine((body, ctx) => {
+  for (const [i2, row] of body.calendars.entries()) {
+    const isFetched = row.status === "fetched";
+    if (isFetched && row.events === null) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["calendars", i2, "events"],
+        message: `status "fetched" must carry an events array, not null`
+      });
+    }
+    if (!isFetched && row.events !== null) {
+      ctx.addIssue({
+        code: exports_external.ZodIssueCode.custom,
+        path: ["calendars", i2, "events"],
+        message: `status "${row.status}" must carry events: null, not an array`
+      });
+    }
+  }
+});
+async function fetchCalendar(args) {
+  const { baseUrl, pat, fetchImpl = fetch } = args;
+  const url2 = `${baseUrl.replace(/\/$/, "")}/api/sync/calendar`;
+  let res;
+  try {
+    res = await fetchImpl(url2, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${pat}`,
+        Accept: "application/json"
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "network error";
+    throw new ApiError(0, `Could not reach ${url2}: ${msg}`);
+  }
+  if (res.status === 401) {
+    throw new ApiError(401, "Token was rejected by the server. Run `plinth login --workspace <slug>` to refresh.");
+  }
+  if (res.status === 404) {
+    throw new ApiError(404, "This Plinth server has no /api/sync/calendar route.");
+  }
+  if (res.status === 429) {
+    throw new ApiError(429, "Rate limited by the server. Wait a few seconds and retry.", parseRetryAfterMs(res.headers.get("retry-after")));
+  }
+  if (!res.ok) {
+    throw new ApiError(res.status, `sync calendar failed with HTTP ${res.status}`);
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new CalendarContractError(res.status, "sync calendar response was not JSON");
+  }
+  const parsed = CalendarResponseSchema.safeParse(body);
+  if (!parsed.success) {
+    const detail = parsed.error.issues.slice(0, 3).map((i2) => `${i2.path.join(".") || "(root)"}: ${i2.message}`).join("; ");
+    throw new CalendarContractError(res.status, `sync calendar response did not match the contract: ${detail}`);
+  }
+  return parsed.data;
+}
+
+// src/lib/calendar/render.ts
+var CALENDAR_BODY_MARKER = "<!-- PLINTH:CALENDAR-BODY -->";
+var OWNERSHIP_NOTE2 = [
+  "<!-- Generated by Plinth from the calendars mapped in this workspace. This file",
+  "     is DERIVED: one-way, overwritten on every refresh, and never uploaded.",
+  "     Your edits here are lost. Dates are changed in Plinth's calendar view, by a",
+  "     person - not from this file and not by an agent. -->"
+].join(`
+`);
+var DEFAULT_USER_LABEL = "the Plinth account this mirror syncs with";
+var WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var DAY_MS = 86400000;
+var FULL_BAND_DAYS = 14;
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+function oneLine(value, maxLength = 200) {
+  const flattened = value.replace(/[\u0000-\u001F\u007F]+/g, " ").replace(/<!--/g, "<! --").replace(/\s+/g, " ").trim();
+  if (flattened.length === 0)
+    return "(untitled)";
+  if (flattened.length <= maxLength)
+    return flattened;
+  return `${flattened.slice(0, maxLength - 3)}...`;
+}
+function dateParts(value) {
+  const m2 = /^(\d{4})-(\d{2})-(\d{2})/.exec(value);
+  if (!m2)
+    return null;
+  return { y: Number(m2[1]), m: Number(m2[2]), d: Number(m2[3]) };
+}
+function timeParts(value) {
+  const m2 = /T(\d{2}):(\d{2})(?::\d{2}(?:\.\d+)?)?(Z|[+-]\d{2}:\d{2})?$/.exec(value);
+  if (!m2)
+    return null;
+  const rawOffset = m2[3];
+  const offset = rawOffset === undefined ? "" : rawOffset === "Z" ? "UTC" : rawOffset;
+  return { hh: m2[1], mi: m2[2], offset };
+}
+function utcMs(parts) {
+  return Date.UTC(parts.y, parts.m - 1, parts.d);
+}
+function shiftDays(parts, days) {
+  const d2 = new Date(utcMs(parts) + days * DAY_MS);
+  return { y: d2.getUTCFullYear(), m: d2.getUTCMonth() + 1, d: d2.getUTCDate() };
+}
+function formatDay(parts, referenceYear) {
+  const weekday = WEEKDAYS[new Date(utcMs(parts)).getUTCDay()] ?? "";
+  const month = MONTHS[parts.m - 1] ?? "";
+  const year = parts.y === referenceYear ? "" : ` ${parts.y}`;
+  return `${weekday} ${parts.d} ${month}${year}`;
+}
+function sortInstant(event) {
+  if (!event.all_day) {
+    const ms = Date.parse(event.start);
+    if (!Number.isNaN(ms))
+      return ms;
+  }
+  const parts = dateParts(event.start);
+  if (parts)
+    return utcMs(parts);
+  return Number.MAX_SAFE_INTEGER;
+}
+function describeWhen(event, referenceYear) {
+  const start = dateParts(event.start);
+  if (!start)
+    return oneLine(event.start, 60);
+  if (event.all_day) {
+    const end2 = dateParts(event.end);
+    const last = end2 ? shiftDays(end2, -1) : start;
+    const single = !end2 || utcMs(last) <= utcMs(start);
+    return single ? `${formatDay(start, referenceYear)} (all day)` : `${formatDay(start, referenceYear)} to ${formatDay(last, referenceYear)} (all day)`;
+  }
+  const startTime = timeParts(event.start);
+  const end = dateParts(event.end);
+  const endTime = timeParts(event.end);
+  if (!startTime)
+    return formatDay(start, referenceYear);
+  const suffix = startTime.offset ? ` ${startTime.offset}` : "";
+  if (!end || !endTime) {
+    return `${formatDay(start, referenceYear)}, ${startTime.hh}:${startTime.mi}${suffix}`;
+  }
+  if (utcMs(end) === utcMs(start)) {
+    return `${formatDay(start, referenceYear)}, ${startTime.hh}:${startTime.mi}-${endTime.hh}:${endTime.mi}${suffix}`;
+  }
+  const endSuffix = endTime.offset ? ` ${endTime.offset}` : "";
+  return `${formatDay(start, referenceYear)} ${startTime.hh}:${startTime.mi}${suffix}` + ` to ${formatDay(end, referenceYear)} ${endTime.hh}:${endTime.mi}${endSuffix}`;
+}
+function fullLine(event, referenceYear, artistPrefix, includeUrl) {
+  const parts = [
+    `**${describeWhen(event, referenceYear)}**`,
+    artistPrefix,
+    `${oneLine(event.title)} (${event.booking_status})`
+  ].filter((p) => p.length > 0);
+  if (event.location)
+    parts.push(oneLine(event.location, 80));
+  if (includeUrl && event.url)
+    parts.push(oneLine(event.url, 300));
+  return `- ${parts.join(" - ")}`;
+}
+function compactLine(event, referenceYear, artistPrefix) {
+  const parts = [
+    describeWhen(event, referenceYear),
+    artistPrefix,
+    `${oneLine(event.title)} (${event.booking_status})`
+  ].filter((p) => p.length > 0);
+  return `- ${parts.join(" - ")}`;
+}
+function humanStamp(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms))
+    return iso;
+  const d2 = new Date(ms);
+  const day = formatDay({ y: d2.getUTCFullYear(), m: d2.getUTCMonth() + 1, d: d2.getUTCDate() }, -1);
+  const hh = String(d2.getUTCHours()).padStart(2, "0");
+  const mi = String(d2.getUTCMinutes()).padStart(2, "0");
+  return `${day}, ${hh}:${mi} UTC`;
+}
+function windowLine(timeMin, timeMax) {
+  const from = dateParts(timeMin);
+  const to = dateParts(timeMax);
+  if (!from || !to)
+    return `${timeMin} to ${timeMax}`;
+  return `${formatDay(from, -1)} to ${formatDay(to, -1)}`;
+}
+function statusLine(args) {
+  const { status, eventCount, error: error52, truncated, stamp, userLabel } = args;
+  switch (status) {
+    case "fetched": {
+      if (eventCount === 0) {
+        return `**Read fine as of ${stamp}. Nothing in this window.** The diary really ` + `is clear across the dates above. This is a successful read of an empty ` + `calendar, not a failed read - if it had failed, this line would say so.`;
+      }
+      const truncatedNote = truncated ? " **This list is INCOMPLETE**: Google had more entries than one page and the rest were not collected." : "";
+      return `**Read fine as of ${stamp}.** ${eventCount} ` + `${eventCount === 1 ? "entry" : "entries"} in the window.${truncatedNote}`;
+    }
+    case "no-token":
+      return `**NOT READ - Google is not connected for ${userLabel}.** Nothing is listed ` + `below because Plinth could not look, NOT because the diary is clear. ` + `Connect Google in Plinth to fill this in, and until then treat this ` + `calendar as unknown rather than empty.`;
+    case "token-expired":
+      return `**NOT READ - the Google connection for ${userLabel} has expired.** Plinth ` + `still holds a connection but could not refresh it, so nothing below is ` + `current. Reconnect Google in Plinth. Treat this calendar as unknown ` + `rather than empty.`;
+    case "google-error":
+      return `**NOT READ - Google refused the request` + `${error52 ? ` (HTTP ${error52.upstream_status})` : ""}.** ` + `${error52 ? oneLine(error52.message, 300) : "No detail was returned."} ` + `A calendar that was unshared or deleted in Google reads exactly like this. ` + `Nothing below is current; treat this calendar as unknown rather than empty.`;
+  }
+}
+function shortStatus(row) {
+  switch (row.status) {
+    case "fetched": {
+      const n2 = row.events?.length ?? 0;
+      if (n2 === 0)
+        return "read fine, nothing in this window";
+      return `read fine, ${n2} ${n2 === 1 ? "entry" : "entries"}${row.truncated ? " (INCOMPLETE - more than one page)" : ""}`;
+    }
+    case "no-token":
+      return "NOT READ - Google is not connected; unknown, not empty";
+    case "token-expired":
+      return "NOT READ - the Google connection has expired; unknown, not empty";
+    case "google-error":
+      return `NOT READ - Google refused` + `${row.error ? ` (HTTP ${row.error.upstream_status}): ${oneLine(row.error.message, 120)}` : ""}` + `; unknown, not empty`;
+  }
+}
+function rowFileName(row, internalName) {
+  return row.artist_slug ?? internalName;
+}
+function rowDisplayName(row) {
+  if (row.artist_name)
+    return oneLine(row.artist_name, 80);
+  return `${oneLine(row.calendar_name, 80)} (internal)`;
+}
+function splitBands(events, generatedAt) {
+  const base2 = Date.parse(generatedAt);
+  const boundary = Number.isNaN(base2) ? Number.MAX_SAFE_INTEGER : base2 + FULL_BAND_DAYS * DAY_MS;
+  const full = [];
+  const rest = [];
+  for (const e2 of events) {
+    (sortInstant(e2) < boundary ? full : rest).push(e2);
+  }
+  return { full, rest };
+}
+function renderArtistCalendar(args) {
+  const { row, generatedAt, window: window2 } = args;
+  const userLabel = args.userLabel ?? DEFAULT_USER_LABEL;
+  const events = row.events ?? [];
+  const stamp = humanStamp(generatedAt);
+  const referenceYear = new Date(Date.parse(generatedAt) || 0).getUTCFullYear();
+  const title = rowDisplayName(row);
+  const header = [
+    "---",
+    "plinth_generated: true",
+    "view: calendar",
+    `artist_slug: ${row.artist_slug === null ? "null" : yamlString(row.artist_slug)}`,
+    `artist_name: ${row.artist_name === null ? "null" : yamlString(row.artist_name)}`,
+    `calendar_name: ${yamlString(row.calendar_name)}`,
+    `generated_at: ${yamlString(generatedAt)}`,
+    `window_start: ${yamlString(window2.time_min)}`,
+    `window_end: ${yamlString(window2.time_max)}`,
+    `status: ${row.status}`,
+    "fetch_state: fresh",
+    `entry_count: ${events.length}`,
+    `truncated: ${row.truncated}`,
+    "---",
+    "",
+    OWNERSHIP_NOTE2,
+    "",
+    `# ${title} - calendar`,
+    ""
+  ].join(`
+`);
+  const body = [
+    "",
+    statusLine({
+      status: row.status,
+      eventCount: events.length,
+      error: row.error,
+      truncated: row.truncated,
+      stamp,
+      userLabel
+    }),
+    "",
+    `**Window:** ${windowLine(window2.time_min, window2.time_max)}.`,
+    "",
+    "**Dates are read here and changed in Plinth's calendar view, by a person.** If something below needs moving, say what the change is and hand it over.",
+    "",
+    renderBands(events, generatedAt, referenceYear, "")
+  ].join(`
+`);
+  return `${header}${CALENDAR_BODY_MARKER}
+${body}`;
+}
+function renderBands(events, generatedAt, referenceYear, artistPrefix) {
+  if (events.length === 0)
+    return "";
+  const { full, rest } = splitBands(events, generatedAt);
+  const out = [""];
+  out.push(`## Next ${FULL_BAND_DAYS} days`, "");
+  if (full.length === 0) {
+    out.push(`_Nothing in the next ${FULL_BAND_DAYS} days._`);
+  } else {
+    for (const e2 of full)
+      out.push(fullLine(e2, referenceYear, artistPrefix, true));
+  }
+  out.push("", "## Rest of the window", "");
+  if (rest.length === 0) {
+    out.push("_Nothing further in the window._");
+  } else {
+    for (const e2 of rest)
+      out.push(compactLine(e2, referenceYear, artistPrefix));
+  }
+  out.push("");
+  return out.join(`
+`);
+}
+function renderUpcoming(args) {
+  const {
+    rows,
+    unmappedArtists,
+    generatedAt,
+    window: window2,
+    artistCount,
+    mappedArtistCount,
+    internalName
+  } = args;
+  const stamp = humanStamp(generatedAt);
+  const referenceYear = new Date(Date.parse(generatedAt) || 0).getUTCFullYear();
+  const fetched = rows.filter((r3) => r3.status === "fetched");
+  const failed = rows.filter((r3) => r3.status !== "fetched");
+  const truncatedAnywhere = rows.some((r3) => r3.truncated);
+  const merged = fetched.flatMap((row) => (row.events ?? []).map((event) => ({ event, row }))).sort((a2, b2) => sortInstant(a2.event) - sortInstant(b2.event));
+  const { full, rest } = splitBands(merged.map((m2) => m2.event), generatedAt);
+  const fullSet = new Set(full);
+  const restSet = new Set(rest);
+  const header = [
+    "---",
+    "plinth_generated: true",
+    "view: calendar",
+    "scope: workspace",
+    `generated_at: ${yamlString(generatedAt)}`,
+    `window_start: ${yamlString(window2.time_min)}`,
+    `window_end: ${yamlString(window2.time_max)}`,
+    `artist_count: ${artistCount}`,
+    `mapped_artist_count: ${mappedArtistCount}`,
+    `calendars_read: ${fetched.length}`,
+    `calendars_not_read: ${failed.length}`,
+    "fetch_state: fresh",
+    `truncated: ${truncatedAnywhere}`,
+    "---",
+    "",
+    OWNERSHIP_NOTE2,
+    "",
+    "# Upcoming - every calendar in this workspace",
+    ""
+  ].join(`
+`);
+  const preamble = [
+    "",
+    `**As of ${stamp}.** Window ${windowLine(window2.time_min, window2.time_max)}.`,
+    "",
+    failed.length === 0 ? `**All ${fetched.length} mapped ${fetched.length === 1 ? "calendar was" : "calendars were"} read.**` : `**${fetched.length} of ${rows.length} mapped ${rows.length === 1 ? "calendar" : "calendars"} read; ${failed.length} could NOT be read.**` + ` Anything on an unread calendar is missing from the lists below - unknown, not absent.`,
+    "",
+    `${artistCount} ${artistCount === 1 ? "artist" : "artists"} in the roster; ` + `${mappedArtistCount} ${mappedArtistCount === 1 ? "has" : "have"} a calendar mapped in Plinth.`,
+    "",
+    "**Dates are read here and changed in Plinth's calendar view, by a person.** If something below needs moving, say what the change is and hand it over.",
+    "",
+    "## Calendar status",
+    "",
+    ...rows.map((row) => `- **${rowDisplayName(row)}**` + `${row.artist_slug ? ` (\`${oneLine(row.artist_slug, 80)}\`)` : ""}` + ` - ${shortStatus(row)} - \`views/calendar/${rowFileName(row, internalName)}.md\``),
+    ...unmappedArtists.map((a2) => `- **${oneLine(a2.name, 80)}** (\`${oneLine(a2.slug, 80)}\`) - NO CALENDAR MAPPED in Plinth, so there is nothing to read and no file for them. Map one in Plinth if they should have dates.`),
+    ""
+  ].join(`
+`);
+  const body = [preamble];
+  body.push(`## Next ${FULL_BAND_DAYS} days`, "", "_Links are in the per-artist file named beside each calendar above._", "");
+  const fullMerged = merged.filter((m2) => fullSet.has(m2.event));
+  if (fullMerged.length === 0) {
+    body.push(fetched.length === 0 ? `_No calendar could be read, so nothing can be listed for the next ${FULL_BAND_DAYS} days._` : `_Nothing in the next ${FULL_BAND_DAYS} days on any calendar that was read._`);
+  } else {
+    for (const { event, row } of fullMerged) {
+      body.push(fullLine(event, referenceYear, `**${rowDisplayName(row)}**`, false));
+    }
+  }
+  body.push("", "## Rest of the window", "");
+  const restMerged = merged.filter((m2) => restSet.has(m2.event));
+  if (restMerged.length === 0) {
+    body.push(fetched.length === 0 ? "_No calendar could be read, so nothing can be listed._" : "_Nothing further in the window on any calendar that was read._");
+  } else {
+    for (const { event, row } of restMerged) {
+      body.push(compactLine(event, referenceYear, `**${rowDisplayName(row)}**`));
+    }
   }
-  async tick() {
-    if (this.stopped || this.inFlight)
-      return;
-    this.inFlight = true;
-    let nextDelay;
+  body.push("");
+  return `${header}${CALENDAR_BODY_MARKER}
+${body.join(`
+`)}`;
+}
+function splitCalendarFile(content) {
+  const at = content.indexOf(CALENDAR_BODY_MARKER);
+  if (at === -1)
+    return null;
+  return {
+    header: content.slice(0, at),
+    body: content.slice(at + CALENDAR_BODY_MARKER.length)
+  };
+}
+function headerField(header, key) {
+  const re = new RegExp(`^${key}: (.*)$`, "m");
+  const m2 = re.exec(header);
+  if (!m2)
+    return null;
+  const raw = m2[1].trim();
+  if (raw === "null")
+    return null;
+  if (raw.startsWith('"')) {
     try {
-      const result = await this.runOnce();
-      nextDelay = result.exitCode === 0 ? this.onSuccess(result) : this.onFailure(result.failure);
+      return JSON.parse(raw);
     } catch {
-      nextDelay = this.onFailure({ kind: "transient", status: 0 });
-    } finally {
-      this.inFlight = false;
+      return raw;
     }
-    this.schedule(nextDelay);
   }
-  onSuccess(result) {
-    this.failures = 0;
-    this.capStreak = 0;
-    this.degradedAnnounced = false;
-    this.authAnnounced = false;
-    if (result.applied !== undefined && result.applied > 0) {
-      this.onApplied(result.applied);
+  return raw;
+}
+function renderStaleFile(existing, args) {
+  const split = splitCalendarFile(existing);
+  if (!split)
+    return null;
+  const previousGeneratedAt = headerField(split.header, "generated_at");
+  const title = /^# (.+)$/m.exec(split.header)?.[1]?.trim() ?? "Calendar";
+  const fmMatch = /^---\n([\s\S]*?)\n---\n/.exec(split.header);
+  const carried = (fmMatch?.[1] ?? "").split(`
+`).filter((line) => !/^(fetch_state|last_refresh_attempt|last_refresh_error):/.test(line));
+  const stamp = previousGeneratedAt ? humanStamp(previousGeneratedAt) : "an earlier refresh";
+  const header = [
+    "---",
+    ...carried,
+    "fetch_state: stale",
+    `last_refresh_attempt: ${yamlString(args.attemptedAt)}`,
+    `last_refresh_error: ${yamlString(oneLine(args.reason, 300))}`,
+    "---",
+    "",
+    OWNERSHIP_NOTE2,
+    "",
+    `# ${title}`,
+    "",
+    `**STALE - the last refresh FAILED and nothing below was updated.** Attempted ` + `${humanStamp(args.attemptedAt)} and it did not succeed: ` + `${oneLine(args.reason, 300)}`,
+    "",
+    `**What is below was last read at ${stamp}** and has not moved since. Anything ` + `changed in Google after that is not here, and something cancelled after that ` + `is still listed. Say the age out loud rather than briefing it as current.`,
+    ""
+  ].join(`
+`);
+  return `${header}${CALENDAR_BODY_MARKER}${split.body}`;
+}
+
+// src/lib/calendar/project.ts
+function writeIfChanged(workspaceSlug, name, content) {
+  if (readCalendarView(workspaceSlug, name) === content)
+    return false;
+  writeCalendarView(workspaceSlug, name, content);
+  return true;
+}
+function projectCalendar(args) {
+  const { workspaceSlug, response, roster, userLabel } = args;
+  const { generated_at: generatedAt, window: window2 } = response;
+  let written = 0;
+  let unchanged = 0;
+  let collided = 0;
+  const seen = new Set;
+  const rows = [];
+  for (const row of response.calendars) {
+    const name = rowFileName(row, CALENDAR_INTERNAL_NAME);
+    if (seen.has(name) || name === CALENDAR_UPCOMING_NAME) {
+      collided += 1;
+      continue;
     }
-    this.afterPoll();
-    return this.intervalMs;
+    seen.add(name);
+    rows.push(row);
+    const content = renderArtistCalendar({
+      row,
+      generatedAt,
+      window: window2,
+      userLabel
+    });
+    if (writeIfChanged(workspaceSlug, name, content))
+      written += 1;
+    else
+      unchanged += 1;
+  }
+  const mapped = new Set(response.calendars.map((r3) => r3.artist_slug).filter((s2) => s2 !== null));
+  const unmappedArtists = roster.filter((a2) => !mapped.has(a2.slug) && a2.status !== "archived").map((a2) => ({ slug: a2.slug, name: a2.name }));
+  const upcoming = renderUpcoming({
+    rows,
+    unmappedArtists,
+    generatedAt,
+    window: window2,
+    artistCount: response.artist_count,
+    mappedArtistCount: response.mapped_artist_count,
+    internalName: CALENDAR_INTERNAL_NAME,
+    userLabel
+  });
+  if (writeIfChanged(workspaceSlug, CALENDAR_UPCOMING_NAME, upcoming))
+    written += 1;
+  else
+    unchanged += 1;
+  const expected = new Set([...seen, CALENDAR_UPCOMING_NAME]);
+  let pruned = 0;
+  for (const name of listCalendarViews(workspaceSlug)) {
+    if (expected.has(name))
+      continue;
+    if (!ownsFile(workspaceSlug, name))
+      continue;
+    try {
+      if (deleteCalendarView(workspaceSlug, name))
+        pruned += 1;
+    } catch {}
   }
-  onFailure(failure) {
-    const kind = failure?.kind ?? "transient";
-    if (kind === "auth") {
-      if (!this.authAnnounced) {
-        this.authAnnounced = true;
-        this.notice("auth", `Pull sync paused — the server rejected the token. Run \`${this.loginHint}\`; ` + `it resumes automatically on the next retry once the token is valid, or on daemon restart.`);
-      }
-      return this.authRetryMs;
+  return { written, unchanged, pruned, collided };
+}
+function ownsFile(workspaceSlug, name) {
+  try {
+    const existing = readCalendarView(workspaceSlug, name);
+    return existing !== null && existing.includes(CALENDAR_BODY_MARKER);
+  } catch {
+    return false;
+  }
+}
+function markCalendarStale(args) {
+  const { workspaceSlug, attemptedAt, reason } = args;
+  let rewritten = 0;
+  let unchanged = 0;
+  let skipped = 0;
+  for (const name of listCalendarViews(workspaceSlug)) {
+    let existing;
+    try {
+      existing = readCalendarView(workspaceSlug, name);
+    } catch {
+      skipped += 1;
+      continue;
     }
-    this.failures += 1;
-    let delay;
-    if (failure?.kind === "rate_limit" && failure.retryAfterMs !== undefined) {
-      delay = Math.min(Math.max(failure.retryAfterMs, 1000), this.capMs);
-    } else {
-      delay = Math.min(this.intervalMs * 2 ** (this.failures - 1), this.capMs);
+    if (existing === null)
+      continue;
+    const staled = renderStaleFile(existing, { attemptedAt, reason });
+    if (staled === null) {
+      skipped += 1;
+      continue;
     }
-    this.trackCap(delay);
-    return delay;
-  }
-  trackCap(delay) {
-    this.capStreak = delay >= this.capMs ? this.capStreak + 1 : 0;
-    if (this.capStreak >= DEGRADED_CAP_STREAK && !this.degradedAnnounced) {
-      this.degradedAnnounced = true;
-      const mins = Math.round(this.capMs / 60000);
-      this.notice("degraded", `Pull sync degraded — repeated failures, retrying about every ${mins}m. ` + `Local edits still push; the mirror may be stale until the cloud is reachable again.`);
+    try {
+      if (writeIfChanged(workspaceSlug, name, staled))
+        rewritten += 1;
+      else
+        unchanged += 1;
+    } catch {
+      skipped += 1;
     }
   }
+  return { rewritten, unchanged, skipped };
 }
 
 // src/lib/pull-suppression.ts
@@ -34230,7 +36277,7 @@ class PullSuppressor {
 }
 
 // src/lib/reconcile.ts
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 async function reconcileDivergedRows(args) {
   const { workspaceSlug, baseUrl, pat, fetchImpl, output, isFrozen } = args;
   const now = args.now ?? (() => new Date);
@@ -34316,7 +36363,7 @@ async function reconcileDivergedRows(args) {
       }
       let content;
       try {
-        content = readFileSync15(absolutePath, "utf8");
+        content = readFileSync17(absolutePath, "utf8");
       } catch (err) {
         if (err?.code === "ENOENT")
           continue;
@@ -35259,25 +37306,111 @@ function createThrottledFetch(baseFetch, opts = {}) {
 // src/commands/sync.ts
 import {
   existsSync as existsSync6,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync17,
-  statSync as statSync9,
-  unlinkSync as unlinkSync6
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync19,
+  statSync as statSync11,
+  unlinkSync as unlinkSync7
 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
+
+// src/lib/files/pull.ts
+import { existsSync as existsSync5, readFileSync as readFileSync18, statSync as statSync10 } from "node:fs";
+
+// src/lib/files/extracted-text.ts
+import { createHash as createHash3 } from "node:crypto";
+var DERIVED_TEXT_VERSION = 2;
+function yamlString2(value) {
+  return JSON.stringify(value);
+}
+var PARTIAL_WARNING = [
+  "> ⚠️ **PARTIAL EXTRACTION.** Some spans of this document came out as text and",
+  "> some did not. Which spans is NOT recorded, so this could be a clean document",
+  "> with mangled party names, or clean prose that degrades part-way through.",
+  "> Verify anything load-bearing against the source file."
+].join(`
+`);
+var NO_LOCAL_COPY_NOTE = [
+  "> ℹ️ **NO LOCAL COPY OF THIS FILE.** Plinth does not hold this file's bytes, so",
+  "> nothing was written under `files/` for it and the text below is the only copy",
+  "> in this mirror. The original lives wherever `source_uri` above points."
+].join(`
+`);
+function garbledBody(relPath, bytesInMirror) {
+  return [
+    "> \uD83D\uDD34 **NOT TEXT — body withheld.**",
+    ">",
+    "> Extraction produced characters that are not words. The usual cause is a PDF",
+    "> whose embedded fonts carry no ToUnicode map, so the glyph indices come out",
+    "> where the letters should be: a page reading *“Dated this 10th day of",
+    "> September”* extracts as `):-,:019`.",
+    ">",
+    "> The characters are NOT reproduced here on purpose. They read as text to a",
+    "> reader and to a search index, and they say nothing — writing them into the",
+    "> mirror would put a document into your corpus that appears readable and is",
+    "> not. They are excluded from Plinth's own search index for the same reason.",
+    ">",
+    bytesInMirror ? `> **Read the original instead:** \`files/${relPath}\`` : "> **There is no local original to read** — Plinth holds no bytes for this file." + " Follow `source_uri` above to the copy that has them."
+  ].join(`
+`);
+}
+function renderExtractedText(doc2) {
+  const withheld = doc2.quality === "garbled";
+  const frontmatter = [
+    "---",
+    "plinth_generated: true",
+    `source_file: ${doc2.bytesInMirror ? yamlString2(`files/${doc2.relPath}`) : "null"}`,
+    `source_uri: ${doc2.sourceUri === undefined ? "unknown" : doc2.sourceUri === null ? "null" : yamlString2(doc2.sourceUri)}`,
+    `content_quality: ${doc2.quality ?? "unchecked"}`,
+    `body_withheld: ${withheld}`,
+    `extracted_chars: ${withheld ? 0 : doc2.text.length}`,
+    "---",
+    "",
+    "<!-- Generated by Plinth from the source file above. This file is DERIVED:",
+    "     your edits here are overwritten on the next sync and are never uploaded.",
+    "     Edit the source file instead. -->",
+    ""
+  ].join(`
+`);
+  if (withheld) {
+    return `${frontmatter}${garbledBody(doc2.relPath, doc2.bytesInMirror)}
+`;
+  }
+  const notices = [
+    ...doc2.quality === "partial" ? [PARTIAL_WARNING] : [],
+    ...doc2.bytesInMirror ? [] : [NO_LOCAL_COPY_NOTE]
+  ];
+  if (notices.length > 0) {
+    return `${frontmatter}${notices.join(`
+
+`)}
+
+${doc2.text}
+`;
+  }
+  return `${frontmatter}${doc2.text}
+`;
+}
+function extractedTextHash(rendered) {
+  return createHash3("sha256").update(rendered, "utf8").digest("hex");
+}
 
 // src/lib/files/pull.ts
-import { existsSync as existsSync5, readFileSync as readFileSync16, statSync as statSync8 } from "node:fs";
 async function pullFiles(args) {
   const { workspaceSlug, baseUrl, pat, fetchImpl } = args;
   let state = args.state;
   let fetched = 0;
   let written = 0;
   let deleted = 0;
+  let textWritten = 0;
+  let textDeleted = 0;
+  let textUnknown = 0;
+  let pointerRows = 0;
   let cursor = args.cursor;
   let lastCursor = args.cursor;
+  let cursorBlocked = false;
   while (true) {
     const page = await syncFilesPage({ baseUrl, pat, cursor, fetchImpl });
+    let pageTextFailed = false;
     for (const row of page.rows) {
       fetched++;
       const outcome = await applyFileRow({
@@ -35290,20 +37423,101 @@ async function pullFiles(args) {
         now: args.now,
         output: args.output,
         suppressor: args.suppressor,
-        isFileFrozen: args.isFileFrozen
+        isFileFrozen: args.isFileFrozen,
+        forceTextRewalk: args.forceTextRewalk
       });
       state = outcome.state;
       if (outcome.action === "written")
         written++;
       else if (outcome.action === "deleted")
         deleted++;
-    }
+      textWritten += outcome.textWritten ?? 0;
+      textDeleted += outcome.textDeleted ?? 0;
+      if (outcome.textUnknown)
+        textUnknown++;
+      if (outcome.pointer)
+        pointerRows++;
+      if (outcome.textFailed)
+        pageTextFailed = true;
+    }
+    if (pageTextFailed)
+      cursorBlocked = true;
     if (page.next_cursor === null)
       break;
-    lastCursor = page.next_cursor;
+    if (!cursorBlocked)
+      lastCursor = page.next_cursor;
     cursor = page.next_cursor;
   }
-  return { state, fetched, written, deleted, lastCursor };
+  if (textUnknown > 0) {
+    args.output?.warn(`${textUnknown} file ${textUnknown === 1 ? "row" : "rows"} arrived without a readable \`has_extracted_text\` — this server predates the extracted-text contract, or the field was dropped from the payload. Derived text under views/extracted/ was left untouched rather than deleted, and is not being updated either.`);
+  }
+  if (pointerRows > 0) {
+    args.output?.info(`${pointerRows} file ${pointerRows === 1 ? "row holds" : "rows hold"} no bytes in Plinth — nothing was written under files/ for ${pointerRows === 1 ? "it" : "them"}; where there is extracted text, views/extracted/ holds the only local copy.`);
+  }
+  return {
+    state,
+    fetched,
+    written,
+    deleted,
+    textWritten,
+    textDeleted,
+    textUnknown,
+    pointerRows,
+    lastCursor
+  };
+}
+async function applyExtractedText(args) {
+  try {
+    return await materialiseExtractedText(args);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    args.output?.warn(`files/${args.relPath}: could not materialise extracted text (${msg}) — mirror text left unwritten, will retry.`);
+    return { textHash: undefined, written: 0, deleted: 0, failed: true };
+  }
+}
+async function materialiseExtractedText(args) {
+  const { workspaceSlug, baseUrl, pat, row, relPath, bytesInMirror, fetchImpl, output } = args;
+  const signal = extractedTextSignal(row);
+  if (signal === "absent") {
+    const removed = deleteExtractedText(workspaceSlug, relPath);
+    return { textHash: undefined, written: 0, deleted: removed ? 1 : 0 };
+  }
+  if (signal === "unknown") {
+    return { textHash: undefined, written: 0, deleted: 0 };
+  }
+  let rendered;
+  if (row.content_quality === "garbled" && bytesInMirror) {
+    rendered = renderExtractedText({
+      relPath,
+      quality: "garbled",
+      bytesInMirror,
+      sourceUri: undefined,
+      text: ""
+    });
+  } else {
+    const got = await getFileText({ baseUrl, pat, id: row.id, fetchImpl });
+    if (!got.ok)
+      return { textHash: undefined, written: 0, deleted: 0 };
+    if (got.row.text === null) {
+      output?.warn(`files/${relPath}: feed reported extracted text, text route withheld it (${got.row.withheld ?? "no reason given"}) — no derived file written.`);
+      const removed = deleteExtractedText(workspaceSlug, relPath);
+      return { textHash: undefined, written: 0, deleted: removed ? 1 : 0 };
+    }
+    rendered = renderExtractedText({
+      relPath,
+      quality: got.row.content_quality,
+      sourceUri: got.row.source_uri,
+      text: got.row.text,
+      bytesInMirror
+    });
+  }
+  const hash2 = extractedTextHash(rendered);
+  const onDisk = readExtractedText(workspaceSlug, relPath);
+  if (onDisk !== null && extractedTextHash(onDisk) === hash2) {
+    return { textHash: hash2, written: 0, deleted: 0 };
+  }
+  writeExtractedText(workspaceSlug, relPath, rendered);
+  return { textHash: hash2, written: 1, deleted: 0 };
 }
 async function applyFileRow(args) {
   const { workspaceSlug, baseUrl, pat, row, state, fetchImpl, output, suppressor } = args;
@@ -35321,28 +37535,88 @@ async function applyFileRow(args) {
   if (row.deleted_at !== null) {
     suppressor?.registerDelete(abs);
     const didUnlink = deleteFilesFile(workspaceSlug, relPath);
+    const removedText = deleteExtractedText(workspaceSlug, relPath);
+    const textDeleted = removedText ? 1 : 0;
     if (existing) {
       const { state: next2 } = removeFileEntry(state, relPath);
-      return { state: next2, action: "deleted" };
+      return { state: next2, action: "deleted", textDeleted };
     }
-    return { state, action: didUnlink ? "deleted" : "skipped" };
+    return { state, action: didUnlink ? "deleted" : "skipped", textDeleted };
+  }
+  const textSignal = extractedTextSignal(row);
+  const textUnknown = textSignal === "unknown";
+  if (storedBytesSignal(row) === "absent") {
+    return applyPointerRow({
+      workspaceSlug,
+      baseUrl,
+      pat,
+      row,
+      relPath,
+      state,
+      existing,
+      textSignal,
+      fetchImpl,
+      output
+    });
   }
   if (existing && existing.content_hash === row.content_hash && existsSync5(abs)) {
-    return { state, action: "noop" };
+    if (!args.forceTextRewalk && textIsCurrent(existing, row, workspaceSlug, relPath)) {
+      return { state, action: "noop", textUnknown };
+    }
+    const text2 = await applyExtractedText({
+      workspaceSlug,
+      baseUrl,
+      pat,
+      row,
+      relPath,
+      bytesInMirror: true,
+      fetchImpl,
+      output
+    });
+    const { state: next2 } = upsertFileEntry(state, {
+      ...existing,
+      updated_at: row.updated_at,
+      text_hash: textUnknown ? existing.text_hash : text2.textHash
+    });
+    return {
+      state: next2,
+      action: "noop",
+      textWritten: text2.written,
+      textDeleted: text2.deleted,
+      textFailed: text2.failed,
+      textUnknown
+    };
+  }
+  const got = await getFile({ baseUrl, pat, id: row.id, fetchImpl });
+  if (!got.ok) {
+    return { state, action: "skipped" };
+  }
+  if (got.row.download_url === null) {
+    if (storedBytesSignal(row) === "present") {
+      output?.warn(`files/${relPath}: the file index says Plinth holds this file's bytes and the file route says it does not — treating it as having none, and leaving any local copy alone.`);
+    }
+    return applyPointerRow({
+      workspaceSlug,
+      baseUrl,
+      pat,
+      row,
+      relPath,
+      state,
+      existing,
+      textSignal,
+      fetchImpl,
+      output
+    });
   }
   if (!suppressor && existing && existing.content_hash !== row.content_hash && existsSync5(abs)) {
     try {
-      const localBytes = readFileSync16(abs);
+      const localBytes = readFileSync18(abs);
       if (sha256Bytes(localBytes) !== existing.content_hash) {
         const stashPath = stashFileConflict({ workspaceSlug, relPath, timestamp: now(), bytes: localBytes });
         output?.warn(`Conflict on files/${relPath} → stashed local edit to ${stashPath} (cloud-wins on boot).`);
       }
     } catch {}
   }
-  const got = await getFile({ baseUrl, pat, id: row.id, fetchImpl });
-  if (!got.ok) {
-    return { state, action: "skipped" };
-  }
   const bytes = await downloadBytes(got.row.download_url, fetchImpl);
   if (sha256Bytes(bytes) !== row.content_hash) {
     output?.warn(`Integrity check failed for files/${relPath} (hash mismatch) — skipped this pull.`);
@@ -35350,9 +37624,28 @@ async function applyFileRow(args) {
   }
   suppressor?.registerWrite(abs, { bodyHash: row.content_hash, frontmatterHash: "" });
   writeFilesBytes(workspaceSlug, relPath, bytes);
+  let text;
+  if (textUnknown) {
+    const removed = deleteExtractedText(workspaceSlug, relPath);
+    if (removed) {
+      output?.warn(`files/${relPath}: bytes changed while the server said nothing about extracted text — removed the derived text, which described the previous version of this file.`);
+    }
+    text = { textHash: undefined, written: 0, deleted: removed ? 1 : 0 };
+  } else {
+    text = await applyExtractedText({
+      workspaceSlug,
+      baseUrl,
+      pat,
+      row,
+      relPath,
+      bytesInMirror: true,
+      fetchImpl,
+      output
+    });
+  }
   let inode;
   try {
-    inode = statSync8(abs).ino;
+    inode = statSync10(abs).ino;
   } catch {
     inode = undefined;
   }
@@ -35363,9 +37656,60 @@ async function applyFileRow(args) {
     size_bytes: row.size_bytes,
     mime_type: row.mime_type,
     updated_at: row.updated_at,
-    inode
+    inode,
+    text_hash: text.textHash
+  });
+  return {
+    state: next,
+    action: "written",
+    textWritten: text.written,
+    textDeleted: text.deleted,
+    textFailed: text.failed,
+    textUnknown
+  };
+}
+async function applyPointerRow(args) {
+  const { workspaceSlug, baseUrl, pat, row, relPath, state, textSignal } = args;
+  if (textSignal === "absent") {
+    args.output?.warn(`files/${relPath}: Plinth holds neither bytes nor text for this file — it has no local representation in the mirror.`);
+  }
+  const bytesInMirror = existsSync5(filesSubtreePath(workspaceSlug, relPath));
+  if (bytesInMirror) {
+    args.output?.warn(`files/${relPath}: Plinth holds no bytes for this file, but a local copy is present at that path — left exactly as it is. Plinth will not update it.`);
+  }
+  const text = await applyExtractedText({
+    workspaceSlug,
+    baseUrl,
+    pat,
+    row,
+    relPath,
+    bytesInMirror,
+    fetchImpl: args.fetchImpl,
+    output: args.output
   });
-  return { state: next, action: "written" };
+  return {
+    state,
+    action: "noop",
+    textWritten: text.written,
+    textDeleted: text.deleted,
+    textFailed: text.failed,
+    textUnknown: textSignal === "unknown",
+    pointer: true
+  };
+}
+function textIsCurrent(existing, row, workspaceSlug, relPath) {
+  const signal = extractedTextSignal(row);
+  if (signal === "unknown")
+    return true;
+  if (signal === "absent") {
+    return existing.text_hash === undefined && !existsSync5(extractedTextPath(workspaceSlug, relPath));
+  }
+  if (existing.text_hash === undefined)
+    return false;
+  const onDisk = readExtractedText(workspaceSlug, relPath);
+  if (onDisk === null)
+    return false;
+  return extractedTextHash(onDisk) === existing.text_hash;
 }
 
 // src/commands/sync.ts
@@ -35383,11 +37727,11 @@ function hasExistingContent(workspacePath) {
   if (!existsSync6(workspacePath))
     return false;
   try {
-    return readdirSync4(workspacePath, { withFileTypes: true }).some((e2) => {
+    return readdirSync5(workspacePath, { withFileTypes: true }).some((e2) => {
       if (!e2.isDirectory())
         return true;
       try {
-        return readdirSync4(join12(workspacePath, e2.name)).length > 0;
+        return readdirSync5(join14(workspacePath, e2.name)).length > 0;
       } catch {
         return true;
       }
@@ -35407,7 +37751,7 @@ function unlinkIfInodeMatches(workspaceSlug, entityType, entrySlug, expectedInod
   }
   let liveInode;
   try {
-    liveInode = statSync9(target).ino;
+    liveInode = statSync11(target).ino;
   } catch {
     return { didUnlink: false, skippedReason: "absent" };
   }
@@ -35416,7 +37760,7 @@ function unlinkIfInodeMatches(workspaceSlug, entityType, entrySlug, expectedInod
   }
   try {
     suppressor?.registerDelete(target);
-    unlinkSync6(target);
+    unlinkSync7(target);
     return { didUnlink: true };
   } catch (err) {
     if (err?.code === "ENOENT") {
@@ -35503,7 +37847,11 @@ async function runSync(workspaceSlug, deps = {}) {
         updateSyncCursor(slug, entityType, lastAdvancedCursor);
       }
     }
-    const filesStartCursor = entry2.sync_cursors?.["files"] ?? null;
+    const needsDerivedTextRewalk = state.derived_text_version !== DERIVED_TEXT_VERSION;
+    const filesStartCursor = needsDerivedTextRewalk ? null : entry2.sync_cursors?.["files"] ?? null;
+    if (needsDerivedTextRewalk) {
+      out.info("Re-reading the file index once to refresh extracted text (template changed).");
+    }
     const filesResult = await pullFiles({
       workspaceSlug: slug,
       baseUrl: entry2.api_base_url,
@@ -35514,16 +37862,21 @@ async function runSync(workspaceSlug, deps = {}) {
       now,
       output: out,
       suppressor: deps.suppressor,
-      isFileFrozen: deps.isFileFrozen
+      isFileFrozen: deps.isFileFrozen,
+      forceTextRewalk: needsDerivedTextRewalk
     });
     if (filesResult.state !== state) {
       state = filesResult.state;
       stateDirty = true;
     }
+    if (needsDerivedTextRewalk && filesResult.textUnknown === 0) {
+      state = { ...state, derived_text_version: DERIVED_TEXT_VERSION };
+      stateDirty = true;
+    }
     counters["files"] = {
       fetched: filesResult.fetched,
-      written: filesResult.written,
-      deleted: filesResult.deleted
+      written: filesResult.written + filesResult.textWritten,
+      deleted: filesResult.deleted + filesResult.textDeleted
     };
     if (filesResult.lastCursor !== filesStartCursor) {
       updateSyncCursor(slug, "files", filesResult.lastCursor);
@@ -35705,7 +38058,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   if (!suppressor && existingEntry && existingEntry.updated_at !== live.updated_at) {
     let localRaw = null;
     try {
-      localRaw = readFileSync17(entityFilePath(workspaceSlug, strategy.type, live.slug), "utf8");
+      localRaw = readFileSync19(entityFilePath(workspaceSlug, strategy.type, live.slug), "utf8");
     } catch {
       localRaw = null;
     }
@@ -35728,7 +38081,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   const hashes = computeMirrorHashes(strategy, content);
   let inode;
   try {
-    inode = statSync9(entityFilePath(workspaceSlug, strategy.type, live.slug)).ino;
+    inode = statSync11(entityFilePath(workspaceSlug, strategy.type, live.slug)).ino;
   } catch {
     inode = undefined;
   }
@@ -35785,7 +38138,7 @@ var syncCommand = defineCommand({
 // src/commands/start.ts
 var SHUTDOWN_DRAIN_TIMEOUT_MS = 5000;
 var PULL_HEARTBEAT_MS = 900000;
-function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync10(p)) {
+function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync12(p)) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -35818,7 +38171,7 @@ function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync10(p)
     return { state, changed: false };
   return { state: { ...state, entries: nextEntries }, changed: true };
 }
-function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync18(p, "utf8")) {
+function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync20(p, "utf8")) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -35915,7 +38268,7 @@ function makeWatchHandler(deps) {
       }
       let st;
       try {
-        st = statSync10(absolutePath);
+        st = statSync12(absolutePath);
       } catch (err) {
         if (err?.code === "ENOENT")
           return;
@@ -35946,7 +38299,7 @@ function makeWatchHandler(deps) {
         spinner.update(`Watching ${workspaceSlug} · ${watchingSummary(getState())}`);
         return;
       }
-      const bytes = readFileSync18(absolutePath);
+      const bytes = readFileSync20(absolutePath);
       const hash2 = sha256Bytes(bytes);
       if (suppressor?.shouldSuppressUpsert(absolutePath, {
         bodyHash: hash2,
@@ -36004,7 +38357,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync18(absolutePath, "utf8");
+        raw = readFileSync20(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -36042,7 +38395,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync18(absolutePath, "utf8");
+        raw = readFileSync20(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -36080,7 +38433,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync18(absolutePath, "utf8");
+        raw = readFileSync20(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -36118,7 +38471,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync18(absolutePath, "utf8");
+        raw = readFileSync20(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -36211,7 +38564,7 @@ function makeWatchHandler(deps) {
           if (strategy) {
             let raw = null;
             try {
-              raw = readFileSync18(absolutePath, "utf8");
+              raw = readFileSync20(absolutePath, "utf8");
             } catch {
               raw = null;
             }
@@ -36819,9 +39172,76 @@ async function runStart(workspaceSlug, deps = {}) {
     loginHint: `plinth login --workspace ${slug}`
   });
   pullLoop.start();
+  let contractMismatchAnnounced = false;
+  let collisionAnnounced = false;
+  const calendarLoop = new CalendarLoop({
+    runOnce: async () => {
+      const attemptedAt = (deps.now?.() ?? new Date).toISOString();
+      try {
+        const response = await fetchCalendar({
+          baseUrl: entry2.api_base_url,
+          pat,
+          fetchImpl
+        });
+        const result = projectCalendar({
+          workspaceSlug: slug,
+          response,
+          roster: readRoster(slug)
+        });
+        const notRead = response.calendars.filter((c3) => c3.status !== "fetched").length;
+        daemonLog.log(calendarProjectedLine({
+          written: result.written,
+          pruned: result.pruned,
+          calendars: response.calendars.length,
+          notRead
+        }));
+        if (result.collided > 0 && !collisionAnnounced) {
+          collisionAnnounced = true;
+          spinner.warn(`${result.collided} calendar row${result.collided === 1 ? "" : "s"} ` + `shared a file name with another and ${result.collided === 1 ? "was" : "were"} skipped.`);
+          spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
+        }
+        contractMismatchAnnounced = false;
+        return { ok: true, written: result.written, pruned: result.pruned };
+      } catch (err) {
+        const failure = classifyCalendarFailure(err);
+        let staled = 0;
+        try {
+          staled = markCalendarStale({
+            workspaceSlug: slug,
+            attemptedAt,
+            reason: failure.reason
+          }).rewritten;
+        } catch (staleErr) {
+          out.log(`[CALENDAR_STALE_FAILED ${categorizeError(staleErr).reason}]`);
+        }
+        daemonLog.log(calendarFailedLine({ ...categorizeError(err), staled }));
+        if (err instanceof CalendarContractError && !contractMismatchAnnounced) {
+          contractMismatchAnnounced = true;
+          spinner.warn(`Calendar refresh: the server's response did not match the contract ` + `this daemon was built against. ${err.message}`);
+          spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
+        }
+        return { ok: false, failure };
+      }
+    },
+    onProjected: (written, pruned) => {
+      const parts = [`${written} calendar file${written === 1 ? "" : "s"}`];
+      if (pruned > 0)
+        parts.push(`${pruned} pruned`);
+      spinner.success(`↻ ${parts.join(", ")}`);
+      spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
+    },
+    notice: (kind, message) => {
+      daemonLog.log(calendarNoticeLine(kind));
+      spinner.warn(message);
+      spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
+    },
+    loginHint: `plinth login --workspace ${slug}`
+  });
+  calendarLoop.startNow();
   const shutdown = (signal) => {
     (async () => {
       pullLoop.stop();
+      calendarLoop.stop();
       spinner.warn(`Received ${signal}, draining pending pushes…`);
       try {
         await Promise.race([
@@ -37032,27 +39452,27 @@ var startCommand = defineCommand({
 });
 
 // src/commands/status.ts
-import { statSync as statSync11 } from "node:fs";
+import { statSync as statSync13 } from "node:fs";
 
 // src/lib/build-stamp.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync19, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname9, join as join13 } from "node:path";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync10, readFileSync as readFileSync21, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname10, join as join15 } from "node:path";
 import { fileURLToPath } from "node:url";
 var BUILD_STAMP_FILENAME = "build-stamp.json";
 function stampPath(distDir) {
-  return join13(distDir, BUILD_STAMP_FILENAME);
+  return join15(distDir, BUILD_STAMP_FILENAME);
 }
 function readHead(repoDir) {
   try {
-    const sha = execFileSync3("git", ["rev-parse", "HEAD"], {
+    const sha = execFileSync4("git", ["rev-parse", "HEAD"], {
       cwd: repoDir,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!sha)
       return null;
-    const porcelain = execFileSync3("git", ["status", "--porcelain", "--untracked-files=no"], { cwd: repoDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const porcelain = execFileSync4("git", ["status", "--porcelain", "--untracked-files=no"], { cwd: repoDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
     return { sha, dirty: porcelain.trim().length > 0 };
   } catch {
     return null;
@@ -37060,7 +39480,7 @@ function readHead(repoDir) {
 }
 function readBuildStamp(distDir) {
   try {
-    const parsed = JSON.parse(readFileSync19(stampPath(distDir), "utf8"));
+    const parsed = JSON.parse(readFileSync21(stampPath(distDir), "utf8"));
     if (parsed && typeof parsed.sha === "string" && parsed.sha.length > 0 && typeof parsed.dirty === "boolean" && typeof parsed.built_at === "string") {
       return { sha: parsed.sha, dirty: parsed.dirty, built_at: parsed.built_at };
     }
@@ -37072,9 +39492,9 @@ function readBuildStamp(distDir) {
 function findRepoRoot(fromDir) {
   let dir = fromDir;
   for (;; ) {
-    if (existsSync7(join13(dir, ".git")))
+    if (existsSync7(join15(dir, ".git")))
       return dir;
-    const parent = dirname9(dir);
+    const parent = dirname10(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -37082,7 +39502,7 @@ function findRepoRoot(fromDir) {
 }
 function probeRepo(repoDir, stampSha) {
   try {
-    execFileSync3("git", ["cat-file", "-e", `${stampSha}^{commit}`], {
+    execFileSync4("git", ["cat-file", "-e", `${stampSha}^{commit}`], {
       cwd: repoDir,
       stdio: "ignore"
     });
@@ -37098,7 +39518,7 @@ function checkBuildStaleness(deps = {}) {
   const metaUrl = deps.metaUrl ?? import.meta.url;
   let distDir;
   try {
-    distDir = dirname9(fileURLToPath(metaUrl));
+    distDir = dirname10(fileURLToPath(metaUrl));
   } catch {
     return { kind: "unknown" };
   }
@@ -37144,8 +39564,8 @@ function formatRelative(deltaMs) {
   return `${Math.floor(h2 / 24)}d ago`;
 }
 function formatAbsolute(date5) {
-  const pad2 = (n2) => String(n2).padStart(2, "0");
-  return `${date5.getFullYear()}-${pad2(date5.getMonth() + 1)}-${pad2(date5.getDate())} ` + `${pad2(date5.getHours())}:${pad2(date5.getMinutes())}:${pad2(date5.getSeconds())}`;
+  const pad3 = (n2) => String(n2).padStart(2, "0");
+  return `${date5.getFullYear()}-${pad3(date5.getMonth() + 1)}-${pad3(date5.getDate())} ` + `${pad3(date5.getHours())}:${pad3(date5.getMinutes())}:${pad3(date5.getSeconds())}`;
 }
 function short(sha) {
   return sha.slice(0, 7);
@@ -37168,7 +39588,7 @@ function renderBuild(out, staleness) {
 }
 function lastActivity(now) {
   try {
-    const mtimeMs = statSync11(daemonLogPath()).mtimeMs;
+    const mtimeMs = statSync13(daemonLogPath()).mtimeMs;
     return formatRelative(now.getTime() - mtimeMs);
   } catch {
     return null;
@@ -37203,6 +39623,27 @@ async function runStatus(args, deps = {}) {
   if (activity)
     out.info(cont(`last activity ${activity}`));
   out.info("");
+  const sessions = listSessions(slug, {
+    aliveFn: deps.aliveFn,
+    startTimeFn: deps.sessionStartTimeFn,
+    mtimeFn: deps.sessionMtimeFn
+  });
+  const selfPidRaw = process.env.CLAUDE_PID;
+  const selfPid = selfPidRaw ? Number.parseInt(selfPidRaw, 10) : null;
+  const selfSessionId = process.env.CLAUDE_CODE_SESSION_ID ?? null;
+  const sessionLines = renderSessionLines(sessions.live, now, Number.isInteger(selfPid) ? selfPid : null, selfSessionId, formatRelative);
+  const count = sessions.live.length;
+  const reapNote = sessions.reaped > 0 ? ` (cleared ${sessions.reaped} ended session${sessions.reaped === 1 ? "" : "s"})` : "";
+  out.info(row("Sessions", count === 0 ? `None registered on this machine.${reapNote}` : `${count} live on this machine${reapNote}`));
+  if (count > 0 || sessions.unknown > 0 || sessions.ended > 0) {
+    if (count > 0)
+      for (const line of sessionLines)
+        out.info(cont(line));
+    for (const line of sessionCaveats(count, sessions.unknown, sessions.ended)) {
+      out.info(cont(line));
+    }
+  }
+  out.info("");
   let localState;
   try {
     localState = loadState(slug);
@@ -37291,7 +39732,7 @@ var versionCommand = defineCommand({
 });
 
 // src/commands/voice-gate.ts
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 
 // src/lib/voice-gate/api.ts
 var VoiceGateSurfaces = [
@@ -37393,15 +39834,15 @@ async function callVoiceGate(req) {
 }
 
 // src/lib/voice-gate/attempts.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import {
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync20,
-  renameSync as renameSync7,
-  unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync8
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync22,
+  renameSync as renameSync8,
+  unlinkSync as unlinkSync8,
+  writeFileSync as writeFileSync9
 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 var MAX_REGENS = 2;
 var ENTRY_TTL_MS = 24 * 60 * 60 * 1000;
 var AttemptEntrySchema = exports_external.object({
@@ -37414,20 +39855,20 @@ var AttemptsFileSchema = exports_external.object({
   entries: exports_external.record(exports_external.string(), AttemptEntrySchema)
 });
 function attemptsDir(workspaceSlug) {
-  return join14(plinthHome(), "_voice_gate", workspaceSlug);
+  return join16(plinthHome(), "_voice_gate", workspaceSlug);
 }
 function attemptsPath(workspaceSlug) {
-  return join14(attemptsDir(workspaceSlug), "attempts.json");
+  return join16(attemptsDir(workspaceSlug), "attempts.json");
 }
 function attemptKey(identity) {
-  return createHash3("sha256").update(identity, "utf8").digest("hex").slice(0, 32);
+  return createHash4("sha256").update(identity, "utf8").digest("hex").slice(0, 32);
 }
 function emptyFile() {
   return { version: 1, entries: {} };
 }
 function load2(workspaceSlug) {
   try {
-    const raw = readFileSync20(attemptsPath(workspaceSlug), "utf8");
+    const raw = readFileSync22(attemptsPath(workspaceSlug), "utf8");
     const parsed = AttemptsFileSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : emptyFile();
   } catch {
@@ -37442,19 +39883,19 @@ function prune(file2, now) {
   }));
   return { version: 1, entries };
 }
-var tmpCounter = 0;
+var tmpCounter2 = 0;
 function save(workspaceSlug, file2) {
   const dir = attemptsDir(workspaceSlug);
   const target = attemptsPath(workspaceSlug);
-  const tmp = `${target}.${process.pid}.${tmpCounter++}.tmp`;
-  mkdirSync9(dir, { recursive: true, mode: 448 });
-  writeFileSync8(tmp, `${JSON.stringify(file2, null, 2)}
+  const tmp = `${target}.${process.pid}.${tmpCounter2++}.tmp`;
+  mkdirSync11(dir, { recursive: true, mode: 448 });
+  writeFileSync9(tmp, `${JSON.stringify(file2, null, 2)}
 `, { mode: 384 });
   try {
-    renameSync7(tmp, target);
+    renameSync8(tmp, target);
   } catch (err) {
     try {
-      unlinkSync7(tmp);
+      unlinkSync8(tmp);
     } catch {}
     throw err;
   }
@@ -37590,7 +40031,7 @@ function denyUngated(detail) {
 }
 
 // src/lib/voice-gate/payload.ts
-import { readFileSync as readFileSync21, statSync as statSync12 } from "node:fs";
+import { readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
 var MAX_BODY_BYTES = 256 * 1024;
@@ -37600,7 +40041,7 @@ function isRawGwsDraftCreate(tokens) {
   return tokens[0] === "gws" && tokens.includes("drafts") && tokens.includes("create");
 }
 var MCP_GMAIL_DRAFT_PATTERN = /^mcp__.*gmail.*__(create|update)_draft$/i;
-function asString(value) {
+function asString2(value) {
   return typeof value === "string" ? value : null;
 }
 function asNonEmptyString(value) {
@@ -37747,11 +40188,11 @@ function isHelperInvocation(tokens) {
   return helperIndex === start + 1 && /(^|\/)python[0-9.]*$/.test(prev);
 }
 function defaultReadBodyFile(path5) {
-  const stat4 = statSync12(path5);
+  const stat4 = statSync14(path5);
   if (stat4.size > MAX_BODY_BYTES) {
     throw new Error(`draft body is ${stat4.size} bytes, over the ${MAX_BODY_BYTES}-byte gate limit`);
   }
-  return readFileSync21(path5, "utf8");
+  return readFileSync23(path5, "utf8");
 }
 function parseRecipients(...raw) {
   const all = raw.filter((v2) => typeof v2 === "string").flatMap((v2) => v2.split(",")).map((v2) => v2.trim().toLowerCase()).filter((v2) => v2.length > 0);
@@ -37839,10 +40280,10 @@ function classifyHelperSegment(tokens, dirState, readBodyFile) {
 }
 function classifyBash(payload, readBodyFile) {
   const input = asRecord(payload.tool_input);
-  const command = asString(input.command);
+  const command = asString2(input.command);
   if (!command)
     return { gated: false };
-  const cwd = asString(payload.cwd);
+  const cwd = asString2(payload.cwd);
   let dirState = cwd ? { dir: cwd, known: true } : { dir: process.cwd(), known: true };
   const items = [];
   for (const segment of splitCommandSegments(command)) {
@@ -37883,7 +40324,7 @@ function classifyMcp(payload) {
       ]
     };
   }
-  const subject = asString(input.subject) ?? "";
+  const subject = asString2(input.subject) ?? "";
   return {
     gated: true,
     items: [
@@ -37891,7 +40332,7 @@ function classifyMcp(payload) {
         draft: {
           site: "mcp-gmail",
           recipients: parseRecipients(asStringArray(input.to).join(","), asStringArray(input.cc).join(","), asStringArray(input.bcc).join(",")),
-          threadId: asString(input.replyToMessageId) || asString(input.draftId) || null,
+          threadId: asString2(input.replyToMessageId) || asString2(input.draftId) || null,
           subject,
           text: composeDraftText(subject, body)
         }
@@ -37902,7 +40343,7 @@ function classifyMcp(payload) {
 function classifyPayload(payload, deps = {}) {
   const readBodyFile = deps.readBodyFile ?? defaultReadBodyFile;
   try {
-    const toolName = asString(payload.tool_name);
+    const toolName = asString2(payload.tool_name);
     if (!toolName)
       return { gated: false };
     if (toolName === "Bash")
@@ -37928,7 +40369,7 @@ var diskAttempts = {
   recordFailure: (slug, key, reason) => recordFailure(slug, key, reason),
   clear: clearAttempt
 };
-async function defaultReadStdin() {
+async function defaultReadStdin2() {
   if (process.stdin.isTTY)
     return "";
   const chunks = [];
@@ -38037,7 +40478,7 @@ async function gateOneDraft(draft, sessionId, auth, deps) {
 }
 async function runVoiceGateHook(args, deps = {}) {
   const sink = deps.sink ?? { stdout: process.stdout, stderr: process.stderr };
-  const readStdin = deps.readStdin ?? defaultReadStdin;
+  const readStdin = deps.readStdin ?? defaultReadStdin2;
   const raw = await readStdin().catch(() => "");
   let payload;
   try {
@@ -38102,7 +40543,7 @@ function isSurface(value) {
 async function runVoiceGateDirect(args, deps = {}) {
   const { Output: Output2 } = await Promise.resolve().then(() => (init_output(), exports_output));
   const out = new Output2({ sink: deps.sink, noColor: deps.noColor });
-  const readStdin = deps.readStdin ?? defaultReadStdin;
+  const readStdin = deps.readStdin ?? defaultReadStdin2;
   const surfaceArg = args.surface ?? "email_draft";
   if (!isSurface(surfaceArg)) {
     out.error(`Unknown surface "${surfaceArg}". Expected one of: ${VoiceGateSurfaces.join(", ")}.`);
@@ -38111,7 +40552,7 @@ async function runVoiceGateDirect(args, deps = {}) {
   let text;
   if (args.file) {
     try {
-      text = readFileSync22(args.file, "utf8");
+      text = readFileSync24(args.file, "utf8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       out.error(`Could not read ${args.file}: ${msg}`);
@@ -38256,7 +40697,9 @@ var main = defineCommand({
     "voice-gate": voiceGateCommand,
     backlinks: backlinksCommand,
     declare: declareCommand,
-    "review-tier": reviewTierCommand
+    "review-tier": reviewTierCommand,
+    session: sessionCommand,
+    "memory-gate": memoryGateCommand
   }
 });
 runMain(main);