chatroom-cli 1.94.2 → 1.96.0

package/dist/index.js

@@ -78205,6 +78205,7 @@ var init_participant = __esm(() => {
   ONLINE_OR_STARTING_STATUSES = new Set([
     "agent.waiting",
     "agent.requestStart",
+    "agent.restart",
     "agent.started",
     "task.acknowledged",
     "task.inProgress",
@@ -79042,90 +79043,54 @@ var init_builder_to_planner = __esm(() => {
   init_role_guidance_disclosure();
 });
 
+// ../../services/backend/prompts/enhancer/defragmentation-reference.ts
+function renderDefragmentationHandoffReference() {
+  return [
+    "### Defragmentation workflow checklist",
+    'Complete the optional **Defragmentation** section when the planner check-in addresses a large or multi-surface system revision, including refactoring, consolidation, or consistency work. Write exactly "Not Applicable." only when no such revision is proposed.',
+    "",
+    "1. **Study surfaces** — map all call sites, use cases, and complexity variants before proposing slices; name every relevant file/module",
+    "2. **Golden implementation** — build a standalone canonical solution first; introduce canonical domain entities/types only when the studied variants require them, then shared use cases, UI components, or utilities; do not patch duplicates in place",
+    "3. **Migrate callers** — refactor all consumers to the golden path; each slice must be shippable end-to-end",
+    "4. **Delete legacy** — remove old implementations only after migration is complete; no dead-code leftovers",
+    "",
+    "### Anti-patterns to flag",
+    "- Incremental copy-paste fixes across N files without a golden SSOT",
+    "- New abstraction without studying all existing variants",
+    '- Leaving old code "for safety" after migration',
+    "- Slices that add helpers/infra without a runnable end-to-end outcome",
+    "- Parallel implementations coexisting without a deletion plan",
+    "",
+    "### Structural decisions",
+    "- Identify SSOT locations for domain entities, shared use cases, and UI components",
+    "- Align with `structural-decisions` glossary: folder structure, file naming, interface locations",
+    "- Flag when the plan scatters the canonical implementation across unrelated modules"
+  ].join(`
+`);
+}
+
 // ../../services/backend/prompts/enhancer/webapp-ux-reference.ts
 function renderWebappUxHandoffReference() {
   return [
     "### UX review checklist",
     'Complete the optional **UX** section in your output when the planner proposes UI changes. Write exactly "Not Applicable." for non-UI tasks. Put code snippets in **Suggested edits** only.',
     "",
-    "1. **Flows** — primary action ≤3 clicks? simpler path exists?",
-    "2. **Patterns** — matches existing components? recommend one if multiple. mobile vs desktop (responsive variants vs separate mobile UI)?",
-    "3. **Layout** — compact title+menu row, description, trailing end-aligned CTA? unnecessary wrappers?",
-    "4. **Shortcuts** — consistent with project conventions? gaps or conflicts?",
-    "5. **States** — loading spinners/skeletons for async data? error messages on failure? empty states?",
-    "6. **Error boundaries** — risky subtrees wrapped so a throw does not crash the whole app? failure isolated from the shell?",
-    "7. **Alignment** — traced parent layout before leaf styles? position/height match siblings?",
-    '8. **Feedback** — immediate pending state on async actions (e.g. save → button "Saving...")?',
-    "9. **Destructive actions** — confirmation dialog before delete/remove/archive/reset/clear or other irreversible/high-impact single actions?",
-    "10. **Bulk actions** — confirmation before batch/multi-item operations (with count or impact summary)?",
-    "",
-    "### Flow complexity",
-    "- Primary action ≤3 clicks from entry point",
-    "- Extend existing surfaces (palette, settings tab, row action) before new navigation",
-    "- Avoid nested modal chains and unjustified multi-step wizards",
-    "- Prefer inline actions over navigate-away-and-back",
+    "1. **Flows** — is the primary path straightforward? simpler alternatives exist?",
+    "2. **Patterns** — consistent with existing project components and conventions? recommend one when multiple exist.",
+    "3. **Layout** — unnecessary complexity or wrappers? layout stable across loading/empty/error transitions (no layout shift when async content arrives or state changes)?",
+    "4. **Shortcuts** — aligned with the project keyboard/shortcut conventions? gaps or conflicts?",
+    "5. **States** — loading, error, and empty states explicitly handled for async surfaces (no blank panels, silent failures, or missing retry affordances)?",
+    "6. **Error boundaries** — failures scoped so one subtree does not crash the whole app?",
+    "7. **Feedback** — timely response for async user actions?",
+    "8. **Interaction affordance** — clickable/interactive elements use pointer cursor (or the project's established equivalent) where applicable?",
+    "9. **Destructive actions** — irreversible or high-impact single actions gated by confirmation?",
+    "10. **Bulk actions** — batch/multi-item operations confirmed with scope or impact summary?",
     "",
-    "### Presentation & responsive patterns",
-    "- Reuse existing design-system components and established UI patterns before introducing new abstractions",
-    "- Match badge/button styling from similar surfaces in the app",
-    "- When multiple valid patterns exist, recommend one and explain tradeoff",
-    "- Use the project's standard breakpoint(s) for mobile vs desktop",
-    "- **Hide/show:** responsive utility classes or equivalent for alternate chrome per viewport",
-    "- **Mobile overlay:** full-screen or sheet overlay with backdrop when desktop uses persistent panels",
-    "- **Separate mobile UI:** dedicated mobile modal/picker when desktop uses side panel or split view",
-    "- **Shared responsive density:** same component with size/density variants per breakpoint",
-    "- **Command/search dialogs:** match existing modal/dialog styling; sensible max-width on small screens",
-    "",
-    "### Layout simplification",
-    "- Review card/section layouts for unnecessary rows, nested wrappers, or misaligned actions",
-    "- Prefer compact rows: title and overflow menu on one line via flex/grid",
-    "- Description on the next line; primary CTA on a trailing row aligned end",
-    "- Canonical simplified card pattern:",
-    "  ```",
-    "  <title>          <overflow-menu>",
-    "  <description>",
-    "                   <primary-cta aligned end>",
-    "  ```",
-    "- Use header + action grid or equivalent flex `justify-between`",
-    "- Flag multi-row chrome that could collapse (menu on its own row, CTA misaligned vs similar cards)",
-    "",
-    "### Error & loading states",
-    "- Initial fetch: centered loader or skeleton for the content area",
-    "- Pagination/infinite scroll: inline loader at scroll edge",
-    "- Save/submit mutations: inline success/error feedback beside the trigger control",
-    "- Never leave blank panels on fetch failure — show error message or retry affordance",
-    "- Disable interactive controls while loading or pending",
-    "",
-    "### Error boundaries",
-    "- Wrap data-dependent or third-party subtrees with error boundaries so a single failure does not unmount the whole app",
-    "- Scope boundaries to the failing panel/section, not the entire shell",
-    "- Provide fallback UI with a recovery action (retry, reload, or navigate away)",
-    "",
-    "### Alignment & component hierarchy",
-    "- Before styling a leaf component, trace parent flex/grid context",
-    "- Match sibling heights and vertical rhythm",
-    "- Flag absolute positioning or fixed heights that fight parent layout",
-    "- When hierarchy is unclear, inspect the rendered component tree (e.g. DOM inspector or component test snapshot) before deciding leaf styles",
-    "",
-    "### Fast user feedback",
-    "- Async actions triggered by keyboard shortcut or click must show **immediate** UI response",
-    '- Canonical pattern: pending local state → button label changes (e.g. "Saving..."), control disabled while in flight',
-    "- Show inline error on failure; brief success confirmation optional",
-    "- Pair shortcut hints with pending state only when the action shows pending feedback",
-    "",
-    "### Destructive & bulk action safeguards",
-    "- **Destructive actions** (delete, remove, archive, reset, clear, disable) require an explicit confirmation step — never fire immediately from a menu item or button without a dialog",
-    "- Use the project's standard confirmation dialog/modal pattern",
-    "- Confirmation includes clear title + description of what will happen; primary action styled as destructive when appropriate",
-    "- **Bulk actions** (multi-select delete, batch disable, clear-all) require confirmation before execution — show how many items are affected",
-    '- Bulk confirm should summarize scope (e.g. "Delete 12 items?") and list material impact when non-obvious',
-    "- Flag plans that wire bulk/destructive handlers directly to mutations/API calls without a confirm gate",
-    "",
-    "### Keyboard shortcuts",
-    "- Align proposed shortcuts with the project's existing shortcut catalog and platform conventions (⌘ on macOS, Ctrl on Windows/Linux)",
-    "- Avoid conflicting bindings; document new shortcuts when introducing them",
-    "- Common patterns: modifier+letter for global commands, Enter to confirm in dialogs, Escape to cancel/close, Shift+Enter for multiline input where applicable",
-    "- Flag plans that add shortcuts without checking for conflicts or omit keyboard access for primary actions"
+    "### Review principles",
+    "- Ground feedback in the planner check-in and the project codebase — cite existing patterns rather than inventing generic UI preferences.",
+    "- Flag missing states, layout-shift risk, and missing interaction affordances when the plan omits them; recommend consistency with established project conventions.",
+    "- Do **not** prescribe style choices the project has not adopted (e.g. specific flex layouts, canonical card chrome, responsive utility patterns, button label copy).",
+    "- When multiple valid patterns exist in the codebase, recommend one and explain the tradeoff."
   ].join(`
 `);
 }
@@ -79140,7 +79105,7 @@ function getEnhancerFeedbackTemplateBody() {
 <specific misreadings or missing constraints — what the user asked vs what the planner proposed>
 </handoff-overview>
 
-<!-- UI collapses proofs, direction, ux, and notes by default; overview and action required are expanded -->
+<!-- UI collapses proofs, direction, ux, defragmentation, and notes by default; overview and action required are expanded -->
 
 <handoff-proofs>
 ## Reasoning review
@@ -79155,18 +79120,32 @@ function getEnhancerFeedbackTemplateBody() {
 <handoff-ux>
 <!-- Optional — write exactly "Not Applicable." when no UI changes are proposed -->
 <!-- When UI is proposed: specific findings tied to the planner's proposal. No code blocks (use Suggested edits). -->
-- **Flows:** <specific finding — click count, nested modals, simpler alternatives>
-- **Patterns:** <which existing pattern fits; recommend one if multiple; mobile vs desktop>
-- **Layout:** <compact rows, trailing CTAs, unnecessary wrappers>
+- **Flows:** <click count, nested modals, simpler alternatives>
+- **Patterns:** <consistency with existing project components; recommend one when multiple>
+- **Layout:** <complexity, wrappers, layout stable across state transitions — no layout shift>
 - **Shortcuts:** <alignment with catalog; gaps or conflicts>
-- **States:** <loading/error/empty coverage for async surfaces>
+- **States:** <loading/error/empty explicitly handled; no blank panels or silent failures>
 - **Error boundaries:** <error boundary placement; failure isolated from the whole app>
-- **Alignment:** <hierarchy traced; position/height issues; inline snapshot consideration>
-- **Feedback:** <immediate pending state on async actions; ⌘Enter + button state>
-- **Destructive safeguards:** <single-item irreversible/high-impact actions gated by confirm dialog; cite missing confirms>
-- **Bulk safeguards:** <batch/multi-item operations gated by confirm with count/impact summary; cite missing confirms>
+- **Feedback:** <timely response for async actions>
+- **Interaction affordance:** <pointer cursor or project equivalent on clickable elements where applicable>
+- **Destructive safeguards:** <confirmation before irreversible/high-impact actions>
+- **Bulk safeguards:** <confirmation with scope summary for batch operations>
 </handoff-ux>
 
+<handoff-defragmentation>
+<!-- Optional — write exactly "Not Applicable." when no large or multi-surface system revision is proposed -->
+<!-- When revision work is proposed: specific findings tied to the planner's proposal. No code blocks (use Suggested edits). -->
+- **Surfaces:** <call sites and modules identified; gaps in surface mapping>
+- **Golden path:** <whether planner builds standalone canonical implementation first>
+- **Domain model:** <canonical types/entities needed or "not needed">
+- **Shared components:** <shared abstractions planned (use cases, UI, utilities)>
+- **Slice ordering:** <study → golden → migrate → delete sequence respected?>
+- **Migration plan:** <how all callers move to golden path>
+- **Deletion plan:** <old implementations slated for removal>
+- **Duplication:** <existing duplicates to eliminate; risk of new duplication>
+- **Structural decisions:** <folder/module boundaries; SSOT locations>
+</handoff-defragmentation>
+
 <handoff-notes>
 ## Knowledge gaps
 <specific facts, files, or research to verify — name what to check and why>
@@ -79205,10 +79184,12 @@ ${getHandoffReportTemplateIntro("Planning Feedback (Enhancer → Planner)")}
 
 The planner sent you three XML sections. Your job is **advisory adversarial review** — raise risks, challenge assumptions, align with user intent. Be **specific and targeted**: cite concrete claims, files, UX choices, and gaps from the check-in so the planner can improve the plan without re-synthesizing vague feedback.
 
-Give **concrete, actionable recommendations** in every section. End with **Recommendations** (second-last: summarized suggestions, tradeoffs, and considerations) then **Suggested edits** (last: proposed edits to grounding and the builder-handoff with file paths and code snippets). For UI work, complete the optional **UX** section using the reference below. **Do not rewrite their full builder brief.** The planner makes the final call.
+Give **concrete, actionable recommendations** in every section. End with **Recommendations** (second-last: summarized suggestions, tradeoffs, and considerations) then **Suggested edits** (last: proposed edits to grounding and the builder-handoff with file paths and code snippets). For UI work, complete the optional **UX** section using the reference below. For large or multi-surface revision work, complete the optional **Defragmentation** section using its reference below. **Do not rewrite their full builder brief.** The planner makes the final call.
 
 ${renderWebappUxHandoffReference()}
 
+${renderDefragmentationHandoffReference()}
+
 \`\`\`markdown
 ${getEnhancerFeedbackTemplateBody()}
 \`\`\`
@@ -80254,6 +80235,24 @@ var init_generator = __esm(() => {
   init_review_guidelines();
 });
 
+// src/infrastructure/deps/create-convex-command-deps.ts
+async function createConvexCommandDeps() {
+  const client4 = await getConvexClient();
+  const backend2 = {
+    mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
+    query: (endpoint, args2) => client4.query(endpoint, args2)
+  };
+  const session2 = { getSessionId, getConvexUrl, getOtherSessionUrls };
+  return {
+    backend: backend2,
+    session: session2
+  };
+}
+var init_create_convex_command_deps = __esm(() => {
+  init_storage();
+  init_client2();
+});
+
 // src/commands/handoff/index.ts
 var exports_handoff = {};
 __export(exports_handoff, {
@@ -80261,18 +80260,7 @@ __export(exports_handoff, {
   handoff: () => handoff
 });
 async function createDefaultDeps10() {
-  const client4 = await getConvexClient();
-  return {
-    backend: {
-      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
-      query: (endpoint, args2) => client4.query(endpoint, args2)
-    },
-    session: {
-      getSessionId,
-      getConvexUrl,
-      getOtherSessionUrls
-    }
-  };
+  return createConvexCommandDeps();
 }
 function handleHandoffError(err) {
   return exports_Effect.sync(() => {
@@ -80389,8 +80377,7 @@ var init_handoff = __esm(() => {
   init_values();
   init_esm();
   init_api3();
-  init_storage();
-  init_client2();
+  init_create_convex_command_deps();
   init_services();
   init_error_formatting();
 });
@@ -81687,18 +81674,7 @@ __export(exports_skill, {
   activateSkill: () => activateSkill
 });
 async function createDefaultDeps15() {
-  const client4 = await getConvexClient();
-  return {
-    backend: {
-      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
-      query: (endpoint, args2) => client4.query(endpoint, args2)
-    },
-    session: {
-      getSessionId,
-      getConvexUrl,
-      getOtherSessionUrls
-    }
-  };
+  return createConvexCommandDeps();
 }
 function handleListSkillsError(err) {
   return exports_Effect.sync(() => {
@@ -81824,8 +81800,7 @@ var listSkillsEffect = (chatroomId, _options) => exports_Effect.gen(function* ()
 var init_skill = __esm(() => {
   init_esm();
   init_api3();
-  init_storage();
-  init_client2();
+  init_create_convex_command_deps();
   init_services();
   init_convex_error();
 });
@@ -81883,6 +81858,111 @@ var init_send = __esm(() => {
   init_client2();
 });
 
+// ../../services/backend/src/domain/usecase/message/serialize-message.ts
+function attachmentContext(options) {
+  return { chatroomId: options.chatroomId ?? "", role: options.role ?? "" };
+}
+function serializeLinearMessage(message, options) {
+  const target = message.targetRole ? ` → ${message.targetRole}` : "";
+  const attachments = message.attachments ? renderDeliveryAttachmentsBlock(message.attachments, attachmentContext(options)).join(`
+`) : "";
+  return `${new Date(message._creationTime).toISOString()} | ${message.senderRole}${target}
+${attachments ? `${attachments}
+` : ""}
+${message.content}`;
+}
+function serializeTaskOriginMessage(message) {
+  return `<message sender="${escapeXmlAttribute(message.senderRole)}" message-id="${escapeXmlAttribute(message._id)}">
+<message-content>
+${escapeXmlText(message.content)}
+</message-content>
+</message>`;
+}
+function serializeContextXmlMessage(message, options) {
+  const indent = options.indent ?? "   ";
+  const attrs = contextMessageAttributes(message);
+  const task = contextTaskBlock(message, indent);
+  const attachmentLines = contextAttachmentLines(message, options, indent);
+  return [
+    `<message ${attrs}>`,
+    task,
+    ...attachmentLines,
+    `${indent}Content:`,
+    `${indent}<message-content>`,
+    `${indent}${indent}${escapeXmlText(message.content)}`,
+    `${indent}</message-content>`,
+    `</message>`
+  ].filter(Boolean).join(`
+`);
+}
+function contextMessageAttributes(message) {
+  const target = message.targetRole ? ` to="${escapeXmlAttribute(message.targetRole)}"` : "";
+  return `id="${escapeXmlAttribute(message._id)}" from="${escapeXmlAttribute(message.senderRole)}"${target} type="${escapeXmlAttribute(message.type)}"`;
+}
+function contextTaskBlock(message, indent) {
+  if (!message.task)
+    return "";
+  return `
+${indent}<task id="${escapeXmlAttribute(message.task._id)}" status="${escapeXmlAttribute(message.task.status)}">
+${indent}${indent}${escapeXmlText(message.task.content)}
+${indent}</task>`;
+}
+function contextAttachmentLines(message, options, indent) {
+  if (!message.attachments)
+    return [];
+  return renderDeliveryAttachmentsBlock(message.attachments, attachmentContext(options)).map((line) => line ? indent + line : "");
+}
+function serializeMessage(message, options) {
+  switch (options.profile) {
+    case "linear":
+      return serializeLinearMessage(message, options);
+    case "task-origin":
+      return serializeTaskOriginMessage(message);
+    case "context-xml":
+      return serializeContextXmlMessage(message, options);
+  }
+}
+var init_serialize_message = __esm(() => {
+  init_render_delivery_attachments();
+});
+
+// ../../services/backend/src/domain/usecase/message/to-serializable-message.ts
+function normalizeDeliveryAttachments(input) {
+  const attachments = {
+    attachedTasks: input.attachedTasks?.map((item) => ({
+      _id: item._id,
+      content: item.content,
+      status: item.status ?? item.backlogStatus ?? ""
+    })),
+    attachedBacklogItems: input.attachedBacklogItems?.map((item) => ({
+      _id: item._id ?? item.id ?? "",
+      content: item.content,
+      status: item.status
+    })),
+    attachedMessages: input.attachedMessages,
+    attachedSnippets: input.attachedSnippets
+  };
+  return Object.values(attachments).some((items) => items && items.length > 0) ? attachments : undefined;
+}
+function normalizeTask(input) {
+  if (!input.taskId || input.taskStatus == null || input.taskContent == null)
+    return;
+  return { _id: input.taskId, status: input.taskStatus, content: input.taskContent };
+}
+function toSerializableMessage(input) {
+  const attachments = normalizeDeliveryAttachments(input);
+  return {
+    _id: input._id,
+    _creationTime: input._creationTime,
+    senderRole: input.senderRole,
+    targetRole: input.targetRole,
+    type: input.type,
+    content: input.content,
+    ...attachments ? { attachments } : {},
+    ...normalizeTask(input) ? { task: normalizeTask(input) } : {}
+  };
+}
+
 // src/commands/messages/messages-fs-service.ts
 import * as nodeFs2 from "node:fs/promises";
 function messageFilename(msg) {
@@ -81890,13 +81970,6 @@ function messageFilename(msg) {
   const receiver = msg.targetRole ?? "all";
   return `${sortPrefix}_${msg.senderRole}-to-${receiver}_${msg._id}.md`;
 }
-function buildLinearMessageContent(msg) {
-  const ts = new Date(msg._creationTime).toISOString();
-  const receiver = msg.targetRole ? ` → ${msg.targetRole}` : "";
-  return `${ts} | ${msg.senderRole}${receiver}
-
-${msg.content}`;
-}
 var MessagesFsService, MessagesFsServiceLive, SORT_KEY_MAX = 9999999999999;
 var init_messages_fs_service = __esm(() => {
   init_esm();
@@ -82073,7 +82146,11 @@ var PAGE_SIZE = 50, SINCE_PAGE_SIZE = 500, ABSOLUTE_MAX = 5000, DEFAULT_LIMIT =
   const manifestEntries = [];
   for (const msg of messages) {
     const file = messageFilename(msg);
-    const content = buildLinearMessageContent(msg);
+    const content = serializeMessage(toSerializableMessage(msg), {
+      profile: "linear",
+      chatroomId,
+      role: options.role
+    });
     const filePath = nodePath2.join(outputDir, file);
     yield* fs11.writeFile(filePath, content).pipe(exports_Effect.mapError((cause3) => ({
       _tag: "WriteFailed",
@@ -82131,6 +82208,7 @@ var PAGE_SIZE = 50, SINCE_PAGE_SIZE = 500, ABSOLUTE_MAX = 5000, DEFAULT_LIMIT =
   });
 });
 var init_download = __esm(() => {
+  init_serialize_message();
   init_esm();
   init_messages_fs_service();
   init_api3();
@@ -82442,18 +82520,19 @@ __export(exports_context2, {
   inspectContext: () => inspectContext
 });
 async function createDefaultDeps18() {
-  const client4 = await getConvexClient();
-  return {
-    backend: {
-      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
-      query: (endpoint, args2) => client4.query(endpoint, args2)
-    },
-    session: {
-      getSessionId,
-      getConvexUrl,
-      getOtherSessionUrls
-    }
-  };
+  return createConvexCommandDeps();
+}
+function requireAuthenticatedChatroom(chatroomId) {
+  return exports_Effect.gen(function* () {
+    const sessionId = yield* requireSessionIdEffect(() => ({
+      _tag: "NotAuthenticated"
+    }));
+    yield* validateChatroomIdEffect(chatroomId, (id3) => ({
+      _tag: "InvalidChatroomId",
+      id: id3
+    }));
+    return sessionId;
+  });
 }
 function handleContextError(err) {
   return exports_Effect.sync(() => {
@@ -82506,13 +82585,7 @@ async function inspectContext(chatroomId, options, deps) {
 }
 var readContextEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect(() => ({
-    _tag: "NotAuthenticated"
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireAuthenticatedChatroom(chatroomId);
   const context5 = yield* backend2.query(api.messages.getContextForRole, {
     sessionId,
     chatroomId,
@@ -82559,47 +82632,12 @@ var readContextEffect = (chatroomId, options) => exports_Effect.gen(function* ()
 \uD83D\uDCAC Chat History:`);
     console.log("─".repeat(60));
     for (const message of context5.messages) {
-      const toAttr = message.targetRole ? ` to="${message.targetRole}"` : "";
-      console.log(`<message id="${message._id}" from="${message.senderRole}"${toAttr} type="${message.type}">`);
-      if (message.taskId) {
-        console.log(`   Task:`);
-        console.log(`      ID: ${message.taskId}`);
-        if (message.taskStatus) {
-          console.log(`      Status: ${message.taskStatus}`);
-        }
-        if (message.taskContent) {
-          const safeTaskContent = sanitizeForTerminal(message.taskContent);
-          console.log(`      Content:`);
-          console.log(`      <task-content>`);
-          console.log(safeTaskContent.split(`
-`).map((l) => `      ${l}`).join(`
-`));
-          console.log(`      </task-content>`);
-        }
-      }
-      if (message.attachedTasks && message.attachedTasks.length > 0) {
-        console.log(`   Attachments:`);
-        for (const task of message.attachedTasks) {
-          console.log(`      \uD83D\uDD39 Task ID: ${task._id}`);
-          console.log(`         Type: Task`);
-          const contentLines = sanitizeForTerminal(task.content).split(`
-`);
-          console.log(`         Content:`);
-          console.log(`         <task-content>`);
-          for (const line of contentLines) {
-            console.log(`         ${line}`);
-          }
-          console.log(`         </task-content>`);
-        }
-      }
-      console.log(`   Content:`);
-      console.log(`   <message-content>`);
-      const safeMessageContent = sanitizeForTerminal(message.content);
-      console.log(safeMessageContent.split(`
-`).map((l) => `      ${l}`).join(`
-`));
-      console.log(`   </message-content>`);
-      console.log(`</message>`);
+      const serialized = serializeMessage(toSerializableMessage(message), {
+        profile: "context-xml",
+        chatroomId,
+        role: options.role
+      });
+      console.log(sanitizeForTerminal(serialized));
     }
     console.log(`
 ` + "═".repeat(60));
@@ -82607,13 +82645,7 @@ var readContextEffect = (chatroomId, options) => exports_Effect.gen(function* ()
   });
 }), newContextEffect = (chatroomId, options) => exports_Effect.gen(function* () {
   const backend2 = yield* BackendService;
-  const sessionId = yield* requireSessionIdEffect(() => ({
-    _tag: "NotAuthenticated"
-  }));
-  yield* validateChatroomIdEffect(chatroomId, (id3) => ({
-    _tag: "InvalidChatroomId",
-    id: id3
-  }));
+  const sessionId = yield* requireAuthenticatedChatroom(chatroomId);
   if (!options.content || options.content.trim().length === 0) {
     return yield* exports_Effect.fail({ _tag: "EmptyContent" });
   }
@@ -82724,11 +82756,11 @@ var readContextEffect = (chatroomId, options) => exports_Effect.gen(function* ()
   });
 });
 var init_context2 = __esm(() => {
+  init_serialize_message();
   init_esm();
   init_format_new_context_error();
   init_api3();
-  init_storage();
-  init_client2();
+  init_create_convex_command_deps();
   init_services();
 });
 
@@ -82857,18 +82889,7 @@ __export(exports_artifact, {
   createArtifact: () => createArtifact
 });
 async function createDefaultDeps20() {
-  const client4 = await getConvexClient();
-  return {
-    backend: {
-      mutation: (endpoint, args2) => client4.mutation(endpoint, args2),
-      query: (endpoint, args2) => client4.query(endpoint, args2)
-    },
-    session: {
-      getSessionId,
-      getConvexUrl,
-      getOtherSessionUrls
-    }
-  };
+  return createConvexCommandDeps();
 }
 function handleArtifactError(err) {
   return exports_Effect.sync(() => {
@@ -83019,8 +83040,7 @@ var createArtifactEffect = (chatroomId, options) => exports_Effect.gen(function*
 var init_artifact = __esm(() => {
   init_esm();
   init_api3();
-  init_storage();
-  init_client2();
+  init_create_convex_command_deps();
   init_services();
   init_file_content();
   artifactErrorHandlers = {
@@ -98511,9 +98531,11 @@ function parseAssignedTaskSignal(raw) {
   return assignedTaskSignalSchema.parse(raw);
 }
 function parseAssignedTaskPresenceSignal(raw) {
+  const full = assignedTaskPresenceSignalSchema.safeParse(raw);
+  if (full.success)
+    return full.data;
   const delta = assignedTaskPresenceDeltaSchema.safeParse(raw);
-  const hasFullWireFields = typeof raw === "object" && raw !== null && "chatroomId" in raw && "presenceUpdatedAt" in raw;
-  if (delta.success && !hasFullWireFields) {
+  if (delta.success) {
     const presenceUpdatedAt = Number(delta.data.presenceKey.split(":")[0]);
     const resolvedAt = Number.isFinite(presenceUpdatedAt) ? presenceUpdatedAt : 0;
     return {
@@ -99436,11 +99458,13 @@ async function runRestartOrchestrator(deps, event) {
   markRestartOrchestratorInFlight(chatroomId, role, event.correlationId);
   try {
     resetRoleDeliveryState(chatroomId, role);
+    await emitPhase(deps, event, "reset");
     await deps.agentMgr.stop({
       chatroomId,
       role,
       reason: "user.restart"
     });
+    await emitPhase(deps, event, "spawn");
     const spawnResult = await exports_Effect.runPromise(deps.agentMgr.ensureRunning({
       chatroomId,
       role,
@@ -99454,13 +99478,17 @@ async function runRestartOrchestrator(deps, event) {
       await emitPhase(deps, event, "failed", spawnResult.error ?? "spawn failed");
       return;
     }
+    await emitPhase(deps, event, "await_session");
     const harnessSessionId = await waitForHarnessSessionId(deps, event, spawnResult.pid);
     if (!harnessSessionId) {
       await emitPhase(deps, event, "failed", "harnessSessionId timeout");
       return;
     }
     await forceNativeWaiting(deps, event);
+    await emitPhase(deps, event, "ready");
+    await emitPhase(deps, event, "deliver");
     const deliveredTaskIds = await deliverPendingTasks(deps, event);
+    await emitPhase(deps, event, "completed");
     await deps.session.backend.mutation(api.machines.emitRestartCompleted, {
       sessionId: deps.session.sessionId,
       machineId: deps.session.machineId,
@@ -127310,13 +127338,13 @@ import { dirname as dirname15, join as join27 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function clientDistCandidates(here) {
   return [
+    join27(here, "client/build"),
     join27(here, "../client/build"),
-    join27(here, "../src/daemon/local-web/client/build"),
-    join27(here, "../../../src/daemon/local-web/client/build")
+    join27(here, "../src/daemon/local-web/client/build")
   ];
 }
-function resolveClientDistDir() {
-  const candidates = clientDistCandidates(dirname15(fileURLToPath7(import.meta.url)));
+function resolveClientDistDir(here = dirname15(fileURLToPath7(import.meta.url))) {
+  const candidates = clientDistCandidates(here);
   for (const dir of candidates) {
     if (existsSync9(join27(dir, "index.html")))
       return dir;
@@ -127598,7 +127626,7 @@ async function startLocalWebServer(config4, deps = {}) {
     throw new Error(`local-web must bind to 127.0.0.1 only (got ${config4.host})`);
   }
   const streamHub = deps.streamHub ?? createStreamHub();
-  const clientDistDir = resolveClientDistDir();
+  const clientDistDir = deps.clientDistDir ?? resolveClientDistDir();
   const server2 = createServer((req, res) => {
     if (tryServeStatic(req, res, clientDistDir))
       return;
@@ -127633,8 +127661,14 @@ async function startLocalWebServer(config4, deps = {}) {
     streamHub,
     stop() {
       return new Promise((resolve8, reject) => {
-        io2.close();
-        server2.close((err) => err ? reject(err) : resolve8());
+        io2.close((err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve8();
+        });
+        server2.closeAllConnections();
       });
     }
   };
@@ -128935,4 +128969,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=70FFCDEB51C1508364756E2164756E21
+//# debugId=2445D97C1319365564756E2164756E21