chamba 0.2.0 → 0.3.1

package/dist/cli.js

@@ -13,17 +13,17 @@ import { z as z3 } from "zod";
 // packages/shared/src/messages.ts
 import { z as z2 } from "zod";
 
-// packages/shared/src/session.ts
+// packages/shared/src/events.ts
 import { z } from "zod";
-var sessionKindSchema = z.enum(["everyday", "spec"]);
-var sessionStatusSchema = z.enum(["active", "ended"]);
-var sessionMetaSchema = z.object({
-  id: z.string().min(1),
-  kind: sessionKindSchema.optional(),
-  title: z.string().optional(),
-  status: sessionStatusSchema,
-  createdAt: z.string().datetime(),
-  updatedAt: z.string().datetime()
+var eventSourceSchema = z.enum(["user", "agent", "system"]);
+var eventEnvelopeSchema = z.object({
+  id: z.uuid(),
+  seq: z.number().int().nonnegative(),
+  sessionId: z.string().min(1),
+  ts: z.iso.datetime(),
+  type: z.string().min(1),
+  source: eventSourceSchema,
+  payload: z.unknown()
 });
 
 // packages/shared/src/messages.ts
@@ -34,22 +34,23 @@ var attachmentSchema = z2.object({
   contentType: z2.string().min(1),
   size: z2.number().int().nonnegative()
 });
+var replyRefSchema = z2.object({
+  seq: z2.number().int().nonnegative(),
+  id: z2.string().min(1),
+  source: eventSourceSchema,
+  snippet: z2.string()
+});
 var messagePayloadSchema = z2.object({
   text: z2.string().min(1).optional(),
-  attachments: z2.array(attachmentSchema).optional()
+  attachments: z2.array(attachmentSchema).optional(),
+  replyTo: replyRefSchema.optional(),
+  answerIn: z2.literal("terminal").optional()
 }).refine((p) => (p.text?.length ?? 0) > 0 || (p.attachments?.length ?? 0) > 0, {
-  message: "a message needs text or at least one attachment"
+  error: "a message needs text or at least one attachment"
 });
-var systemReasonSchema = z2.enum([
-  "session-created",
-  "user-moved-away",
-  "session-ended",
-  "kind-chosen"
-]);
+var systemReasonSchema = z2.enum(["session-created", "session-ended"]);
 var systemPayloadSchema = z2.object({
-  reason: systemReasonSchema,
-  to: z2.string().min(1).optional(),
-  kind: sessionKindSchema.optional()
+  reason: systemReasonSchema
 });
 
 // packages/shared/src/annotations.ts
@@ -83,147 +84,169 @@ var annotationBatchPayloadSchema = z3.object({
 });
 
 // packages/shared/src/api.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
-// packages/shared/src/events.ts
+// packages/shared/src/presence.ts
 import { z as z4 } from "zod";
-var eventSourceSchema = z4.enum(["user", "agent", "system"]);
-var eventEnvelopeSchema = z4.object({
-  id: z4.string().uuid(),
-  seq: z4.number().int().nonnegative(),
-  sessionId: z4.string().min(1),
-  ts: z4.string().datetime(),
-  type: z4.string().min(1),
-  source: eventSourceSchema,
-  payload: z4.unknown()
-});
+var presenceSchema = z4.enum(["listening", "working", "away"]);
 
-// packages/shared/src/presence.ts
+// packages/shared/src/session.ts
 import { z as z5 } from "zod";
-var presenceSchema = z5.enum(["listening", "working", "away"]);
-
-// packages/shared/src/spec.ts
-import { z as z6 } from "zod";
-var QUESTION_CARD = "question-card";
-var DECISION = "decision";
-var ARTIFACT = "artifact";
-var questionOptionSchema = z6.object({
-  label: z6.string().min(1),
-  description: z6.string().min(1),
-  recommended: z6.boolean().optional()
-});
-var questionCardPayloadSchema = z6.object({
-  cardId: z6.string().uuid(),
-  question: z6.string().min(1),
-  options: z6.array(questionOptionSchema).min(2).max(6),
-  /** Optional custom wording for the stop-anytime affordance. */
-  stopHint: z6.string().min(1).optional()
-});
-var decisionStatusSchema = z6.enum(["confirmed", "assumed"]);
-var decisionPayloadSchema = z6.object({
-  summary: z6.string().min(1),
-  status: decisionStatusSchema,
-  detail: z6.string().min(1).optional()
-});
-var artifactKindSchema = z6.enum(["draft", "mock", "diagram"]);
-var artifactRefSchema = z6.object({
-  kind: artifactKindSchema,
-  name: z6.string().min(1),
-  relPath: z6.string().min(1),
-  contentType: z6.string().min(1),
-  size: z6.number().int().nonnegative()
-});
-var artifactPayloadSchema = z6.object({
-  artifact: artifactRefSchema
+var sessionStatusSchema = z5.enum(["active", "ended"]);
+var sessionMetaSchema = z5.object({
+  id: z5.string().min(1),
+  /** The agent session that created this session (e.g. a Claude Code session id).
+   * `open` uses it to reconnect the same agent session to its existing workspace. */
+  agentKey: z5.string().min(1).optional(),
+  title: z5.string().optional(),
+  status: sessionStatusSchema,
+  createdAt: z5.string().datetime(),
+  updatedAt: z5.string().datetime()
 });
 
 // packages/shared/src/api.ts
-var cursorSchema = z7.number().int().nonnegative();
-var createSessionReqSchema = z7.object({
-  kind: sessionKindSchema.optional(),
-  title: z7.string().min(1).optional()
-});
-var setSessionKindReqSchema = z7.object({
-  kind: sessionKindSchema
+var cursorSchema = z6.number().int().nonnegative();
+var POLL_DEFAULT_WAIT_MS = 25e3;
+var POLL_MAX_WAIT_MS = 3e4;
+var SESSION_QUERY_PARAM = "s";
+function sessionPageUrl(baseUrl, id) {
+  return `${baseUrl.replace(/\/+$/, "")}/?${SESSION_QUERY_PARAM}=${encodeURIComponent(id)}`;
+}
+async function errorBodyMessage(res) {
+  try {
+    const body = await res.json();
+    return typeof body.error === "string" ? body.error : null;
+  } catch {
+    return null;
+  }
+}
+var createSessionReqSchema = z6.object({
+  title: z6.string().min(1).optional(),
+  agentKey: z6.string().min(1).optional()
 });
-var messageBodySchema = z7.object({
-  text: z7.string().min(1).optional(),
-  attachmentIds: z7.array(z7.string().min(1)).optional()
-}).refine((r) => (r.text?.length ?? 0) > 0 || (r.attachmentIds?.length ?? 0) > 0, {
-  message: "a message needs text or at least one attachment"
+var messageBodyBase = z6.object({
+  text: z6.string().min(1).optional(),
+  attachmentIds: z6.array(z6.string().min(1)).optional(),
+  replyTo: z6.number().int().nonnegative().optional()
 });
-var annotationItemReqSchema = z7.object({
-  note: z7.string().min(1).optional(),
+var needsContent = (r) => (r.text?.length ?? 0) > 0 || (r.attachmentIds?.length ?? 0) > 0;
+var needsContentMessage = { error: "a message needs text or at least one attachment" };
+var postMessageReqSchema = messageBodyBase.extend({ answerIn: z6.literal("terminal").optional() }).refine(needsContent, needsContentMessage);
+var replyReqSchema = messageBodyBase.refine(needsContent, needsContentMessage);
+var annotationItemReqSchema = z6.object({
+  note: z6.string().min(1).optional(),
   target: annotationTargetSchema,
-  screenshotAttachmentId: z7.string().min(1).optional()
+  screenshotAttachmentId: z6.string().min(1).optional()
 });
-var postAnnotationsReqSchema = z7.object({
-  items: z7.array(annotationItemReqSchema).min(1)
+var postAnnotationsReqSchema = z6.object({
+  items: z6.array(annotationItemReqSchema).min(1)
 });
-var moveAwayReqSchema = z7.object({
-  to: z7.string().min(1).optional()
-});
-var postQuestionCardReqSchema = questionCardPayloadSchema;
-var postDecisionReqSchema = decisionPayloadSchema;
-var postArtifactReqSchema = z7.object({
-  kind: artifactKindSchema,
-  name: z7.string().min(1),
-  content: z7.string().min(1)
-});
-var attachmentResSchema = z7.object({
+var attachmentResSchema = z6.object({
   attachment: attachmentSchema
 });
-var eventResSchema = z7.object({
+var eventResSchema = z6.object({
   event: eventEnvelopeSchema
 });
-var pollResSchema = z7.object({
-  events: z7.array(eventEnvelopeSchema),
+var pollResSchema = z6.object({
+  events: z6.array(eventEnvelopeSchema),
   cursor: cursorSchema,
-  ended: z7.boolean().optional()
+  ended: z6.boolean().optional(),
+  /** Set when the server is shutting down on purpose and woke this poll to say
+   * so; the caller should exit its loop cleanly instead of retrying. */
+  stopping: z6.boolean().optional()
 });
-var fetchMoreSchema = z7.object({
-  hasMore: z7.boolean(),
+var fetchMoreSchema = z6.object({
+  hasMore: z6.boolean(),
   earliestLoadedSeq: cursorSchema,
-  hint: z7.string()
+  hint: z6.string()
 });
-var attachDigestSchema = z7.object({
+var attachDigestSchema = z6.object({
   meta: sessionMetaSchema,
   presence: presenceSchema,
-  tail: z7.array(eventEnvelopeSchema),
+  tail: z6.array(eventEnvelopeSchema),
   cursor: cursorSchema,
   fetchMore: fetchMoreSchema
 });
-var sessionSummarySchema = z7.object({
+var sessionSummarySchema = z6.object({
   meta: sessionMetaSchema,
   presence: presenceSchema
 });
-var listResSchema = z7.object({
-  sessions: z7.array(sessionSummarySchema)
+var listResSchema = z6.object({
+  sessions: z6.array(sessionSummarySchema)
 });
-var sessionResSchema = z7.object({
+var sessionResSchema = z6.object({
   session: sessionSummarySchema
 });
-var healthResSchema = z7.object({
-  ok: z7.boolean(),
+var healthResSchema = z6.object({
+  ok: z6.boolean(),
   sessions: cursorSchema,
-  home: z7.string().min(1).optional(),
-  port: z7.number().int().positive().optional(),
-  version: z7.string().min(1).optional()
+  home: z6.string().min(1).optional(),
+  port: z6.number().int().positive().optional(),
+  version: z6.string().min(1).optional()
 });
 
 // packages/shared/src/issues.ts
-import { z as z8 } from "zod";
-var issueTypeSchema = z8.enum(["bug", "feature"]);
-var postIssueReqSchema = z8.object({
+import { z as z7 } from "zod";
+var issueTypeSchema = z7.enum(["bug", "feature"]);
+var postIssueReqSchema = z7.object({
   type: issueTypeSchema,
-  text: z8.string().min(1),
-  screenshotAttachmentIds: z8.array(z8.string().min(1)).optional()
+  text: z7.string().min(1),
+  screenshotAttachmentIds: z7.array(z7.string().min(1)).optional()
+});
+var issueResSchema = z7.object({
+  id: z7.string().min(1),
+  path: z7.string().min(1)
+});
+
+// packages/shared/src/page.ts
+import { z as z8 } from "zod";
+var PAGE = "page";
+var pageRefSchema = z8.object({
+  name: z8.string().min(1),
+  relPath: z8.string().min(1),
+  contentType: z8.string().min(1),
+  size: z8.number().int().nonnegative()
+});
+var pagePayloadSchema = z8.object({
+  page: pageRefSchema
 });
-var issueResSchema = z8.object({
-  id: z8.string().min(1),
-  path: z8.string().min(1)
+var postPageReqSchema = z8.object({
+  name: z8.string().min(1).max(120),
+  content: z8.string().min(1)
 });
 
+// packages/shared/src/payload.ts
+var attachmentsSchema = attachmentSchema.array();
+function eventText(event) {
+  const payload = event.payload;
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    if (typeof record.text === "string") return record.text;
+    if (typeof record.reason === "string") return record.reason;
+  }
+  return "";
+}
+function eventAttachments(event) {
+  if (!event.payload || typeof event.payload !== "object") return [];
+  const parsed = attachmentsSchema.safeParse(
+    event.payload.attachments
+  );
+  return parsed.success ? parsed.data : [];
+}
+
+// packages/shared/src/reference.ts
+function parseRef(input) {
+  let ref = input.trim();
+  const token = ref.match(/^\[?\s*chamba\s+([^\s\]]+)/i);
+  if (token?.[1]) ref = token[1];
+  const match = ref.match(/^(?:([A-Za-z0-9_-]+)#)?#?(\d+)$/);
+  if (!match?.[2]) return null;
+  return { ...match[1] ? { session: match[1] } : {}, seq: Number(match[2]) };
+}
+function sourceLabel(source) {
+  return source === "user" ? "you" : source;
+}
+
 // packages/shared/src/ws.ts
 import { z as z9 } from "zod";
 var wsServerMessageSchema = z9.discriminatedUnion("t", [
@@ -240,10 +263,6 @@ var wsServerMessageSchema = z9.discriminatedUnion("t", [
     t: z9.literal("presence"),
     state: presenceSchema
   }),
-  z9.object({
-    t: z9.literal("kind"),
-    meta: sessionMetaSchema
-  }),
   z9.object({
     t: z9.literal("ended"),
     meta: sessionMetaSchema
@@ -255,40 +274,100 @@ import { createNodeWebSocket } from "@hono/node-ws";
 import { Hono } from "hono";
 
 // packages/server/src/inject.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// packages/server/src/static.ts
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-function resolveInjectDist() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  const dev = path.resolve(here, "../../inject/dist");
-  const packaged = path.resolve(here, "../inject");
-  return [dev, packaged].find((dir) => existsSync(path.join(dir, "annotate.js"))) ?? dev;
-}
 
-// packages/server/src/render.ts
-import { marked } from "marked";
+// packages/server/src/mime.ts
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".map": "application/json; charset=utf-8",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8"
+};
+var EXTENSIONS = {};
+for (const [ext, type] of Object.entries(CONTENT_TYPES)) {
+  const base = type.split(";")[0] ?? type;
+  if (!(base in EXTENSIONS)) EXTENSIONS[base] = ext;
+}
 
 // packages/server/src/static.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path2 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveWebDist() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const dev = path.resolve(here, "../../web/dist");
+  const packaged = path.resolve(here, "../web");
+  return [dev, packaged].find((dir) => existsSync(path.join(dir, "index.html"))) ?? dev;
+}
+
+// packages/server/src/inject.ts
+function resolveInjectDist() {
   const here = path2.dirname(fileURLToPath2(import.meta.url));
-  const dev = path2.resolve(here, "../../web/dist");
-  const packaged = path2.resolve(here, "../web");
-  return [dev, packaged].find((dir) => existsSync2(path2.join(dir, "index.html"))) ?? dev;
+  const dev = path2.resolve(here, "../../inject/dist");
+  const packaged = path2.resolve(here, "../inject");
+  return [dev, packaged].find((dir) => existsSync2(path2.join(dir, "annotate.js"))) ?? dev;
 }
 
-// packages/server/src/app.ts
-var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+// packages/server/src/version.ts
+import { existsSync as existsSync3, readFileSync } from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function chambaVersion() {
+  let dir = path3.dirname(fileURLToPath3(import.meta.url));
+  for (; ; ) {
+    const manifest = path3.join(dir, "package.json");
+    if (existsSync3(manifest)) {
+      try {
+        const { version } = JSON.parse(readFileSync(manifest, "utf8"));
+        if (typeof version === "string" && version) return version;
+      } catch {
+      }
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) return "0.0.0-dev";
+    dir = parent;
+  }
+}
 
-// packages/server/src/lifecycle.ts
-import { open, readFile as readFile2, rm } from "node:fs/promises";
+// packages/server/src/sessions/meta.ts
+import { readdir, readFile as readFile2 } from "node:fs/promises";
+
+// packages/server/src/sessions/atomic.ts
+import { randomUUID } from "node:crypto";
+import { rename, rm, writeFile } from "node:fs/promises";
+async function writeJsonAtomic(file, value) {
+  const tmp = `${file}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await rename(tmp, file);
+  } catch (err) {
+    await rm(tmp, { force: true }).catch(() => void 0);
+    throw err;
+  }
+}
 
 // packages/server/src/sessions/paths.ts
-import { existsSync as existsSync3, realpathSync } from "node:fs";
+import { existsSync as existsSync4, realpathSync } from "node:fs";
 import { appendFile, mkdir, readFile } from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 function defaultContext() {
   return { cwd: process.cwd(), env: process.env };
 }
@@ -301,70 +380,70 @@ function findExistingHome(ctx = defaultContext()) {
   const inside = enclosingChamba(ctx.cwd);
   if (inside) return canonicalize(inside);
   const root = gitRoot(ctx.cwd);
-  let cursor = path3.resolve(ctx.cwd);
+  let cursor = path4.resolve(ctx.cwd);
   while (true) {
-    if (existsSync3(path3.join(cursor, ".chamba"))) return canonicalize(path3.join(cursor, ".chamba"));
+    if (existsSync4(path4.join(cursor, ".chamba"))) return canonicalize(path4.join(cursor, ".chamba"));
     if (!root) break;
     if (cursor === root) break;
-    const parent = path3.dirname(cursor);
+    const parent = path4.dirname(cursor);
     if (parent === cursor) break;
     cursor = parent;
   }
   return null;
 }
 function plannedHome(ctx = defaultContext()) {
-  const root = gitRoot(ctx.cwd) ?? path3.resolve(ctx.cwd);
-  return canonicalize(path3.join(root, ".chamba"));
+  const root = gitRoot(ctx.cwd) ?? path4.resolve(ctx.cwd);
+  return canonicalize(path4.join(root, ".chamba"));
 }
 function gitRoot(cwd) {
-  let cursor = path3.resolve(cwd);
+  let cursor = path4.resolve(cwd);
   while (true) {
-    if (existsSync3(path3.join(cursor, ".git"))) return cursor;
-    const parent = path3.dirname(cursor);
+    if (existsSync4(path4.join(cursor, ".git"))) return cursor;
+    const parent = path4.dirname(cursor);
     if (parent === cursor) return null;
     cursor = parent;
   }
 }
 function enclosingChamba(cwd) {
-  const parts = path3.resolve(cwd).split(path3.sep);
+  const parts = path4.resolve(cwd).split(path4.sep);
   const index = parts.lastIndexOf(".chamba");
   if (index < 0) return null;
-  return parts.slice(0, index + 1).join(path3.sep) || path3.sep;
+  return parts.slice(0, index + 1).join(path4.sep) || path4.sep;
 }
 function canonicalize(p) {
-  const resolved = path3.resolve(p);
+  const resolved = path4.resolve(p);
   let existing = resolved;
   const tail = [];
-  while (!existsSync3(existing)) {
-    tail.unshift(path3.basename(existing));
-    const parent = path3.dirname(existing);
+  while (!existsSync4(existing)) {
+    tail.unshift(path4.basename(existing));
+    const parent = path4.dirname(existing);
     if (parent === existing) return resolved;
     existing = parent;
   }
-  return path3.join(realpathSync(existing), ...tail);
+  return path4.join(realpathSync(existing), ...tail);
 }
 function sessionsDir(home) {
-  return path3.join(home, "sessions");
+  return path4.join(home, "sessions");
 }
 function sessionDir(home, id) {
-  return path3.join(sessionsDir(home), id);
+  return path4.join(sessionsDir(home), id);
 }
 function metaPath(home, id) {
-  return path3.join(sessionDir(home, id), "meta.json");
+  return path4.join(sessionDir(home, id), "meta.json");
 }
 function pidfilePath(home) {
-  return path3.join(home, "server.json");
+  return path4.join(home, "server.json");
 }
 function agentStatePath(home) {
-  return path3.join(home, "agent-state.json");
+  return path4.join(home, "agent-state.json");
 }
 async function ensureChambaHome(home) {
   await mkdir(sessionsDir(home), { recursive: true });
   await ensureGitignored(home);
 }
 async function ensureGitignored(home) {
-  if (path3.basename(home) !== ".chamba") return;
-  const gitignore = path3.join(path3.dirname(home), ".gitignore");
+  if (path4.basename(home) !== ".chamba") return;
+  const gitignore = path4.join(path4.dirname(home), ".gitignore");
   const entry = ".chamba/";
   try {
     let content = "";
@@ -385,13 +464,37 @@ async function ensureGitignored(home) {
   }
 }
 
+// packages/server/src/sessions/meta.ts
+async function readMeta(home, id) {
+  try {
+    const raw = await readFile2(metaPath(home, id), "utf8");
+    return sessionMetaSchema.parse(JSON.parse(raw));
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function listSessionIds(home) {
+  try {
+    const entries = await readdir(sessionsDir(home), { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+
+// packages/server/src/app.ts
+var MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+
 // packages/server/src/lifecycle.ts
+import { open, readFile as readFile3, rm as rm2 } from "node:fs/promises";
 function readServerInfo(home) {
   return readPidfile(pidfilePath(home));
 }
 async function readPidfile(file) {
   try {
-    const raw = await readFile2(file, "utf8");
+    const raw = await readFile3(file, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.pid === "number" && typeof parsed.port === "number") return parsed;
     return null;
@@ -441,48 +544,6 @@ function parsePort(value, source) {
   return port;
 }
 
-// packages/server/src/version.ts
-import { existsSync as existsSync4, readFileSync } from "node:fs";
-import path4 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-function chambaVersion() {
-  let dir = path4.dirname(fileURLToPath3(import.meta.url));
-  for (; ; ) {
-    const manifest = path4.join(dir, "package.json");
-    if (existsSync4(manifest)) {
-      try {
-        const { version } = JSON.parse(readFileSync(manifest, "utf8"));
-        if (typeof version === "string" && version) return version;
-      } catch {
-      }
-    }
-    const parent = path4.dirname(dir);
-    if (parent === dir) return "0.0.0-dev";
-    dir = parent;
-  }
-}
-
-// packages/server/src/sessions/meta.ts
-import { readdir, readFile as readFile3, rename, rm as rm2, writeFile } from "node:fs/promises";
-async function readMeta(home, id) {
-  try {
-    const raw = await readFile3(metaPath(home, id), "utf8");
-    return sessionMetaSchema.parse(JSON.parse(raw));
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
-  }
-}
-async function listSessionIds(home) {
-  try {
-    const entries = await readdir(sessionsDir(home), { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch (err) {
-    if (err.code === "ENOENT") return [];
-    throw err;
-  }
-}
-
 // packages/server/src/index.ts
 var DEFAULT_IDLE_MS = 5 * 6e4;
 
@@ -522,11 +583,13 @@ var ChannelError = class extends Error {
     this.status = status2;
     this.name = "ChannelError";
   }
+  status;
 };
 var Client = class {
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
   }
+  baseUrl;
   /** Liveness probe with a short deadline; never throws - `false` means "spawn it". */
   async isUp(timeoutMs = 800) {
     try {
@@ -539,6 +602,17 @@ var Client = class {
   async health() {
     return this.json("/api/health", { method: "GET", timeoutMs: 2e3 }, healthResSchema);
   }
+  /** True when a server answers here *and* reports `home` as the workspace it
+   * owns - the identity check that keeps commands off a foreign server sharing
+   * the port (derived ports can collide across projects). Never throws. */
+  async ownsHome(home) {
+    if (!await this.isUp()) return false;
+    try {
+      return (await this.health()).home === home;
+    } catch {
+      return false;
+    }
+  }
   async create(req) {
     const res = await this.json(
       "/api/sessions",
@@ -575,28 +649,10 @@ var Client = class {
     );
     return res.event;
   }
-  /** Post a structured interview question card (spec sessions). Agent-sourced. */
-  async postQuestionCard(id, body) {
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/cards`,
-      { method: "POST", body, timeoutMs: 5e3 },
-      eventResSchema
-    );
-    return res.event;
-  }
-  /** Record a decision-log entry (confirmed vs. assumed). Agent-sourced. */
-  async postDecision(id, body) {
+  /** Show or revise a page (self-contained HTML for the Illustration tab). */
+  async showPage(id, body) {
     const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/decisions`,
-      { method: "POST", body, timeoutMs: 5e3 },
-      eventResSchema
-    );
-    return res.event;
-  }
-  /** Author or revise a draft/mock/diagram artifact by posting its source text. */
-  async postArtifact(id, body) {
-    const res = await this.json(
-      `/api/sessions/${encodeURIComponent(id)}/artifacts`,
+      `/api/sessions/${encodeURIComponent(id)}/pages`,
       { method: "POST", body, timeoutMs: 1e4 },
       eventResSchema
     );
@@ -639,13 +695,6 @@ var Client = class {
       pollResSchema
     );
   }
-  async attach(id, tail) {
-    return this.json(
-      `/api/sessions/${encodeURIComponent(id)}/attach?tail=${tail}`,
-      { method: "GET", timeoutMs: 5e3 },
-      attachDigestSchema
-    );
-  }
   async end(id) {
     const res = await this.json(
       `/api/sessions/${encodeURIComponent(id)}/end`,
@@ -680,18 +729,12 @@ function bodyInit(body) {
   return { headers: { "content-type": "application/json" }, body: JSON.stringify(body) };
 }
 async function toError(res) {
-  let message = `${res.status} ${res.statusText}`;
-  try {
-    const body = await res.json();
-    if (typeof body.error === "string") message = body.error;
-  } catch {
-  }
+  const message = await errorBodyMessage(res) ?? `${res.status} ${res.statusText}`;
   return new ChannelError(res.status, message);
 }
 
 // packages/cli/src/output.ts
 import path6 from "node:path";
-import { z as z10 } from "zod";
 function out(message) {
   process.stdout.write(`${message}
 `);
@@ -700,42 +743,35 @@ function note(message) {
   process.stderr.write(`${message}
 `);
 }
-function eventText(event) {
-  const payload = event.payload;
-  if (payload && typeof payload === "object") {
-    const record = payload;
-    if (typeof record.text === "string") return record.text;
-    if (typeof record.reason === "string") return record.reason;
-  }
-  return "";
-}
-function eventAttachments(event) {
-  if (!event.payload || typeof event.payload !== "object") return [];
-  const parsed = z10.array(attachmentSchema).safeParse(event.payload.attachments);
-  return parsed.success ? parsed.data : [];
-}
 function formatSystemEvent(event) {
   const parsed = systemPayloadSchema.safeParse(event.payload);
   if (!parsed.success) return `\xB7 ${eventText(event)}`;
-  const { reason, to, kind } = parsed.data;
-  switch (reason) {
-    case "user-moved-away":
-      return to ? `\xB7 You moved to another session (${to})` : "\xB7 The user moved away";
+  switch (parsed.data.reason) {
     case "session-ended":
       return "\xB7 Session ended";
     case "session-created":
       return "\xB7 Session created";
-    case "kind-chosen":
-      return kind ? `\xB7 Session set to ${kind}` : "\xB7 Session kind chosen";
-    default:
-      return `\xB7 ${reason}`;
   }
 }
+function eventMarkers(event) {
+  if (!event.payload || typeof event.payload !== "object") return "";
+  const record = event.payload;
+  const parts = [];
+  const ref = replyRefSchema.safeParse(record.replyTo);
+  if (ref.success) {
+    const who = sourceLabel(ref.data.source);
+    const snippet = ref.data.snippet ? `: "${ref.data.snippet}"` : "";
+    parts.push(`[re #${ref.data.seq} ${who}${snippet}]`);
+  }
+  if (record.answerIn === "terminal") parts.push("[answer in terminal]");
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
 function formatEvent(event) {
   if (event.source === "system") return formatSystemEvent(event);
-  const who = event.source === "user" ? "you" : "agent";
+  const who = sourceLabel(event.source);
+  const markers = eventMarkers(event);
   const text = eventText(event);
-  return text ? `${who}: ${text}` : `${who}:`;
+  return text ? `${who}${markers}: ${text}` : `${who}${markers}:`;
 }
 function annotationItems(event) {
   const parsed = annotationBatchPayloadSchema.safeParse(event.payload);
@@ -743,7 +779,7 @@ function annotationItems(event) {
 }
 function formatAnnotationBatch(event, home) {
   const items = annotationItems(event);
-  const who = event.source === "user" ? "you" : "agent";
+  const who = sourceLabel(event.source);
   const lines = [`${who} [${items.length} annotation${items.length === 1 ? "" : "s"}]:`];
   items.forEach((item, index) => {
     const { target } = item;
@@ -765,34 +801,12 @@ function formatAnnotationBatch(event, home) {
   });
   return lines;
 }
-function formatQuestionCard(event) {
-  const parsed = questionCardPayloadSchema.safeParse(event.payload);
-  if (!parsed.success) return [formatEvent(event)];
-  const card = parsed.data;
-  const lines = [`agent [question]: ${card.question}`];
-  card.options.forEach((option, index) => {
-    const rec = option.recommended ? " (recommended)" : "";
-    lines.push(`  ${index + 1}. ${option.label}${rec} - ${option.description}`);
-  });
-  lines.push(
-    `  (the user can also type a custom answer${card.stopHint ? ` or ${card.stopHint}` : ", or stop anytime"})`
-  );
-  return lines;
-}
-function formatDecision(event) {
-  const parsed = decisionPayloadSchema.safeParse(event.payload);
-  if (!parsed.success) return formatEvent(event);
-  const { status: status2, summary, detail } = parsed.data;
-  return `agent [decision: ${status2}]: ${summary}${detail ? ` - ${detail}` : ""}`;
-}
-function formatArtifact(event, home) {
-  const parsed = artifactRefSchema.safeParse(
-    event.payload?.artifact
-  );
+function formatPage(event, home) {
+  const parsed = pageRefSchema.safeParse(event.payload?.page);
   if (!parsed.success) return formatEvent(event);
   const ref = parsed.data;
   const abs = path6.join(sessionDir(home, event.sessionId), ref.relPath);
-  return `agent [artifact ${ref.kind} "${ref.name}"] -> ${abs}`;
+  return `agent [page "${ref.name}"] -> ${abs}`;
 }
 function printEvents(events, home) {
   for (const event of events) {
@@ -800,16 +814,8 @@ function printEvents(events, home) {
       for (const line of formatAnnotationBatch(event, home)) out(line);
       continue;
     }
-    if (event.type === QUESTION_CARD) {
-      for (const line of formatQuestionCard(event)) out(line);
-      continue;
-    }
-    if (event.type === DECISION) {
-      out(formatDecision(event));
-      continue;
-    }
-    if (event.type === ARTIFACT) {
-      out(formatArtifact(event, home));
+    if (event.type === PAGE) {
+      out(formatPage(event, home));
       continue;
     }
     out(formatEvent(event));
@@ -822,47 +828,41 @@ function formatSession(meta, presence, current) {
   const marker = current ? "*" : " ";
   const title = meta.title ? ` "${meta.title}"` : "";
   const live = presence ? ` ${presence}` : "";
-  return `${marker} ${meta.id}  ${meta.status}${live}  ${meta.kind ?? "unset"}${title}`;
+  return `${marker} ${meta.id}  ${meta.status}${live}${title}`;
 }
 
-// packages/cli/src/commands/artifact.ts
-import { readFile as readFile6 } from "node:fs/promises";
-
 // packages/cli/src/state.ts
-import { randomUUID } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile5, rename as rename2, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile5 } from "node:fs/promises";
 import path7 from "node:path";
-import { z as z11 } from "zod";
-var agentStateSchema = z11.object({
-  currentSessionId: z11.string().optional(),
-  cursors: z11.record(z11.number().int().nonnegative()).default({})
+import { z as z10 } from "zod";
+var agentStateSchema = z10.object({
+  currentSessionId: z10.string().optional(),
+  bindings: z10.record(z10.string(), z10.string()).default({}),
+  cursors: z10.record(z10.string(), z10.number().int().nonnegative()).default({})
 });
+var EMPTY = { bindings: {}, cursors: {} };
 async function readState(home = resolveHome()) {
   try {
     const raw = await readFile5(agentStatePath(home), "utf8");
     return agentStateSchema.parse(JSON.parse(raw));
   } catch {
-    return { cursors: {} };
+    return EMPTY;
   }
 }
 async function writeState(state, home = resolveHome()) {
   const file = agentStatePath(home);
   await mkdir2(path7.dirname(file), { recursive: true });
-  const tmp = `${file}.${randomUUID()}.tmp`;
-  try {
-    await writeFile2(tmp, `${JSON.stringify(state, null, 2)}
-`, "utf8");
-    await rename2(tmp, file);
-  } catch (err) {
-    await rm3(tmp, { force: true }).catch(() => void 0);
-    throw err;
-  }
+  await writeJsonAtomic(file, state);
 }
 function cursorFor(state, id) {
   return state.cursors[id] ?? 0;
 }
-function withSession(state, id, cursor) {
-  return { currentSessionId: id, cursors: { ...state.cursors, [id]: cursor } };
+function withSession(state, id, cursor, key) {
+  return {
+    currentSessionId: id,
+    bindings: key ? { ...state.bindings, [key]: id } : state.bindings,
+    cursors: { ...state.cursors, [id]: cursor }
+  };
 }
 
 // packages/cli/src/commands/context.ts
@@ -872,13 +872,22 @@ var UsageError = class extends Error {
     this.name = "UsageError";
   }
 };
-async function resolveSessionId(ctx) {
+function agentKey(env = process.env) {
+  return env.CHAMBA_SESSION_KEY || env.CLAUDE_CODE_SESSION_ID || void 0;
+}
+async function resolveSessionId(ctx, env = process.env) {
   const flag = ctx.flags.session;
   if (flag === "true" || flag === "") {
     throw new UsageError("`--session` needs a session id, e.g. --session <id>");
   }
   if (flag) return flag;
   const state = await readState(ctx.home);
+  const key = agentKey(env);
+  if (key) {
+    const bound = state.bindings[key];
+    if (bound) return bound;
+    throw new UsageError("no session bound to this agent - run `chamba open`");
+  }
   if (state.currentSessionId) return state.currentSessionId;
   throw new UsageError("no current session - run `chamba open` or pass --session <id>");
 }
@@ -888,116 +897,6 @@ function intFlag(value, fallback) {
   return Number.isInteger(n) && n >= 0 ? n : fallback;
 }
 
-// packages/cli/src/commands/artifact.ts
-async function artifact(ctx) {
-  const kind = artifactKindSchema.safeParse(ctx.flags.kind);
-  if (!kind.success) {
-    throw new UsageError(
-      "usage: chamba artifact --kind draft|mock|diagram --name <name> --file <path>"
-    );
-  }
-  const name = ctx.flags.name?.trim();
-  if (!name || name === "true") throw new UsageError("chamba artifact needs --name <name>");
-  const file = ctx.flags.file;
-  if (!file || file === "true") throw new UsageError("chamba artifact needs --file <path>");
-  let content;
-  try {
-    content = await readFile6(file, "utf8");
-  } catch (err) {
-    throw new UsageError(`could not read ${file}: ${err.message}`);
-  }
-  const result = postArtifactReqSchema.safeParse({ kind: kind.data, name, content });
-  if (!result.success) {
-    throw new UsageError(
-      `invalid artifact: ${result.error.issues.map((i) => i.message).join("; ")}`
-    );
-  }
-  const id = await resolveSessionId(ctx);
-  const event = await ctx.client.postArtifact(id, result.data);
-  const ref = event.payload.artifact;
-  note(`posted ${kind.data} "${name}" to ${id}${ref?.relPath ? ` (${ref.relPath})` : ""}`);
-  return 0;
-}
-
-// packages/cli/src/commands/ask.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { readFile as readFile7 } from "node:fs/promises";
-async function ask(ctx) {
-  const source = await readCardSource(ctx);
-  let parsed;
-  try {
-    parsed = JSON.parse(source);
-  } catch (err) {
-    throw new UsageError(`--json is not valid JSON: ${err.message}`);
-  }
-  if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && !("cardId" in parsed)) {
-    parsed.cardId = randomUUID2();
-  }
-  const result = postQuestionCardReqSchema.safeParse(parsed);
-  if (!result.success) {
-    throw new UsageError(
-      `invalid question card: ${result.error.issues.map((i) => `${i.path.join(".")} ${i.message}`).join("; ")}`
-    );
-  }
-  const id = await resolveSessionId(ctx);
-  await ctx.client.postQuestionCard(id, result.data);
-  note(`asked ${id}: "${result.data.question}" (${result.data.options.length} options)`);
-  return 0;
-}
-async function readCardSource(ctx) {
-  if (ctx.flags.json && ctx.flags.json !== "true") return ctx.flags.json;
-  const file = ctx.positionals[0];
-  if (file) {
-    try {
-      return await readFile7(file, "utf8");
-    } catch (err) {
-      throw new UsageError(`could not read card file ${file}: ${err.message}`);
-    }
-  }
-  throw new UsageError(
-    `usage: chamba ask --json '{"question":"...","options":[...]}' | <file.json>`
-  );
-}
-
-// packages/cli/src/commands/attach.ts
-async function attach(ctx) {
-  const flagId = ctx.flags.session === "true" ? void 0 : ctx.flags.session || void 0;
-  const id = ctx.positionals[0] ?? flagId;
-  if (!id) throw new UsageError("usage: chamba attach <session-id>");
-  const tail = intFlag(ctx.flags.tail, 20);
-  const digest = await ctx.client.attach(id, tail);
-  note(`session ${digest.meta.id} - ${digest.meta.status}, agent ${digest.presence}`);
-  if (digest.fetchMore.hasMore) note(`(${digest.fetchMore.hint})`);
-  printEvents(digest.tail, ctx.home);
-  const state = await readState(ctx.home);
-  await writeState(withSession(state, digest.meta.id, digest.cursor), ctx.home);
-  note(`now current - poll from cursor ${digest.cursor}`);
-  return 0;
-}
-
-// packages/cli/src/commands/decision.ts
-async function decision(ctx) {
-  const summary = ctx.flags.summary?.trim();
-  if (!summary || summary === "true") {
-    throw new UsageError(
-      'usage: chamba decision --status confirmed|assumed --summary "..." [--detail "..."]'
-    );
-  }
-  const detail = ctx.flags.detail && ctx.flags.detail !== "true" ? ctx.flags.detail : void 0;
-  const result = postDecisionReqSchema.safeParse({
-    summary,
-    status: ctx.flags.status,
-    ...detail ? { detail } : {}
-  });
-  if (!result.success) {
-    throw new UsageError("--status must be `confirmed` or `assumed`");
-  }
-  const id = await resolveSessionId(ctx);
-  await ctx.client.postDecision(id, result.data);
-  note(`recorded ${result.data.status} decision on ${id}`);
-  return 0;
-}
-
 // packages/cli/src/commands/end.ts
 async function end(ctx) {
   const id = await resolveSessionId(ctx);
@@ -1006,90 +905,23 @@ async function end(ctx) {
   return 0;
 }
 
-// packages/cli/src/commands/export.ts
-import { copyFile, mkdir as mkdir3, readFile as readFile8, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
-import path8 from "node:path";
-async function exportCmd(ctx) {
-  const dest = ctx.positionals[0];
-  if (!dest) throw new UsageError("usage: chamba export <dest> [--session <id>]");
-  const id = await resolveSessionId(ctx);
-  const { events } = await ctx.client.events(id, 0);
-  const summary = await assemblePackage({
-    events,
-    sessionDir: sessionDir(ctx.home, id),
-    dest: path8.resolve(dest)
-  });
-  note(
-    `exported ${id} -> ${path8.resolve(dest)} (spec.md${summary.hasDraft ? "" : " placeholder"}, ${summary.assets.length} asset${summary.assets.length === 1 ? "" : "s"}, ${summary.decisions} decision${summary.decisions === 1 ? "" : "s"})`
-  );
-  out(path8.resolve(dest));
-  return 0;
-}
-async function assemblePackage(input) {
-  const artifacts = /* @__PURE__ */ new Map();
-  let canonicalDraft;
-  const decisions = [];
-  for (const event of input.events) {
-    if (event.type === ARTIFACT) {
-      const parsed = artifactRefSchema.safeParse(
-        event.payload?.artifact
-      );
-      if (!parsed.success) continue;
-      const ref = parsed.data;
-      artifacts.set(`${ref.kind}:${ref.name}`, ref);
-      if (ref.kind === "draft") canonicalDraft = ref;
-    } else if (event.type === DECISION) {
-      const parsed = decisionPayloadSchema.safeParse(event.payload);
-      if (parsed.success) decisions.push(parsed.data);
-    }
-  }
-  await mkdir3(input.dest, { recursive: true });
-  const assetsDir = path8.join(input.dest, "assets");
-  await rm4(assetsDir, { recursive: true, force: true });
-  const draftBody = canonicalDraft ? await readArtifact(input.sessionDir, canonicalDraft) : void 0;
-  await writeFile3(
-    path8.join(input.dest, "spec.md"),
-    draftBody ?? "# Spec\n\n_No draft was authored in this session._\n",
-    "utf8"
-  );
-  const assets = [];
-  for (const ref of artifacts.values()) {
-    if (ref === canonicalDraft) continue;
-    const src = path8.join(input.sessionDir, ref.relPath);
-    const base = path8.basename(ref.relPath);
-    try {
-      await mkdir3(assetsDir, { recursive: true });
-      await copyFile(src, path8.join(assetsDir, base));
-      assets.push(base);
-    } catch {
-    }
+// packages/cli/src/commands/get.ts
+async function get(ctx) {
+  const input = ctx.positionals.join(" ").trim();
+  if (!input) {
+    throw new UsageError("usage: chamba get <ref>   (42, <session>#42, or a pasted token)");
+  }
+  const ref = parseRef(input);
+  if (!ref) throw new UsageError(`not a message reference: ${input}`);
+  const id = ref.session ?? await resolveSessionId(ctx);
+  const res = await ctx.client.events(id, ref.seq, 1);
+  const event = res.events[0];
+  if (!event || event.seq !== ref.seq) {
+    note(`no event #${ref.seq} in session ${id} on this server`);
+    return 1;
   }
-  await writeFile3(path8.join(input.dest, "decisions.md"), renderDecisions(decisions), "utf8");
-  return { hasDraft: Boolean(draftBody), assets, decisions: decisions.length };
-}
-async function readArtifact(dir, ref) {
-  try {
-    return await readFile8(path8.join(dir, ref.relPath), "utf8");
-  } catch {
-    return void 0;
-  }
-}
-function renderDecisions(decisions) {
-  const confirmed = decisions.filter((d) => d.status === "confirmed");
-  const assumed = decisions.filter((d) => d.status === "assumed");
-  const section = (items) => items.length === 0 ? "_None._\n" : `${items.map((d) => `- ${d.summary}${d.detail ? `
-  ${d.detail}` : ""}`).join("\n")}
-`;
-  return [
-    "# Decision log",
-    "",
-    "## Confirmed",
-    "",
-    section(confirmed),
-    "## Assumed / open questions",
-    "",
-    section(assumed)
-  ].join("\n");
+  printEvents([event], ctx.home);
+  return 0;
 }
 
 // packages/cli/src/commands/help.ts
@@ -1100,45 +932,36 @@ Usage:
   chamba init [dir]          create the .chamba workspace (at the git root, or
              [--here]        <dir>, or the current dir with --here); prints its
                              location and per-project port
-  chamba open [--kind K]     start a session (K: everyday | spec), print its URL
-             [--title T]     (creates the workspace at the repo root if none yet)
-  chamba poll                wait for the next human/system events, blocking across
-             [--wait ms]     quiet windows on its own until a batch arrives (it may
-             [--for ms]      include "user moved away" -> attach, or "session ended"
-             [--once]        -> stop). After a quiet stretch (--for, default 4m) it
-                             prints a heartbeat and exits 0 - just re-run. --once does
-                             one bounded check instead (scripts/tests); --wait is the
-                             per-request window (max 30s)
+  chamba open [--title T]    open a session and print its URL (creates the
+             [--new]         workspace at the repo root if none yet). Reconnects
+             [--last]        to this agent's bound session when one is active;
+                             --new always creates, --last rebinds to the newest
+                             active session
+  chamba poll                wait for the next human/system events, blocking
+             [--wait ms]     indefinitely until a batch arrives (zero cost while
+             [--for ms]      quiet). --for bounds the wait: after a quiet stretch
+             [--once]        it prints a heartbeat and exits 0 - just re-run.
+                             --once does one bounded check instead (scripts/
+                             tests); --wait is the per-request window (max 30s)
   chamba reply <text>        send a line from the agent into the session
+             [--to <seq>]    mark it as answering a specific earlier event
              [--file a,b]    attach files by path (comma-separated); --image is
              [--image a,b]   an alias. text is optional when files are attached
-  chamba attach <id>         load a session's recent tail and make it current
-             [--tail N]
+  chamba get <ref>           print one event by reference: 42, <session>#42, or
+                             a pasted [chamba <session>#42 "..."] token
+  chamba show <file.html>    render a self-contained HTML page in the browser's
+             [--name N]      Illustration tab. Re-show the same name to revise
   chamba end                 end the current session
   chamba stop                stop this project's server (it otherwise self-stops
                              after an idle spell); the next open starts a fresh one
 
-Spec sessions (open with --kind spec):
-  chamba ask --json '{...}'  post a question card (question + 2-6 options with
-             | <file.json>   descriptions, optional "recommended"); a cardId is
-                             created for you. The answer returns as a message
-  chamba decision            record a decision: --status confirmed|assumed
-             --status S        --summary "..." [--detail "..."]
-             --summary T
-  chamba artifact            author/revise a draft (markdown), mock (HTML), or
-             --kind K          diagram (mermaid): --kind draft|mock|diagram
-             --name N          --name <name> --file <path>. Re-post to revise
-             --file P
-  chamba export <dest>       copy the finalized package (spec.md + decisions.md
-                             + assets/) to <dest> (e.g. docs/)
-
   chamba skill install       install the chamba skill (/chamba) into
              [--global]      ./.claude/skills, or ~/.claude/skills with --global
   chamba --version           print the chamba version
   chamba help                show this help
 
 Global:
-  --session <id>             act on a specific session instead of the current one
+  --session <id>             act on a specific session instead of the bound one
   --port <n>                 server port (default: CHAMBA_PORT, else a per-project
                              port derived from the workspace location)`;
 function help(_ctx) {
@@ -1147,7 +970,7 @@ function help(_ctx) {
 }
 
 // packages/cli/src/commands/init.ts
-import path9 from "node:path";
+import path8 from "node:path";
 async function init(ctx) {
   const target = resolveTarget(ctx);
   const existing = findExistingHome({ cwd: target, env: {} });
@@ -1158,20 +981,20 @@ async function init(ctx) {
   if (existing && ctx.flags.here) {
     note(`note: shadowing an existing workspace at ${existing}`);
   }
-  await ensureChambaHome(path9.join(target, ".chamba"));
-  const home = findExistingHome({ cwd: target, env: {} }) ?? path9.join(target, ".chamba");
+  await ensureChambaHome(path8.join(target, ".chamba"));
+  const home = findExistingHome({ cwd: target, env: {} }) ?? path8.join(target, ".chamba");
   report("created chamba workspace", home);
-  if (path9.basename(home) !== ".chamba") {
+  if (path8.basename(home) !== ".chamba") {
     note("warning: home is not a .chamba directory, so it will not be auto-gitignored");
   }
   return 0;
 }
 function resolveTarget(ctx) {
   const explicit = ctx.positionals[0];
-  if (explicit) return path9.resolve(explicit);
+  if (explicit) return path8.resolve(explicit);
   const root = gitRoot(process.cwd());
   if (root) return root;
-  if (ctx.flags.here) return path9.resolve(process.cwd());
+  if (ctx.flags.here) return path8.resolve(process.cwd());
   throw new UsageError(
     "no .git found here - pass a directory (`chamba init <dir>`) or `chamba init --here` to choose where .chamba lives"
   );
@@ -1186,7 +1009,7 @@ function report(headline, home) {
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
 import { createRequire } from "node:module";
-import path10 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
 var require2 = createRequire(import.meta.url);
 async function ensureServer(client, target) {
@@ -1220,17 +1043,17 @@ function spawnServer(target) {
   child.unref();
 }
 function serverLaunchArgs() {
-  const here = path10.dirname(fileURLToPath4(import.meta.url));
-  const packagedServer = path10.join(here, "server.js");
+  const here = path9.dirname(fileURLToPath4(import.meta.url));
+  const packagedServer = path9.join(here, "server.js");
   if (existsSync5(packagedServer)) return [packagedServer];
   const serverBin = require2.resolve("@chamba/server/bin");
   const tsxLoader = pathToFileURL(require2.resolve("tsx")).href;
   return ["--import", tsxLoader, serverBin];
 }
 function ensureDevBuilds() {
-  const here = path10.dirname(fileURLToPath4(import.meta.url));
-  if (existsSync5(path10.join(here, "server.js"))) return;
-  const repoRoot = path10.resolve(path10.dirname(require2.resolve("@chamba/server/bin")), "../../..");
+  const here = path9.dirname(fileURLToPath4(import.meta.url));
+  if (existsSync5(path9.join(here, "server.js"))) return;
+  const repoRoot = path9.resolve(path9.dirname(require2.resolve("@chamba/server/bin")), "../../..");
   const deps = [
     { label: "web UI", filter: "@chamba/web", dist: resolveWebDist(), marker: "index.html" },
     {
@@ -1241,7 +1064,7 @@ function ensureDevBuilds() {
     }
   ];
   for (const dep of deps) {
-    if (existsSync5(path10.join(dep.dist, dep.marker))) continue;
+    if (existsSync5(path9.join(dep.dist, dep.marker))) continue;
     note(`building chamba ${dep.label} (first run in this environment)...`);
     const result = spawnSync("pnpm", ["--filter", dep.filter, "build"], {
       cwd: repoRoot,
@@ -1288,41 +1111,76 @@ async function open2(ctx) {
   note(`home: ${ctx.home}  port: ${ctx.port}`);
   const { spawned } = await ensureServer(ctx.client, { home: ctx.home, port: ctx.port });
   if (spawned) note(`started chamba server on :${ctx.port}`);
-  const req = {
-    ...ctx.flags.kind ? { kind: parseKind(ctx.flags.kind) } : {},
-    ...ctx.flags.title ? { title: ctx.flags.title } : {}
-  };
-  const summary = await ctx.client.create(req);
-  const id = summary.meta.id;
-  const digest = await ctx.client.attach(id, 0);
+  const key = agentKey();
   const state = await readState(ctx.home);
-  await writeState(withSession(state, id, digest.cursor), ctx.home);
-  out(`http://localhost:${ctx.port}/?s=${id}`);
+  const existing = await resolveExisting(ctx, key, state);
+  const meta = existing ?? await create(ctx, key);
+  const cursor = state.cursors[meta.id] ?? (existing ? 0 : 1);
+  await writeState(withSession(state, meta.id, cursor, key), ctx.home);
+  out(sessionPageUrl(`http://localhost:${ctx.port}`, meta.id));
   note("  in a container? if this link is unreachable from your host:");
   note(
     `  - the server bound ${resolveBindHost([])}; set CHAMBA_HOST=0.0.0.0 so the host can reach it`
   );
   note(`  - forward port ${ctx.port} to the host (1:1); pin it with CHAMBA_PORT to keep it stable`);
-  note(`session ${id} - open the URL, then run \`chamba poll\` to wait for messages`);
-  if (!ctx.flags.kind) {
+  if (existing) {
+    note(`reconnected to session ${meta.id} - open the URL, then run \`chamba poll\``);
+  } else {
     note(
-      "  no --kind given: the human picks spec or everyday in the browser; your next poll reports it as `\xB7 Session set to ...`"
+      `session ${meta.id} created - open the URL, then run \`chamba poll\` to wait for messages`
     );
   }
   return 0;
 }
-function parseKind(value) {
-  const parsed = sessionKindSchema.safeParse(value);
-  if (!parsed.success) throw new UsageError(`invalid --kind: ${value} (expected everyday or spec)`);
-  return parsed.data;
+async function resolveExisting(ctx, key, state) {
+  if (ctx.flags.new !== void 0) return null;
+  const wantLast = ctx.flags.last !== void 0;
+  if (!wantLast && !key) return null;
+  const active = (await ctx.client.list()).filter((s) => s.meta.status === "active").map((s) => s.meta);
+  if (wantLast) {
+    const found = active[0];
+    if (!found)
+      throw new UsageError("no active session to rebind - run `chamba open` to create one");
+    return found;
+  }
+  const bound = key ? state.bindings[key] : void 0;
+  return active.find((m) => m.id === bound) ?? active.find((m) => m.agentKey === key) ?? null;
+}
+async function create(ctx, key) {
+  const req = {
+    ...ctx.flags.title ? { title: ctx.flags.title } : {},
+    ...key ? { agentKey: key } : {}
+  };
+  const summary = await ctx.client.create(req);
+  return summary.meta;
+}
+
+// packages/cli/src/errors.ts
+function errorCode(err) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [err];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== "object" || seen.has(current)) continue;
+    seen.add(current);
+    const code = current.code;
+    if (typeof code === "string") return code;
+    const cause = current.cause;
+    if (cause) queue.push(cause);
+    const errors = current.errors;
+    if (Array.isArray(errors)) queue.push(...errors);
+  }
+  return void 0;
+}
+function isConnectionRefused(err) {
+  return errorCode(err) === "ECONNREFUSED";
 }
 
 // packages/cli/src/commands/poll.ts
-var DEFAULT_WAIT_MS = 25e3;
-var MAX_WAIT_MS = 3e4;
 var DEFAULT_FOLLOW_MS = 4 * 6e4;
 var BACKOFF_START_MS = 500;
 var BACKOFF_MAX_MS = 5e3;
+var RESPAWN_BUDGET = 3;
 var IDLE_GUARD_MS = 1e3;
 var realClock = {
   now: () => Date.now(),
@@ -1330,28 +1188,48 @@ var realClock = {
 };
 async function poll(ctx, clock = realClock) {
   const id = await resolveSessionId(ctx);
-  const wait = Math.min(intFlag(ctx.flags.wait, DEFAULT_WAIT_MS), MAX_WAIT_MS);
+  const wait = Math.min(intFlag(ctx.flags.wait, POLL_DEFAULT_WAIT_MS), POLL_MAX_WAIT_MS);
   if (ctx.flags.once !== void 0) return pollOnce(ctx, id, wait);
-  const followMs = intFlag(ctx.flags.for, DEFAULT_FOLLOW_MS);
+  const followMs = ctx.flags.for !== void 0 ? intFlag(ctx.flags.for, DEFAULT_FOLLOW_MS) : null;
+  let respawnsLeft = RESPAWN_BUDGET;
   return follow(
     {
       now: clock.now,
       sleep: clock.sleep,
       cursor: async () => cursorFor(await readState(ctx.home), id),
-      poll: (since) => ctx.client.poll(id, since, wait),
+      poll: async (since) => {
+        const res = await ctx.client.poll(id, since, wait);
+        respawnsLeft = RESPAWN_BUDGET;
+        return res;
+      },
       deliver: async (res) => {
         printEvents(res.events, ctx.home);
         await writeState(withSession(await readState(ctx.home), id, res.cursor), ctx.home);
       },
+      recover: async (err) => {
+        if (!isConnectionRefused(err)) return "not-mine";
+        if (!await readServerInfo(ctx.home)) return "server-stopped";
+        if (respawnsLeft <= 0) return "unrecoverable";
+        respawnsLeft -= 1;
+        note("chamba server was down - restarting it");
+        try {
+          await ensureServer(ctx.client, { home: ctx.home, port: ctx.port });
+          return "respawned";
+        } catch (e) {
+          note(`could not restart the server: ${e.message}`);
+          return "unrecoverable";
+        }
+      },
       onError: (err, giveUp) => note(pollErrorMessage(err, giveUp)),
       onHeartbeat: () => note("still listening - re-run chamba poll to keep waiting"),
       onEnded: () => note("session has ended - nothing more to wait for"),
+      onServerStopped: () => note("chamba server stopped - run `chamba open` to continue"),
       isFatal
     },
     // The park floor never drops below the guard sleep, so a small (or zero) `--wait`
     // - which makes the server answer empty at once - cannot spin the loop hot.
     {
-      deadline: clock.now() + followMs,
+      deadline: followMs === null ? null : clock.now() + followMs,
       parkFloorMs: Math.max(IDLE_GUARD_MS, Math.floor(wait / 2))
     }
   );
@@ -1377,7 +1255,24 @@ async function follow(io, cfg) {
     try {
       res = await io.poll(since);
     } catch (err) {
-      const giveUp = io.isFatal(err) || io.now() >= cfg.deadline;
+      if (io.isFatal(err)) {
+        io.onError(err, true);
+        return 1;
+      }
+      const outcome = await io.recover?.(err) ?? "not-mine";
+      if (outcome === "respawned") {
+        backoff = BACKOFF_START_MS;
+        continue;
+      }
+      if (outcome === "server-stopped") {
+        io.onServerStopped?.();
+        return 0;
+      }
+      if (outcome === "unrecoverable") {
+        io.onError(err, true);
+        return 1;
+      }
+      const giveUp = cfg.deadline !== null && io.now() >= cfg.deadline;
       io.onError(err, giveUp);
       if (giveUp) return 1;
       await io.sleep(backoff);
@@ -1393,7 +1288,11 @@ async function follow(io, cfg) {
       io.onEnded?.();
       return 0;
     }
-    if (io.now() >= cfg.deadline) {
+    if (res.stopping) {
+      io.onServerStopped?.();
+      return 0;
+    }
+    if (cfg.deadline !== null && io.now() >= cfg.deadline) {
       io.onHeartbeat();
       return 0;
     }
@@ -1419,8 +1318,9 @@ async function reply(ctx) {
   const text = ctx.positionals.join(" ").trim();
   const files = filePaths(ctx.flags);
   if (!text && files.length === 0) {
-    throw new UsageError("usage: chamba reply <text> [--file a,b] [--image a,b]");
+    throw new UsageError("usage: chamba reply <text> [--to <seq>] [--file a,b] [--image a,b]");
   }
+  const replyTo = replyToSeq(ctx.flags);
   const id = await resolveSessionId(ctx);
   for (const file of files) {
     try {
@@ -1439,15 +1339,54 @@ async function reply(ctx) {
   }
   await ctx.client.reply(id, {
     ...text ? { text } : {},
-    ...attachmentIds.length > 0 ? { attachmentIds } : {}
+    ...attachmentIds.length > 0 ? { attachmentIds } : {},
+    ...replyTo !== void 0 ? { replyTo } : {}
   });
   note(`sent to ${id}`);
   return 0;
 }
+function replyToSeq(flags) {
+  const raw = flags.to;
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (raw === "true" || !Number.isInteger(n) || n < 0) {
+    throw new UsageError("`--to` needs an event seq, e.g. --to 42");
+  }
+  return n;
+}
 function filePaths(flags) {
   return [flags.file, flags.image].filter((value) => typeof value === "string" && value !== "true").flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
 }
 
+// packages/cli/src/commands/show.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import path10 from "node:path";
+async function show(ctx) {
+  const file = ctx.positionals[0];
+  if (!file) throw new UsageError("usage: chamba show <file.html> [--name <name>]");
+  if (!/\.html?$/i.test(file)) {
+    throw new UsageError(`chamba show takes a self-contained HTML file, got: ${file}`);
+  }
+  let content;
+  try {
+    content = await readFile6(file, "utf8");
+  } catch (err) {
+    throw new UsageError(`could not read ${file}: ${err.message}`);
+  }
+  const flagName = ctx.flags.name?.trim();
+  const name = flagName && flagName !== "true" ? flagName : path10.basename(file).replace(/\.html?$/i, "");
+  const result = postPageReqSchema.safeParse({ name, content });
+  if (!result.success) {
+    throw new UsageError(`invalid page: ${result.error.issues.map((i) => i.message).join("; ")}`);
+  }
+  const id = await resolveSessionId(ctx);
+  const event = await ctx.client.showPage(id, result.data);
+  const ref = pageRefSchema.safeParse(event.payload?.page);
+  const shownAs = ref.success ? ref.data.name : name;
+  note(`showing "${shownAs}" in session ${id}${ref.success ? ` (${ref.data.relPath})` : ""}`);
+  return 0;
+}
+
 // packages/cli/src/commands/skill.ts
 import { cpSync, existsSync as existsSync6, rmSync } from "node:fs";
 import { homedir } from "node:os";
@@ -1490,7 +1429,7 @@ async function status(ctx) {
     return 0;
   }
   const state = await readState(ctx.home);
-  const up = await serverOwnsHome(ctx);
+  const up = await ctx.client.ownsHome(ctx.home);
   const rows = up ? await rowsFromServer(ctx) : await rowsFromDisk(ctx);
   note(`home: ${ctx.home}`);
   if (rows.length === 0) {
@@ -1503,14 +1442,6 @@ async function status(ctx) {
   }
   return 0;
 }
-async function serverOwnsHome(ctx) {
-  if (!await ctx.client.isUp()) return false;
-  try {
-    return (await ctx.client.health()).home === ctx.home;
-  } catch {
-    return false;
-  }
-}
 async function rowsFromServer(ctx) {
   const summaries = await ctx.client.list();
   return summaries.map((s) => ({ meta: s.meta, presence: s.presence }));
@@ -1529,7 +1460,7 @@ async function stop(ctx) {
     return 0;
   }
   const client = new Client(`http://127.0.0.1:${info.port}/`);
-  if (!await ownsHome(client, ctx.home)) {
+  if (!await client.ownsHome(ctx.home)) {
     note("no chamba server running here");
     return 0;
   }
@@ -1546,25 +1477,14 @@ async function stop(ctx) {
   note(`sent stop to the chamba server (pid ${info.pid}) but it did not exit in time`);
   return 1;
 }
-async function ownsHome(client, home) {
-  if (!await client.isUp()) return false;
-  try {
-    return (await client.health()).home === home;
-  } catch {
-    return false;
-  }
-}
 async function waitUntilDown(client, timeoutMs = 5e3) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (!await client.isUp()) return true;
-    await delay2(150);
+    await delay(150);
   }
   return false;
 }
-function delay2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 
 // packages/cli/src/commands/index.ts
 var COMMANDS = {
@@ -1572,15 +1492,11 @@ var COMMANDS = {
   open: open2,
   poll,
   reply,
+  get,
+  show,
   end,
-  attach,
   status,
   stop,
-  // Spec sessions: structured interview + live artifacts + export.
-  ask,
-  decision,
-  artifact,
-  export: exportCmd,
   // Distribution: install the bundled skill into a Claude skills directory.
   skill,
   help,
@@ -1596,16 +1512,7 @@ function runCommand(name, ctx) {
 }
 
 // packages/cli/src/index.ts
-var REQUIRES_WORKSPACE = /* @__PURE__ */ new Set([
-  "poll",
-  "reply",
-  "end",
-  "attach",
-  "ask",
-  "decision",
-  "artifact",
-  "export"
-]);
+var REQUIRES_WORKSPACE = /* @__PURE__ */ new Set(["poll", "reply", "get", "show", "end"]);
 async function main(argv = process.argv.slice(2)) {
   const { positionals, flags } = parseArgs(argv);
   if (flags.version && positionals.length === 0) {
@@ -1645,29 +1552,13 @@ function reportError(err) {
     note(`error: ${err.message}`);
     return 1;
   }
-  if (errorCode(err) === "ECONNREFUSED") {
+  if (isConnectionRefused(err)) {
     note("cannot reach the chamba server - run `chamba open` first");
     return 1;
   }
   note(`error: ${err.message}`);
   return 1;
 }
-function errorCode(err) {
-  const seen = /* @__PURE__ */ new Set();
-  const queue = [err];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || typeof current !== "object" || seen.has(current)) continue;
-    seen.add(current);
-    const code = current.code;
-    if (typeof code === "string") return code;
-    const cause = current.cause;
-    if (cause) queue.push(cause);
-    const errors = current.errors;
-    if (Array.isArray(errors)) queue.push(...errors);
-  }
-  return void 0;
-}
 function invokedAsEntry() {
   const entry = process.argv[1];
   if (entry === void 0) return false;