@schoolai/shipyard-mcp 0.3.2-next.523 → 0.3.2-next.527

package/apps/server/dist/{chunk-NNJ3ELQW.js → chunk-QDYV6R7L.js}

@@ -1,7 +1,19 @@
 import {
   __commonJS,
-  __toESM
-} from "./chunk-JSBRDJBE.js";
+  __toESM,
+  assertNever,
+  getSessionIdByPlanId,
+  getSessionState,
+  getSessionStateByPlanId,
+  isSessionStateApproved,
+  isSessionStateApprovedAwaitingToken,
+  isSessionStateReviewed,
+  isSessionStateSynced,
+  loadEnv,
+  logger,
+  setSessionState,
+  startPeriodicCleanup
+} from "./chunk-HFZCBGQ3.js";
 
 // ../../node_modules/.pnpm/lz-string@1.5.0/node_modules/lz-string/libs/lz-string.js
 var require_lz_string = __commonJS({
@@ -306,7 +318,7 @@ var require_lz_string = __commonJS({
             return compressed.charCodeAt(index);
           });
         },
-        _decompress: function(length, resetValue, getNextValue) {
+        _decompress: function(length2, resetValue, getNextValue) {
           var dictionary = [], next, enlargeIn = 4, dictSize = 4, numBits = 3, entry = "", result = [], i, w, bits, resb, maxpower, power, c, data = { val: getNextValue(0), position: resetValue, index: 1 };
           for (i = 0; i < 3; i += 1) {
             dictionary[i] = i;
@@ -364,7 +376,7 @@ var require_lz_string = __commonJS({
           w = c;
           result.push(c);
           while (true) {
-            if (data.index > length) {
+            if (data.index > length2) {
               return "";
             }
             bits = 0;
@@ -470,12 +482,6 @@ var PlanStatusValues = [
   "in_progress",
   "completed"
 ];
-var PlanViewTabValues = [
-  "plan",
-  "activity",
-  "deliverables",
-  "changes"
-];
 var OriginPlatformValues = [
   "claude-code",
   "devin",
@@ -532,38 +538,6 @@ var ConversationVersionSchema = z.discriminatedUnion("handedOff", [ConversationV
   handedOffAt: z.number(),
   handedOffTo: z.string()
 })]);
-var PlanEventTypes = [
-  "plan_created",
-  "status_changed",
-  "comment_added",
-  "comment_resolved",
-  "artifact_uploaded",
-  "deliverable_linked",
-  "pr_linked",
-  "content_edited",
-  "approved",
-  "changes_requested",
-  "completed",
-  "conversation_imported",
-  "conversation_handed_off",
-  "step_completed",
-  "plan_archived",
-  "plan_unarchived",
-  "conversation_exported",
-  "plan_shared",
-  "approval_requested",
-  "input_request_created",
-  "input_request_answered",
-  "input_request_declined",
-  "agent_activity",
-  "session_token_regenerated"
-];
-var AgentActivityTypes = [
-  "help_request",
-  "help_request_resolved",
-  "blocker",
-  "blocker_resolved"
-];
 var PlanEventBaseSchema = z.object({
   id: z.string(),
   actor: z.string(),
@@ -728,13 +702,6 @@ var PlanEventSchema = z.discriminatedUnion("type", [
   }),
   PlanEventBaseSchema.extend({ type: z.literal("session_token_regenerated") })
 ]);
-function isInboxWorthy(event, username, ownerId) {
-  if (!event.inboxWorthy) return false;
-  if (!event.inboxFor) return true;
-  const resolvedInboxFor = event.inboxFor === "owner" && ownerId ? ownerId : event.inboxFor;
-  if (Array.isArray(resolvedInboxFor)) return resolvedInboxFor.includes(username);
-  return resolvedInboxFor === username;
-}
 var PlanMetadataBaseSchema = z.object({
   id: z.string(),
   title: z.string(),
@@ -800,9 +767,6 @@ var LocalArtifactSchema = BaseArtifactSchema.extend({
   localArtifactId: z.string()
 });
 var ArtifactSchema = z.discriminatedUnion("storage", [GitHubArtifactSchema, LocalArtifactSchema]);
-function getArtifactUrl(repo, pr, planId, filename) {
-  return `https://raw.githubusercontent.com/${repo}/plan-artifacts/pr-${pr}/${planId}/${filename}`;
-}
 var DeliverableSchema = z.object({
   id: z.string(),
   text: z.string(),
@@ -879,15 +843,6 @@ var GitHubArtifactParseSchema = z.object({
   storage: z.literal("github"),
   url: z.string()
 });
-function createGitHubArtifact(params) {
-  const artifact = {
-    id: nanoid(),
-    ...params,
-    storage: "github",
-    uploadedAt: params.uploadedAt ?? Date.now()
-  };
-  return GitHubArtifactParseSchema.parse(artifact);
-}
 var LocalArtifactParseSchema = z.object({
   id: z.string(),
   type: z.enum([
@@ -901,15 +856,6 @@ var LocalArtifactParseSchema = z.object({
   storage: z.literal("local"),
   localArtifactId: z.string()
 });
-function createLocalArtifact(params) {
-  const artifact = {
-    id: nanoid(),
-    ...params,
-    storage: "local",
-    uploadedAt: params.uploadedAt ?? Date.now()
-  };
-  return LocalArtifactParseSchema.parse(artifact);
-}
 function createInitialConversationVersion(params) {
   const version = {
     ...params,
@@ -917,19 +863,12 @@ function createInitialConversationVersion(params) {
   };
   return ConversationVersionSchema.parse(version);
 }
-function createHandedOffConversationVersion(params) {
-  const version = {
-    ...params,
-    handedOff: true
-  };
-  return ConversationVersionSchema.parse(version);
-}
 
 // ../../packages/schema/dist/yjs-helpers-DzEyLz-f.mjs
 import { z as z2 } from "zod";
 import { nanoid as nanoid2 } from "nanoid";
 import * as Y from "yjs";
-function assertNever(value) {
+function assertNever2(value) {
   throw new Error(`Unhandled discriminated union member: ${JSON.stringify(value)}`);
 }
 var AgentPresenceSchema = z2.object({
@@ -1028,17 +967,6 @@ var CreateSubscriptionRequestSchema = z2.object({
   threshold: z2.number().positive().optional()
 });
 var CreateSubscriptionResponseSchema = z2.object({ clientId: z2.string() });
-var DEFAULT_INPUT_REQUEST_TIMEOUT_SECONDS = 1800;
-var InputRequestTypeValues = [
-  "text",
-  "multiline",
-  "choice",
-  "confirm",
-  "number",
-  "email",
-  "date",
-  "rating"
-];
 var InputRequestStatusValues = [
   "pending",
   "answered",
@@ -1206,17 +1134,6 @@ function createInputRequest(params) {
   if (!parseResult.success) throw new Error(`Invalid input request: ${parseResult.error.issues[0]?.message}`);
   return parseResult.data;
 }
-function normalizeChoiceOptions(options) {
-  return options.map((opt) => typeof opt === "string" ? {
-    value: opt,
-    label: opt
-  } : {
-    ...opt,
-    value: opt.value,
-    label: opt.label || opt.value
-  });
-}
-var CHOICE_DROPDOWN_THRESHOLD = 9;
 var MAX_QUESTIONS_PER_REQUEST = 10;
 var QuestionBaseSchema = z2.object({
   message: z2.string().min(1, "Message cannot be empty"),
@@ -1369,9 +1286,6 @@ var YDOC_KEYS = {
   LOCAL_DIFF_COMMENTS: "localDiffComments"
 };
 var validKeys = new Set(Object.values(YDOC_KEYS));
-function isValidYDocKey(key) {
-  return validKeys.has(key);
-}
 var CommentBodySchema = z2.union([z2.string(), z2.array(z2.unknown())]);
 var ThreadCommentSchema = z2.object({
   id: z2.string(),
@@ -1385,9 +1299,6 @@ var ThreadSchema = z2.object({
   resolved: z2.boolean().optional(),
   selectedText: z2.string().optional()
 });
-function isThread(value) {
-  return ThreadSchema.safeParse(value).success;
-}
 function parseThreads(data) {
   const threads = [];
   for (const [_key, value] of Object.entries(data)) {
@@ -1421,20 +1332,6 @@ function extractMentions(body) {
 function toUnknownArray(array) {
   return array.toJSON();
 }
-function findInputRequestById(data, requestId) {
-  for (let i = 0; i < data.length; i++) {
-    const item = data[i];
-    if (item && typeof item === "object" && "id" in item && item.id === requestId) {
-      const parsed = AnyInputRequestSchema.safeParse(item);
-      if (parsed.success) return {
-        rawIndex: i,
-        request: parsed.data
-      };
-      return null;
-    }
-  }
-  return null;
-}
 var VALID_STATUS_TRANSITIONS = {
   draft: [
     "pending_review",
@@ -1539,7 +1436,7 @@ function applyStatusTransitionFields(map, transition) {
       applyCompletedTransition(map, transition);
       break;
     default:
-      assertNever(transition);
+      assertNever2(transition);
   }
 }
 function resetPlanToDraft(ydoc, actor) {
@@ -1607,20 +1504,6 @@ function initPlanMetadata(ydoc, init) {
   const result = getPlanMetadataWithValidation(ydoc);
   if (!result.success) throw new Error(`Failed to initialize metadata: ${result.error}`);
 }
-function getStepCompletions(ydoc) {
-  const steps = ydoc.getMap("stepCompletions");
-  return new Map(steps.entries());
-}
-function toggleStepCompletion(ydoc, stepId, actor) {
-  ydoc.transact(() => {
-    const steps = ydoc.getMap("stepCompletions");
-    const current = steps.get(stepId) || false;
-    steps.set(stepId, !current);
-  }, actor ? { actor } : void 0);
-}
-function isStepCompleted(ydoc, stepId) {
-  return ydoc.getMap("stepCompletions").get(stepId) || false;
-}
 function getArtifacts(ydoc) {
   return toUnknownArray(ydoc.getArray(YDOC_KEYS.ARTIFACTS)).map((item) => {
     if (!item || typeof item !== "object") return null;
@@ -1639,40 +1522,12 @@ function addArtifact(ydoc, artifact, actor) {
     ydoc.getArray(YDOC_KEYS.ARTIFACTS).push([validated]);
   }, actor ? { actor } : void 0);
 }
-function removeArtifact(ydoc, artifactId) {
-  const array = ydoc.getArray(YDOC_KEYS.ARTIFACTS);
-  const index = toUnknownArray(array).map((item) => ArtifactSchema.safeParse(item)).filter((r) => r.success).map((r) => r.data).findIndex((a) => a.id === artifactId);
-  if (index === -1) return false;
-  array.delete(index, 1);
-  return true;
-}
-function getAgentPresences(ydoc) {
-  const map = ydoc.getMap(YDOC_KEYS.PRESENCE);
-  const result = /* @__PURE__ */ new Map();
-  for (const [sessionId, value] of map.entries()) {
-    const parsed = AgentPresenceSchema.safeParse(value);
-    if (parsed.success) result.set(sessionId, parsed.data);
-  }
-  return result;
-}
 function setAgentPresence(ydoc, presence, actor) {
   const validated = AgentPresenceSchema.parse(presence);
   ydoc.transact(() => {
     ydoc.getMap(YDOC_KEYS.PRESENCE).set(validated.sessionId, validated);
   }, actor ? { actor } : void 0);
 }
-function clearAgentPresence(ydoc, sessionId) {
-  const map = ydoc.getMap(YDOC_KEYS.PRESENCE);
-  if (!map.has(sessionId)) return false;
-  map.delete(sessionId);
-  return true;
-}
-function getAgentPresence(ydoc, sessionId) {
-  const value = ydoc.getMap(YDOC_KEYS.PRESENCE).get(sessionId);
-  if (!value) return null;
-  const parsed = AgentPresenceSchema.safeParse(value);
-  return parsed.success ? parsed.data : null;
-}
 function getDeliverables(ydoc) {
   return toUnknownArray(ydoc.getArray(YDOC_KEYS.DELIVERABLES)).map((item) => DeliverableSchema.safeParse(item)).filter((result) => result.success).map((result) => result.data);
 }
@@ -1701,75 +1556,6 @@ function linkArtifactToDeliverable(ydoc, deliverableId, artifactId, actor) {
   }, actor ? { actor } : void 0);
   return true;
 }
-function getPlanOwnerId(ydoc) {
-  const ownerId = ydoc.getMap(YDOC_KEYS.METADATA).get("ownerId");
-  return typeof ownerId === "string" ? ownerId : null;
-}
-function isApprovalRequired(ydoc) {
-  const map = ydoc.getMap(YDOC_KEYS.METADATA);
-  const approvalRequired = map.get("approvalRequired");
-  if (typeof approvalRequired === "boolean") return approvalRequired;
-  const ownerId = map.get("ownerId");
-  return typeof ownerId === "string" && ownerId.length > 0;
-}
-function getApprovedUsers(ydoc) {
-  const approvedUsers = ydoc.getMap(YDOC_KEYS.METADATA).get("approvedUsers");
-  if (!Array.isArray(approvedUsers)) return [];
-  return approvedUsers.filter((id) => typeof id === "string");
-}
-function isUserApproved(ydoc, userId) {
-  if (getPlanOwnerId(ydoc) === userId) return true;
-  return getApprovedUsers(ydoc).includes(userId);
-}
-function approveUser(ydoc, userId, actor) {
-  const currentApproved = getApprovedUsers(ydoc);
-  if (currentApproved.includes(userId)) return;
-  ydoc.transact(() => {
-    const map = ydoc.getMap(YDOC_KEYS.METADATA);
-    map.set("approvedUsers", [...currentApproved, userId]);
-    map.set("updatedAt", Date.now());
-  }, actor ? { actor } : void 0);
-}
-function revokeUser(ydoc, userId, actor) {
-  if (userId === getPlanOwnerId(ydoc)) return false;
-  const currentApproved = getApprovedUsers(ydoc);
-  if (currentApproved.indexOf(userId) === -1) return false;
-  ydoc.transact(() => {
-    const map = ydoc.getMap(YDOC_KEYS.METADATA);
-    map.set("approvedUsers", currentApproved.filter((id) => id !== userId));
-    map.set("updatedAt", Date.now());
-  }, actor ? { actor } : void 0);
-  return true;
-}
-function getRejectedUsers(ydoc) {
-  const rejectedUsers = ydoc.getMap(YDOC_KEYS.METADATA).get("rejectedUsers");
-  if (!Array.isArray(rejectedUsers)) return [];
-  return rejectedUsers.filter((id) => typeof id === "string");
-}
-function isUserRejected(ydoc, userId) {
-  return getRejectedUsers(ydoc).includes(userId);
-}
-function rejectUser(ydoc, userId, actor) {
-  if (userId === getPlanOwnerId(ydoc)) return;
-  const currentRejected = getRejectedUsers(ydoc);
-  const currentApproved = getApprovedUsers(ydoc);
-  ydoc.transact(() => {
-    const map = ydoc.getMap(YDOC_KEYS.METADATA);
-    if (!currentRejected.includes(userId)) map.set("rejectedUsers", [...currentRejected, userId]);
-    if (currentApproved.includes(userId)) map.set("approvedUsers", currentApproved.filter((id) => id !== userId));
-    map.set("updatedAt", Date.now());
-  }, actor ? { actor } : void 0);
-}
-function unrejectUser(ydoc, userId, actor) {
-  const currentRejected = getRejectedUsers(ydoc);
-  if (currentRejected.indexOf(userId) === -1) return false;
-  ydoc.transact(() => {
-    const map = ydoc.getMap(YDOC_KEYS.METADATA);
-    map.set("rejectedUsers", currentRejected.filter((id) => id !== userId));
-    map.set("updatedAt", Date.now());
-  }, actor ? { actor } : void 0);
-  return true;
-}
 function getLinkedPRs(ydoc) {
   return toUnknownArray(ydoc.getArray(YDOC_KEYS.LINKED_PRS)).map((item) => LinkedPRSchema.safeParse(item)).filter((result) => result.success).map((result) => result.data);
 }
@@ -1782,126 +1568,12 @@ function linkPR(ydoc, pr, actor) {
     array.push([validated]);
   }, actor ? { actor } : void 0);
 }
-function unlinkPR(ydoc, prNumber) {
-  const array = ydoc.getArray(YDOC_KEYS.LINKED_PRS);
-  const index = toUnknownArray(array).map((item) => LinkedPRSchema.safeParse(item)).filter((r) => r.success).map((r) => r.data).findIndex((p) => p.prNumber === prNumber);
-  if (index === -1) return false;
-  array.delete(index, 1);
-  return true;
-}
-function getLinkedPR(ydoc, prNumber) {
-  return getLinkedPRs(ydoc).find((pr) => pr.prNumber === prNumber) ?? null;
-}
-function updateLinkedPRStatus(ydoc, prNumber, status) {
-  const array = ydoc.getArray(YDOC_KEYS.LINKED_PRS);
-  const existing = toUnknownArray(array).map((item) => LinkedPRSchema.safeParse(item)).filter((r) => r.success).map((r) => r.data);
-  const index = existing.findIndex((p) => p.prNumber === prNumber);
-  if (index === -1) return false;
-  const pr = existing[index];
-  if (!pr) return false;
-  array.delete(index, 1);
-  array.insert(index, [{
-    ...pr,
-    status
-  }]);
-  return true;
-}
 function getPRReviewComments(ydoc) {
   return toUnknownArray(ydoc.getArray(YDOC_KEYS.PR_REVIEW_COMMENTS)).map((item) => PRReviewCommentSchema.safeParse(item)).filter((result) => result.success).map((result) => result.data);
 }
-function getPRReviewCommentsForPR(ydoc, prNumber) {
-  return getPRReviewComments(ydoc).filter((c) => c.prNumber === prNumber);
-}
-function addPRReviewComment(ydoc, comment, actor) {
-  const validated = PRReviewCommentSchema.parse(comment);
-  ydoc.transact(() => {
-    ydoc.getArray(YDOC_KEYS.PR_REVIEW_COMMENTS).push([validated]);
-  }, actor ? { actor } : void 0);
-}
-function resolvePRReviewComment(ydoc, commentId, resolved) {
-  const array = ydoc.getArray(YDOC_KEYS.PR_REVIEW_COMMENTS);
-  const existing = toUnknownArray(array).map((item) => PRReviewCommentSchema.safeParse(item)).filter((r) => r.success).map((r) => r.data);
-  const index = existing.findIndex((c) => c.id === commentId);
-  if (index === -1) return false;
-  const comment = existing[index];
-  if (!comment) return false;
-  array.delete(index, 1);
-  array.insert(index, [{
-    ...comment,
-    resolved
-  }]);
-  return true;
-}
-function removePRReviewComment(ydoc, commentId) {
-  const array = ydoc.getArray(YDOC_KEYS.PR_REVIEW_COMMENTS);
-  const index = toUnknownArray(array).map((item) => PRReviewCommentSchema.safeParse(item)).filter((r) => r.success).map((r) => r.data).findIndex((c) => c.id === commentId);
-  if (index === -1) return false;
-  array.delete(index, 1);
-  return true;
-}
 function getLocalDiffComments(ydoc) {
   return toUnknownArray(ydoc.getArray(YDOC_KEYS.LOCAL_DIFF_COMMENTS)).map((item) => LocalDiffCommentSchema.safeParse(item)).filter((result) => result.success).map((result) => result.data);
 }
-function getLocalDiffCommentsForFile(ydoc, path) {
-  return getLocalDiffComments(ydoc).filter((c) => c.path === path);
-}
-function addLocalDiffComment(ydoc, comment, actor) {
-  const validated = LocalDiffCommentSchema.parse(comment);
-  ydoc.transact(() => {
-    ydoc.getArray(YDOC_KEYS.LOCAL_DIFF_COMMENTS).push([validated]);
-  }, actor ? { actor } : void 0);
-}
-function resolveLocalDiffComment(ydoc, commentId, resolved) {
-  const array = ydoc.getArray(YDOC_KEYS.LOCAL_DIFF_COMMENTS);
-  const existing = toUnknownArray(array).map((item) => LocalDiffCommentSchema.safeParse(item)).filter((r) => r.success).map((r) => r.data);
-  const index = existing.findIndex((c) => c.id === commentId);
-  if (index === -1) return false;
-  const comment = existing[index];
-  if (!comment) return false;
-  array.delete(index, 1);
-  array.insert(index, [{
-    ...comment,
-    resolved
-  }]);
-  return true;
-}
-function removeLocalDiffComment(ydoc, commentId) {
-  const array = ydoc.getArray(YDOC_KEYS.LOCAL_DIFF_COMMENTS);
-  const index = toUnknownArray(array).map((item) => LocalDiffCommentSchema.safeParse(item)).filter((r) => r.success).map((r) => r.data).findIndex((c) => c.id === commentId);
-  if (index === -1) return false;
-  array.delete(index, 1);
-  return true;
-}
-function extractViewedByFromCrdt(existingViewedBy) {
-  const viewedBy = {};
-  if (existingViewedBy instanceof Y.Map) {
-    for (const [key, value] of existingViewedBy.entries()) if (typeof key === "string" && typeof value === "number") viewedBy[key] = value;
-  } else if (existingViewedBy && typeof existingViewedBy === "object" && !Array.isArray(existingViewedBy)) {
-    for (const [key, value] of Object.entries(existingViewedBy)) if (typeof value === "number") viewedBy[key] = value;
-  }
-  return viewedBy;
-}
-function markPlanAsViewed(ydoc, username) {
-  const map = ydoc.getMap(YDOC_KEYS.METADATA);
-  ydoc.transact(() => {
-    const viewedBy = extractViewedByFromCrdt(map.get("viewedBy"));
-    viewedBy[username] = Date.now();
-    const viewedByMap = new Y.Map();
-    for (const [user, timestamp] of Object.entries(viewedBy)) viewedByMap.set(user, timestamp);
-    map.set("viewedBy", viewedByMap);
-  });
-}
-function getViewedBy(ydoc) {
-  return extractViewedByFromCrdt(ydoc.getMap(YDOC_KEYS.METADATA).get("viewedBy"));
-}
-function isPlanUnread(metadata, username, viewedBy) {
-  const lastViewed = (viewedBy ?? {})[username];
-  if (!lastViewed) return true;
-  return lastViewed < metadata.updatedAt;
-}
-function getConversationVersions(ydoc) {
-  return getPlanMetadata(ydoc)?.conversationVersions || [];
-}
 function addConversationVersion(ydoc, version, actor) {
   const validated = ConversationVersionSchema.parse(version);
   ydoc.transact(() => {
@@ -1912,21 +1584,6 @@ function addConversationVersion(ydoc, version, actor) {
     metadata.set("conversationVersions", [...versions, validated]);
   }, actor ? { actor } : void 0);
 }
-function markVersionHandedOff(ydoc, versionId, handedOffTo, actor) {
-  const updated = getConversationVersions(ydoc).map((v) => {
-    if (v.versionId !== versionId) return v;
-    const handedOffVersion = {
-      ...v,
-      handedOff: true,
-      handedOffAt: Date.now(),
-      handedOffTo
-    };
-    return ConversationVersionSchema.parse(handedOffVersion);
-  });
-  ydoc.transact(() => {
-    ydoc.getMap(YDOC_KEYS.METADATA).set("conversationVersions", updated);
-  }, actor ? { actor } : void 0);
-}
 function logPlanEvent(ydoc, type, actor, ...args) {
   const eventsArray = ydoc.getArray(YDOC_KEYS.EVENTS);
   const [data, options] = args;
@@ -1981,229 +1638,6 @@ function createPlanSnapshot(ydoc, reason, actor, status, blocks) {
     deliverables: deliverables.length > 0 ? deliverables : void 0
   };
 }
-function getLatestSnapshot(ydoc) {
-  const snapshots = getSnapshots(ydoc);
-  if (snapshots.length === 0) return null;
-  return snapshots[snapshots.length - 1] ?? null;
-}
-function getValidatedTags(rawTags) {
-  if (!Array.isArray(rawTags)) return [];
-  return rawTags.filter((t2) => typeof t2 === "string");
-}
-function addPlanTag(ydoc, tag, actor) {
-  ydoc.transact(() => {
-    const map = ydoc.getMap(YDOC_KEYS.METADATA);
-    const currentTags = getValidatedTags(map.get("tags"));
-    const normalizedTag = tag.toLowerCase().trim();
-    if (!normalizedTag || currentTags.includes(normalizedTag)) return;
-    map.set("tags", [...currentTags, normalizedTag]);
-    map.set("updatedAt", Date.now());
-  }, actor ? { actor } : void 0);
-}
-function removePlanTag(ydoc, tag, actor) {
-  ydoc.transact(() => {
-    const map = ydoc.getMap(YDOC_KEYS.METADATA);
-    const currentTags = getValidatedTags(map.get("tags"));
-    const normalizedTag = tag.toLowerCase().trim();
-    map.set("tags", currentTags.filter((t2) => t2 !== normalizedTag));
-    map.set("updatedAt", Date.now());
-  }, actor ? { actor } : void 0);
-}
-function getAllTagsFromIndex(indexEntries) {
-  const tagSet = /* @__PURE__ */ new Set();
-  for (const entry of indexEntries) if (entry.tags) for (const tag of entry.tags) tagSet.add(tag);
-  return Array.from(tagSet).sort();
-}
-function archivePlan(ydoc, actorId) {
-  const metadata = getPlanMetadata(ydoc);
-  if (!metadata) return {
-    success: false,
-    error: "Plan metadata not found"
-  };
-  if (metadata.archivedAt) return {
-    success: false,
-    error: "Plan is already archived"
-  };
-  ydoc.transact(() => {
-    const metadataMap = ydoc.getMap(YDOC_KEYS.METADATA);
-    metadataMap.set("archivedAt", Date.now());
-    metadataMap.set("archivedBy", actorId);
-    metadataMap.set("updatedAt", Date.now());
-  }, { actor: actorId });
-  return { success: true };
-}
-function unarchivePlan(ydoc, actorId) {
-  const metadata = getPlanMetadata(ydoc);
-  if (!metadata) return {
-    success: false,
-    error: "Plan metadata not found"
-  };
-  if (!metadata.archivedAt) return {
-    success: false,
-    error: "Plan is not archived"
-  };
-  ydoc.transact(() => {
-    const metadataMap = ydoc.getMap(YDOC_KEYS.METADATA);
-    metadataMap.delete("archivedAt");
-    metadataMap.delete("archivedBy");
-    metadataMap.set("updatedAt", Date.now());
-  }, { actor: actorId });
-  return { success: true };
-}
-function answerInputRequest(ydoc, requestId, response, answeredBy) {
-  const requestsArray = ydoc.getArray(YDOC_KEYS.INPUT_REQUESTS);
-  const found = findInputRequestById(toUnknownArray(requestsArray), requestId);
-  if (!found) return {
-    success: false,
-    error: "Request not found"
-  };
-  const { rawIndex: index, request } = found;
-  if (request.status !== "pending") switch (request.status) {
-    case "answered":
-      return {
-        success: false,
-        error: "Request already answered",
-        answeredBy: request.answeredBy
-      };
-    case "declined":
-      return {
-        success: false,
-        error: "Request was declined"
-      };
-    case "cancelled":
-      return {
-        success: false,
-        error: "Request was cancelled"
-      };
-    default:
-      return {
-        success: false,
-        error: `Request is not pending`
-      };
-  }
-  const answeredRequest = {
-    ...request,
-    status: "answered",
-    response,
-    answeredAt: Date.now(),
-    answeredBy
-  };
-  const validated = InputRequestSchema.parse(answeredRequest);
-  ydoc.transact(() => {
-    requestsArray.delete(index, 1);
-    requestsArray.insert(index, [validated]);
-    logPlanEvent(ydoc, "input_request_answered", answeredBy, {
-      requestId,
-      response,
-      answeredBy,
-      requestMessage: "message" in request ? request.message : void 0,
-      requestType: request.type
-    });
-  });
-  return { success: true };
-}
-function answerMultiQuestionInputRequest(ydoc, requestId, responses, answeredBy) {
-  const requestsArray = ydoc.getArray(YDOC_KEYS.INPUT_REQUESTS);
-  const found = findInputRequestById(toUnknownArray(requestsArray), requestId);
-  if (!found) return {
-    success: false,
-    error: "Request not found"
-  };
-  const { rawIndex: index, request } = found;
-  if (request.type !== "multi") return {
-    success: false,
-    error: "Request is not pending"
-  };
-  if (request.status !== "pending") switch (request.status) {
-    case "answered":
-      return {
-        success: false,
-        error: "Request already answered",
-        answeredBy: request.answeredBy
-      };
-    case "declined":
-      return {
-        success: false,
-        error: "Request was declined"
-      };
-    case "cancelled":
-      return {
-        success: false,
-        error: "Request was cancelled"
-      };
-    default:
-      return {
-        success: false,
-        error: `Request is not pending`
-      };
-  }
-  const answeredRequest = {
-    ...request,
-    status: "answered",
-    responses,
-    answeredAt: Date.now(),
-    answeredBy
-  };
-  const validated = MultiQuestionInputRequestSchema.parse(answeredRequest);
-  ydoc.transact(() => {
-    requestsArray.delete(index, 1);
-    requestsArray.insert(index, [validated]);
-    logPlanEvent(ydoc, "input_request_answered", answeredBy, {
-      requestId,
-      response: responses,
-      answeredBy,
-      requestType: "multi"
-    });
-  });
-  return { success: true };
-}
-function cancelInputRequest(ydoc, requestId) {
-  const requestsArray = ydoc.getArray(YDOC_KEYS.INPUT_REQUESTS);
-  const found = findInputRequestById(toUnknownArray(requestsArray), requestId);
-  if (!found) return {
-    success: false,
-    error: "Request not found"
-  };
-  const { rawIndex: index, request } = found;
-  if (request.status !== "pending") return {
-    success: false,
-    error: `Request is not pending`
-  };
-  const cancelledRequest = {
-    ...request,
-    status: "cancelled"
-  };
-  const validated = request.type === "multi" ? MultiQuestionInputRequestSchema.parse(cancelledRequest) : InputRequestSchema.parse(cancelledRequest);
-  ydoc.transact(() => {
-    requestsArray.delete(index, 1);
-    requestsArray.insert(index, [validated]);
-  });
-  return { success: true };
-}
-function declineInputRequest(ydoc, requestId) {
-  const requestsArray = ydoc.getArray(YDOC_KEYS.INPUT_REQUESTS);
-  const found = findInputRequestById(toUnknownArray(requestsArray), requestId);
-  if (!found) return {
-    success: false,
-    error: "Request not found"
-  };
-  const { rawIndex: index, request } = found;
-  if (request.status !== "pending") return {
-    success: false,
-    error: `Request is not pending`
-  };
-  const declinedRequest = {
-    ...request,
-    status: "declined"
-  };
-  const validated = request.type === "multi" ? MultiQuestionInputRequestSchema.parse(declinedRequest) : InputRequestSchema.parse(declinedRequest);
-  ydoc.transact(() => {
-    requestsArray.delete(index, 1);
-    requestsArray.insert(index, [validated]);
-    logPlanEvent(ydoc, "input_request_declined", "User", { requestId });
-  });
-  return { success: true };
-}
 function atomicRegenerateTokenIfOwner(ydoc, expectedOwnerId, newTokenHash, actor) {
   let result = {
     success: false,
@@ -2272,29 +1706,10 @@ var UrlEncodedPlanV2Schema = z3.object({
   keyVersions: z3.array(UrlKeyVersionSchema).optional()
 });
 var UrlEncodedPlanSchema = z3.discriminatedUnion("v", [UrlEncodedPlanV1Schema, UrlEncodedPlanV2Schema]);
-function isUrlEncodedPlanV1(plan) {
-  return plan.v === 1;
-}
-function isUrlEncodedPlanV2(plan) {
-  return plan.v === 2;
-}
 function encodePlan(plan) {
   const json = JSON.stringify(plan);
   return import_lz_string.default.compressToEncodedURIComponent(json);
 }
-function decodePlan(encoded) {
-  try {
-    const json = import_lz_string.default.decompressFromEncodedURIComponent(encoded);
-    if (!json) return null;
-    const parsed = JSON.parse(json);
-    const result = UrlEncodedPlanSchema.safeParse(parsed);
-    if (!result.success)
-      return null;
-    return result.data;
-  } catch (_error) {
-    return null;
-  }
-}
 function createPlanUrl(baseUrl, plan) {
   const encoded = encodePlan(plan);
   const url = new URL(baseUrl);
@@ -2334,22 +1749,6 @@ function createPlanUrlWithHistory(baseUrl, plan, snapshots) {
     keyVersions: keyVersions.length > 0 ? keyVersions : void 0
   });
 }
-function getLocationSearch() {
-  if (typeof globalThis === "undefined") return null;
-  if (!("location" in globalThis)) return null;
-  const location = Object.fromEntries(Object.entries(globalThis)).location;
-  if (typeof location !== "object" || location === null) return null;
-  if (!("search" in location)) return null;
-  const search = Object.fromEntries(Object.entries(location)).search;
-  return typeof search === "string" ? search : null;
-}
-function getPlanFromUrl() {
-  const search = getLocationSearch();
-  if (!search) return null;
-  const encoded = new URLSearchParams(search).get("d");
-  if (!encoded) return null;
-  return decodePlan(encoded);
-}
 
 // ../../packages/schema/dist/index.mjs
 import { z as z4 } from "zod";
@@ -2560,88 +1959,6 @@ var ClaudeCodeMessageSchema = z4.object({
   costUSD: z4.number().optional(),
   durationMs: z4.number().optional()
 });
-function parseClaudeCodeTranscriptString(content) {
-  const lines = content.split("\n").filter((line) => line.trim());
-  const messages = [];
-  const errors = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line) continue;
-    try {
-      const parsed = JSON.parse(line);
-      const result = ClaudeCodeMessageSchema.safeParse(parsed);
-      if (result.success) messages.push(result.data);
-      else errors.push({
-        line: i + 1,
-        error: `Validation failed: ${result.error.message}`
-      });
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      errors.push({
-        line: i + 1,
-        error: `JSON parse error: ${errorMessage}`
-      });
-    }
-  }
-  return {
-    messages,
-    errors
-  };
-}
-function assertNever$1(x) {
-  throw new Error(`Unhandled case: ${JSON.stringify(x)}`);
-}
-function convertContentBlock(block) {
-  switch (block.type) {
-    case "text":
-      return [{
-        type: "text",
-        text: block.text
-      }];
-    case "tool_use":
-      return [{
-        type: "data",
-        data: { toolUse: {
-          name: block.name,
-          id: block.id,
-          input: block.input
-        } }
-      }];
-    case "tool_result":
-      return [{
-        type: "data",
-        data: { toolResult: {
-          toolUseId: block.tool_use_id,
-          content: block.content,
-          isError: block.is_error ?? false
-        } }
-      }];
-    default:
-      return assertNever$1(block);
-  }
-}
-function convertMessage(msg, contextId) {
-  const role = msg.message.role === "user" ? "user" : "agent";
-  const parts = msg.message.content.flatMap((block) => convertContentBlock(block));
-  return {
-    messageId: msg.uuid,
-    role,
-    parts,
-    contextId,
-    metadata: {
-      timestamp: msg.timestamp,
-      platform: "claude-code",
-      parentMessageId: msg.parentUuid,
-      model: msg.message.model,
-      usage: msg.message.usage,
-      costUSD: msg.costUSD,
-      durationMs: msg.durationMs
-    }
-  };
-}
-function claudeCodeToA2A(messages, contextId) {
-  return messages.filter((msg) => msg.type !== "summary").map((msg) => convertMessage(msg, contextId));
-}
 function validateA2AMessages(messages) {
   const valid = [];
   const errors = [];
@@ -2658,39 +1975,6 @@ function validateA2AMessages(messages) {
     errors
   };
 }
-function getFirstTextPart(parts) {
-  return parts.filter((p) => p.type === "text")[0];
-}
-function extractTitleFromMessage(msg) {
-  if (!msg) return "Imported Conversation";
-  const firstPart = getFirstTextPart(msg.parts);
-  if (!firstPart) return "Imported Conversation";
-  const text = firstPart.text;
-  return text.length > 50 ? `${text.slice(0, 50)}...` : text;
-}
-function isToolDataPart(part) {
-  const data = part.data;
-  return Boolean(data && typeof data === "object" && ("toolUse" in data || "toolResult" in data));
-}
-function countToolInteractions(parts) {
-  return parts.filter((p) => p.type === "data").filter(isToolDataPart).length;
-}
-function summarizeMessage(msg) {
-  const prefix = msg.role === "user" ? "User" : "Agent";
-  const firstTextPart = getFirstTextPart(msg.parts);
-  if (firstTextPart) return `${prefix}: ${firstTextPart.text.slice(0, 100)}${firstTextPart.text.length > 100 ? "..." : ""}`;
-  const toolCount = countToolInteractions(msg.parts);
-  if (toolCount > 0) return `${prefix}: [${toolCount} tool interaction(s)]`;
-}
-function summarizeA2AConversation(messages, maxMessages = 3) {
-  const title = extractTitleFromMessage(messages.find((m) => m.role === "user"));
-  const summaryLines = messages.slice(0, maxMessages).map(summarizeMessage).filter((line) => typeof line === "string");
-  if (messages.length > maxMessages) summaryLines.push(`... and ${messages.length - maxMessages} more messages`);
-  return {
-    title,
-    text: summaryLines.join("\n")
-  };
-}
 function isToolUseData(data) {
   if (!data || typeof data !== "object") return false;
   const d = toRecord(data);
@@ -2862,26 +2146,6 @@ function computeCommentStaleness(comment, currentHeadSha, currentLineContent) {
     isStale: false
   };
 }
-function isLineContentStale(comment, currentLineContent) {
-  if (!comment.lineContentHash || currentLineContent === void 0) return false;
-  const currentHash = hashLineContent(currentLineContent);
-  return comment.lineContentHash !== currentHash;
-}
-function withStalenessInfo(comment, currentHeadSha, currentLineContent) {
-  const staleness = computeCommentStaleness(comment, currentHeadSha, currentLineContent);
-  return {
-    ...comment,
-    isStale: staleness.isStale,
-    stalenessType: staleness.type
-  };
-}
-function withStalenessInfoBatch(comments, currentHeadSha, lineContentMap) {
-  return comments.map((comment) => {
-    const key = `${comment.path}:${comment.line}`;
-    const currentLineContent = lineContentMap?.get(key);
-    return withStalenessInfo(comment, currentHeadSha, currentLineContent);
-  });
-}
 function isDiffHeader(line) {
   return line.startsWith("diff --git") || line.startsWith("index ") || line.startsWith("---") || line.startsWith("+++");
 }
@@ -2996,26 +2260,6 @@ function formatDiffCommentsForLLM(comments, options = {}) {
 (${resolvedCount} resolved comment(s) not shown)`;
   return output;
 }
-function formatPRCommentsForLLM(comments, options = {}) {
-  return formatDiffCommentsForLLM(comments, options);
-}
-function getPRCommentsSummary(comments) {
-  const byFile = /* @__PURE__ */ new Map();
-  let unresolved = 0;
-  let resolved = 0;
-  for (const comment of comments) {
-    if (comment.resolved) resolved++;
-    else unresolved++;
-    const count = byFile.get(comment.path) ?? 0;
-    byFile.set(comment.path, count + 1);
-  }
-  return {
-    total: comments.length,
-    unresolved,
-    resolved,
-    byFile
-  };
-}
 var EnvironmentContextSchema = z4.object({
   projectName: z4.string().optional(),
   branch: z4.string().optional(),
@@ -3031,18 +2275,6 @@ var GitHubPRResponseSchema = z4.object({
   merged: z4.boolean(),
   head: z4.object({ ref: z4.string() })
 });
-function asPlanId(id) {
-  return id;
-}
-function asAwarenessClientId(id) {
-  return id;
-}
-function asWebRTCPeerId(id) {
-  return id;
-}
-function asGitHubUsername(username) {
-  return username;
-}
 var ROUTES = {
   REGISTRY_LIST: "/registry",
   REGISTRY_REGISTER: "/register",
@@ -3083,49 +2315,6 @@ var InviteRedemptionSchema = z4.object({
   redeemedAt: z4.number(),
   tokenId: z4.string()
 });
-function parseInviteFromUrl(url) {
-  try {
-    const inviteParam = new URL(url).searchParams.get("invite");
-    if (!inviteParam) return null;
-    const [tokenId, tokenValue] = inviteParam.split(":");
-    if (!tokenId || !tokenValue) return null;
-    return {
-      tokenId,
-      tokenValue
-    };
-  } catch {
-    return null;
-  }
-}
-function buildInviteUrl(baseUrl, planId, tokenId, tokenValue) {
-  const normalizedBase = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  const url = new URL(`${normalizedBase}${ROUTES.WEB_TASK(planId)}`);
-  url.searchParams.set("invite", `${tokenId}:${tokenValue}`);
-  return url.toString();
-}
-function getTokenTimeRemaining(expiresAt) {
-  const remaining = expiresAt - Date.now();
-  if (remaining <= 0) return {
-    expired: true,
-    minutes: 0,
-    formatted: "Expired"
-  };
-  const minutes = Math.ceil(remaining / 6e4);
-  if (minutes >= 60) {
-    const hours = Math.floor(minutes / 60);
-    const mins = minutes % 60;
-    return {
-      expired: false,
-      minutes,
-      formatted: mins > 0 ? `${hours}h ${mins}m` : `${hours}h`
-    };
-  }
-  return {
-    expired: false,
-    minutes,
-    formatted: `${minutes}m`
-  };
-}
 var GitFileStatusSchema = z4.enum([
   "added",
   "modified",
@@ -3163,11 +2352,6 @@ var LocalChangesUnavailableSchema = z4.object({
   message: z4.string()
 });
 var LocalChangesResultSchema = z4.discriminatedUnion("available", [LocalChangesResponseSchema, LocalChangesUnavailableSchema]);
-var P2PMessageType = {
-  CONVERSATION_EXPORT_START: 240,
-  CONVERSATION_CHUNK: 241,
-  CONVERSATION_EXPORT_END: 242
-};
 var ConversationExportStartMetaSchema = z4.object({
   exportId: z4.string(),
   totalChunks: z4.number().int().positive(),
@@ -3187,112 +2371,9 @@ var ConversationExportEndSchema = z4.object({
   exportId: z4.string(),
   checksum: z4.string()
 });
-function isConversationExportStart(data) {
-  return data.length > 0 && data[0] === P2PMessageType.CONVERSATION_EXPORT_START;
-}
-function isConversationChunk(data) {
-  return data.length > 0 && data[0] === P2PMessageType.CONVERSATION_CHUNK;
-}
-function isConversationExportEnd(data) {
-  return data.length > 0 && data[0] === P2PMessageType.CONVERSATION_EXPORT_END;
-}
-function isP2PConversationMessage(data) {
-  if (data.length === 0) return false;
-  const type = data[0];
-  return type === P2PMessageType.CONVERSATION_EXPORT_START || type === P2PMessageType.CONVERSATION_CHUNK || type === P2PMessageType.CONVERSATION_EXPORT_END;
-}
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
-function encodeExportStartMessage(meta) {
-  const jsonBytes = textEncoder.encode(JSON.stringify(meta));
-  const result = new Uint8Array(1 + jsonBytes.length);
-  result[0] = P2PMessageType.CONVERSATION_EXPORT_START;
-  result.set(jsonBytes, 1);
-  return result;
-}
-function decodeExportStartMessage(data) {
-  if (data.length === 0 || data[0] !== P2PMessageType.CONVERSATION_EXPORT_START) throw new Error("Invalid export start message: wrong type byte");
-  const jsonStr = textDecoder.decode(data.slice(1));
-  const parsed = JSON.parse(jsonStr);
-  return ConversationExportStartMetaSchema.parse(parsed);
-}
-function encodeChunkMessage(chunk) {
-  const exportIdBytes = textEncoder.encode(chunk.exportId);
-  const result = new Uint8Array(5 + exportIdBytes.length + 4 + chunk.data.length);
-  let offset = 0;
-  result[offset] = P2PMessageType.CONVERSATION_CHUNK;
-  offset += 1;
-  const view = new DataView(result.buffer);
-  view.setUint32(offset, exportIdBytes.length, false);
-  offset += 4;
-  result.set(exportIdBytes, offset);
-  offset += exportIdBytes.length;
-  view.setUint32(offset, chunk.chunkIndex, false);
-  offset += 4;
-  result.set(chunk.data, offset);
-  return result;
-}
-function decodeChunkMessage(data) {
-  if (data.length < 9 || data[0] !== P2PMessageType.CONVERSATION_CHUNK) throw new Error("Invalid chunk message: too short or wrong type byte");
-  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  let offset = 1;
-  const exportIdLength = view.getUint32(offset, false);
-  offset += 4;
-  if (data.length < 9 + exportIdLength) throw new Error("Invalid chunk message: exportId extends beyond message");
-  const exportId = textDecoder.decode(data.slice(offset, offset + exportIdLength));
-  offset += exportIdLength;
-  const chunkIndex = view.getUint32(offset, false);
-  offset += 4;
-  const chunkData = data.slice(offset);
-  return ChunkMessageSchema.parse({
-    exportId,
-    chunkIndex,
-    data: chunkData
-  });
-}
-function encodeExportEndMessage(end) {
-  const jsonBytes = textEncoder.encode(JSON.stringify(end));
-  const result = new Uint8Array(1 + jsonBytes.length);
-  result[0] = P2PMessageType.CONVERSATION_EXPORT_END;
-  result.set(jsonBytes, 1);
-  return result;
-}
-function decodeExportEndMessage(data) {
-  if (data.length === 0 || data[0] !== P2PMessageType.CONVERSATION_EXPORT_END) throw new Error("Invalid export end message: wrong type byte");
-  const jsonStr = textDecoder.decode(data.slice(1));
-  const parsed = JSON.parse(jsonStr);
-  return ConversationExportEndSchema.parse(parsed);
-}
-function decodeP2PMessage(data) {
-  if (data.length === 0) throw new Error("Cannot decode empty message");
-  const type = data[0];
-  if (type === void 0) throw new Error("Message type byte is missing");
-  switch (type) {
-    case P2PMessageType.CONVERSATION_EXPORT_START:
-      return {
-        type: "export_start",
-        payload: decodeExportStartMessage(data)
-      };
-    case P2PMessageType.CONVERSATION_CHUNK:
-      return {
-        type: "chunk",
-        payload: decodeChunkMessage(data)
-      };
-    case P2PMessageType.CONVERSATION_EXPORT_END:
-      return {
-        type: "export_end",
-        payload: decodeExportEndMessage(data)
-      };
-    default:
-      throw new Error(`Unknown P2P message type: 0x${type.toString(16)}`);
-  }
-}
-function assertNeverP2PMessage(msg) {
-  throw new Error(`Unhandled P2P message type: ${JSON.stringify(msg)}`);
-}
 var PLAN_INDEX_DOC_NAME = "plan-index";
-var PLAN_INDEX_VIEWED_BY_KEY = "viewedBy";
-var NON_PLAN_DB_NAMES = ["plan-index", "idb-keyval"];
 var PlanIndexEntrySchema = z4.discriminatedUnion("deleted", [z4.object({
   deleted: z4.literal(false),
   id: z4.string(),
@@ -3314,18 +2395,6 @@ var PlanIndexEntrySchema = z4.discriminatedUnion("deleted", [z4.object({
   deletedAt: z4.number(),
   deletedBy: z4.string()
 })]);
-function getPlanIndex(ydoc, includeArchived = false) {
-  const plansMap = ydoc.getMap(YDOC_KEYS.PLANS);
-  const entries = [];
-  for (const [_id, data] of plansMap.entries()) {
-    const result = PlanIndexEntrySchema.safeParse(data);
-    if (result.success) {
-      if (!includeArchived && result.data.deleted) continue;
-      entries.push(result.data);
-    }
-  }
-  return entries.sort((a, b) => b.updatedAt - a.updatedAt);
-}
 function getPlanIndexEntry(ydoc, planId) {
   const data = ydoc.getMap(YDOC_KEYS.PLANS).get(planId);
   if (!data) return null;
@@ -3336,9 +2405,6 @@ function setPlanIndexEntry(ydoc, entry) {
   const validated = PlanIndexEntrySchema.parse(entry);
   ydoc.getMap(YDOC_KEYS.PLANS).set(validated.id, validated);
 }
-function removePlanIndexEntry(ydoc, planId) {
-  ydoc.getMap(YDOC_KEYS.PLANS).delete(planId);
-}
 function touchPlanIndexEntry(ydoc, planId) {
   const entry = getPlanIndexEntry(ydoc, planId);
   if (entry) setPlanIndexEntry(ydoc, {
@@ -3346,84 +2412,6 @@ function touchPlanIndexEntry(ydoc, planId) {
     updatedAt: Date.now()
   });
 }
-function getViewedByFromIndex(ydoc, planId) {
-  const planViewedBy = ydoc.getMap(PLAN_INDEX_VIEWED_BY_KEY).get(planId);
-  if (!planViewedBy || !(planViewedBy instanceof Y2.Map)) return {};
-  const result = {};
-  for (const [username, timestamp] of planViewedBy.entries()) if (typeof timestamp === "number") result[username] = timestamp;
-  return result;
-}
-function updatePlanIndexViewedBy(ydoc, planId, username) {
-  ydoc.transact(() => {
-    const viewedByRoot = ydoc.getMap(PLAN_INDEX_VIEWED_BY_KEY);
-    let planViewedBy = viewedByRoot.get(planId);
-    if (!planViewedBy || !(planViewedBy instanceof Y2.Map)) {
-      planViewedBy = new Y2.Map();
-      viewedByRoot.set(planId, planViewedBy);
-    }
-    planViewedBy.set(username, Date.now());
-  });
-}
-function clearPlanIndexViewedBy(ydoc, planId, username) {
-  ydoc.transact(() => {
-    const planViewedBy = ydoc.getMap(PLAN_INDEX_VIEWED_BY_KEY).get(planId);
-    if (planViewedBy && planViewedBy instanceof Y2.Map) planViewedBy.delete(username);
-  });
-}
-function getAllViewedByFromIndex(ydoc, planIds) {
-  const result = {};
-  for (const planId of planIds) result[planId] = getViewedByFromIndex(ydoc, planId);
-  return result;
-}
-function removeViewedByFromIndex(ydoc, planId) {
-  ydoc.getMap(PLAN_INDEX_VIEWED_BY_KEY).delete(planId);
-}
-var PLAN_INDEX_EVENT_VIEWED_BY_KEY = "event-viewedBy";
-function markEventAsViewed(ydoc, planId, eventId, username) {
-  const viewedByRoot = ydoc.getMap(PLAN_INDEX_EVENT_VIEWED_BY_KEY);
-  const rawPlanEvents = viewedByRoot.get(planId);
-  let planEvents;
-  if (rawPlanEvents instanceof Y2.Map) planEvents = rawPlanEvents;
-  else {
-    planEvents = new Y2.Map();
-    viewedByRoot.set(planId, planEvents);
-  }
-  const rawEventViews = planEvents.get(eventId);
-  let eventViews;
-  if (rawEventViews instanceof Y2.Map) eventViews = rawEventViews;
-  else {
-    eventViews = new Y2.Map();
-    planEvents.set(eventId, eventViews);
-  }
-  eventViews.set(username, Date.now());
-}
-function clearEventViewedBy(ydoc, planId, eventId, username) {
-  const planEvents = ydoc.getMap(PLAN_INDEX_EVENT_VIEWED_BY_KEY).get(planId);
-  if (!planEvents || !(planEvents instanceof Y2.Map)) return;
-  const eventViews = planEvents.get(eventId);
-  if (!eventViews || !(eventViews instanceof Y2.Map)) return;
-  eventViews.delete(username);
-}
-function isEventUnread(ydoc, planId, eventId, username) {
-  const planEvents = ydoc.getMap(PLAN_INDEX_EVENT_VIEWED_BY_KEY).get(planId);
-  if (!planEvents || !(planEvents instanceof Y2.Map)) return true;
-  const eventViews = planEvents.get(eventId);
-  if (!eventViews || !(eventViews instanceof Y2.Map)) return true;
-  return !eventViews.has(username);
-}
-function getAllEventViewedByForPlan(ydoc, planId) {
-  const planEvents = ydoc.getMap(PLAN_INDEX_EVENT_VIEWED_BY_KEY).get(planId);
-  if (!planEvents || !(planEvents instanceof Y2.Map)) return {};
-  const result = {};
-  for (const [eventId, eventViews] of planEvents.entries()) {
-    if (!(eventViews instanceof Y2.Map)) continue;
-    const views = {};
-    for (const [username, timestamp] of eventViews.entries())
-      if (typeof timestamp === "number") views[username] = timestamp;
-    result[eventId] = views;
-  }
-  return result;
-}
 function formatThreadsForLLM(threads, options = {}) {
   const { includeResolved = false, selectedTextMaxLength = 100, resolveUser } = options;
   const unresolvedThreads = threads.filter((t$1) => !t$1.resolved);
@@ -3457,18 +2445,17 @@ function truncate(text, maxLength) {
 }
 var TOOL_NAMES = {
   ADD_ARTIFACT: "add_artifact",
-  ADD_PR_REVIEW_COMMENT: "add_pr_review_comment",
   COMPLETE_TASK: "complete_task",
-  CREATE_PLAN: "create_plan",
+  CREATE_TASK: "create_task",
   EXECUTE_CODE: "execute_code",
   LINK_PR: "link_pr",
   READ_DIFF_COMMENTS: "read_diff_comments",
-  READ_PLAN: "read_plan",
+  READ_TASK: "read_task",
   REGENERATE_SESSION_TOKEN: "regenerate_session_token",
   REQUEST_USER_INPUT: "request_user_input",
   SETUP_REVIEW_NOTIFICATION: "setup_review_notification",
   UPDATE_BLOCK_CONTENT: "update_block_content",
-  UPDATE_PLAN: "update_plan"
+  UPDATE_TASK: "update_task"
 };
 var PlanIdSchema = z4.object({ planId: z4.string().min(1) });
 var PlanStatusResponseSchema = z4.object({ status: z4.string() });
@@ -3662,9 +2649,6 @@ function isErrnoException(err) {
 function hasErrorCode(err, code) {
   return isErrnoException(err) && err.code === code;
 }
-function isBuffer(value) {
-  return Buffer.isBuffer(value);
-}
 function createUserResolver(ydoc, fallbackLength = 8) {
   const usersMap = ydoc.getMap("users");
   return (userId) => {
@@ -3681,258 +2665,2966 @@ function getSignalingConnections(provider) {
   if (hasSignalingConns(provider)) return provider.signalingConns;
   return [];
 }
-function getWebrtcPeerId(provider) {
-  return provider?.room?.peerId;
+
+// src/registry-server.ts
+import { mkdirSync, readFileSync as readFileSync2, unlinkSync } from "fs";
+import { readFile, unlink, writeFile as writeFile2 } from "fs/promises";
+import http from "http";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve, sep } from "path";
+import { createExpressMiddleware } from "@trpc/server/adapters/express";
+import express from "express";
+import * as decoding from "lib0/decoding";
+import * as encoding from "lib0/encoding";
+import { WebSocketServer } from "ws";
+import { LeveldbPersistence } from "y-leveldb";
+import * as awarenessProtocol from "y-protocols/awareness";
+import * as syncProtocol from "y-protocols/sync";
+import * as Y4 from "yjs";
+
+// src/config/env/registry.ts
+import { homedir } from "os";
+import { join } from "path";
+
+// ../../packages/shared/dist/registry-config.mjs
+var DEFAULT_REGISTRY_PORTS = [32191, 32192];
+
+// src/config/env/registry.ts
+import { z as z5 } from "zod";
+var schema = z5.object({
+  REGISTRY_PORT: z5.string().optional().transform((val) => {
+    if (!val) return DEFAULT_REGISTRY_PORTS;
+    const port = Number.parseInt(val, 10);
+    if (Number.isNaN(port)) {
+      throw new Error(`REGISTRY_PORT must be a valid number, got: ${val}`);
+    }
+    return [port];
+  }),
+  SHIPYARD_STATE_DIR: z5.string().optional().default(() => join(homedir(), ".shipyard"))
+});
+var registryConfig = loadEnv(schema);
+
+// src/conversation-handlers.ts
+import { mkdir, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { nanoid as nanoid3 } from "nanoid";
+async function importConversationHandler(input, ctx) {
+  const { a2aMessages, meta } = input;
+  if (!a2aMessages || !Array.isArray(a2aMessages)) {
+    return {
+      success: false,
+      error: "Missing or invalid a2aMessages"
+    };
+  }
+  if (a2aMessages.length === 0) {
+    return {
+      success: false,
+      error: "a2aMessages array is empty"
+    };
+  }
+  try {
+    const { valid, errors } = validateA2AMessages(a2aMessages);
+    if (errors.length > 0) {
+      return {
+        success: false,
+        error: `Invalid A2A messages: ${errors.map((e) => e.error).join(", ")}`
+      };
+    }
+    const sessionId = nanoid3();
+    const claudeMessages = a2aToClaudeCode(valid, sessionId);
+    const jsonl = formatAsClaudeCodeJSONL(claudeMessages);
+    const projectName = meta?.planId ? `shipyard-${meta.planId.slice(0, 8)}` : process.cwd().split("/").pop() || "shipyard";
+    const projectPath = join2(homedir2(), ".claude", "projects", projectName);
+    await mkdir(projectPath, { recursive: true });
+    const transcriptPath = join2(projectPath, `${sessionId}.jsonl`);
+    await writeFile(transcriptPath, jsonl, "utf-8");
+    ctx.logger.info(
+      {
+        sessionId,
+        transcriptPath,
+        messageCount: claudeMessages.length,
+        sourcePlatform: meta?.sourcePlatform
+      },
+      "Created Claude Code session from imported conversation"
+    );
+    return {
+      success: true,
+      sessionId,
+      transcriptPath,
+      messageCount: claudeMessages.length
+    };
+  } catch (error) {
+    ctx.logger.error({ error }, "Failed to import conversation");
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
 }
-function getWebrtcRoom(provider) {
-  return provider?.room ?? null;
+function createConversationHandlers() {
+  return {
+    importConversation: (input, ctx) => importConversationHandler(input, ctx)
+  };
 }
 
-export {
-  PlanStatusValues,
-  PlanViewTabValues,
-  OriginPlatformValues,
-  ClaudeCodeOriginMetadataSchema,
-  DevinOriginMetadataSchema,
-  CursorOriginMetadataSchema,
-  OriginMetadataSchema,
-  parseClaudeCodeOrigin,
-  ConversationVersionSchema,
-  PlanEventTypes,
-  AgentActivityTypes,
-  AgentActivityDataSchema,
-  PlanEventSchema,
-  isInboxWorthy,
-  PlanMetadataSchema,
-  ArtifactSchema,
-  getArtifactUrl,
-  DeliverableSchema,
-  PlanSnapshotSchema,
-  LinkedPRStatusValues,
-  LinkedPRSchema,
-  PRReviewCommentSchema,
-  LocalDiffCommentSchema,
-  createLinkedPR,
-  createGitHubArtifact,
-  createLocalArtifact,
-  createInitialConversationVersion,
-  createHandedOffConversationVersion,
-  assertNever,
-  AgentPresenceSchema,
-  ReviewCommentSchema,
-  ReviewFeedbackSchema,
-  CreateHookSessionRequestSchema,
-  CreateHookSessionResponseSchema,
-  UpdatePlanContentRequestSchema,
-  UpdatePlanContentResponseSchema,
-  GetReviewStatusResponseSchema,
-  UpdatePresenceRequestSchema,
-  UpdatePresenceResponseSchema,
-  HookApiErrorSchema,
-  RegisterServerRequestSchema,
-  RegisterServerResponseSchema,
-  UnregisterServerRequestSchema,
-  UnregisterServerResponseSchema,
-  ChangeTypeSchema,
-  CreateSubscriptionRequestSchema,
-  CreateSubscriptionResponseSchema,
-  DEFAULT_INPUT_REQUEST_TIMEOUT_SECONDS,
-  InputRequestTypeValues,
-  InputRequestStatusValues,
-  ChoiceOptionSchema,
+// src/crdt-validation.ts
+var corruptionState = /* @__PURE__ */ new Map();
+var CORRUPTION_REPORT_INTERVAL_MS = 5 * 60 * 1e3;
+function shouldReportCorruption(planId, key) {
+  const state = corruptionState.get(planId);
+  const now = Date.now();
+  if (!state) {
+    corruptionState.set(planId, {
+      lastReported: now,
+      corruptedKeys: /* @__PURE__ */ new Set([key])
+    });
+    return true;
+  }
+  if (!state.corruptedKeys.has(key)) {
+    state.corruptedKeys.add(key);
+    state.lastReported = now;
+    return true;
+  }
+  if (now - state.lastReported > CORRUPTION_REPORT_INTERVAL_MS) {
+    state.lastReported = now;
+    return true;
+  }
+  return false;
+}
+function clearCorruptionState(planId, key) {
+  const state = corruptionState.get(planId);
+  if (state) {
+    state.corruptedKeys.delete(key);
+    if (state.corruptedKeys.size === 0) {
+      corruptionState.delete(planId);
+    }
+  }
+}
+function validateMetadata(doc, planId) {
+  const result = getPlanMetadataWithValidation(doc);
+  if (result.success) {
+    clearCorruptionState(planId, YDOC_KEYS.METADATA);
+    return { key: YDOC_KEYS.METADATA, valid: true };
+  }
+  return {
+    key: YDOC_KEYS.METADATA,
+    valid: false,
+    errors: [result.error]
+  };
+}
+function validateArray(doc, key, schema4) {
+  const array = doc.getArray(key);
+  const items = array.toJSON();
+  if (items.length === 0) {
+    return { key, valid: true, totalItems: 0, invalidItems: 0 };
+  }
+  const errors = [];
+  let invalidCount = 0;
+  for (let i = 0; i < items.length; i++) {
+    const result = schema4.safeParse(items[i]);
+    if (!result.success) {
+      invalidCount++;
+      errors.push(`Item ${i}: ${result.error?.message ?? "Unknown error"}`);
+    }
+  }
+  return {
+    key,
+    valid: invalidCount === 0,
+    totalItems: items.length,
+    invalidItems: invalidCount,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+function logCorruption(planId, result, origin) {
+  if (!shouldReportCorruption(planId, result.key)) {
+    return;
+  }
+  logger.error(
+    {
+      planId,
+      key: result.key,
+      totalItems: result.totalItems,
+      invalidItems: result.invalidItems,
+      errors: result.errors?.slice(0, 5),
+      origin: typeof origin === "string" ? origin : void 0
+    },
+    "CRDT corruption detected from peer sync"
+  );
+}
+function createArrayObserver(planId, key, schema4) {
+  return (event, transaction) => {
+    const doc = event.target.doc;
+    if (!doc) return;
+    const result = validateArray(doc, key, schema4);
+    if (!result.valid) {
+      logCorruption(planId, result, transaction.origin);
+    } else {
+      clearCorruptionState(planId, key);
+    }
+  };
+}
+function attachCRDTValidation(planId, doc) {
+  doc.getMap(YDOC_KEYS.METADATA).observe((_event, transaction) => {
+    const result = validateMetadata(doc, planId);
+    if (!result.valid) {
+      logCorruption(planId, result, transaction.origin);
+    } else {
+      clearCorruptionState(planId, YDOC_KEYS.METADATA);
+    }
+  });
+  doc.getArray(YDOC_KEYS.ARTIFACTS).observe(createArrayObserver(planId, YDOC_KEYS.ARTIFACTS, ArtifactSchema));
+  doc.getArray(YDOC_KEYS.DELIVERABLES).observe(createArrayObserver(planId, YDOC_KEYS.DELIVERABLES, DeliverableSchema));
+  doc.getArray(YDOC_KEYS.LINKED_PRS).observe(createArrayObserver(planId, YDOC_KEYS.LINKED_PRS, LinkedPRSchema));
+  doc.getArray(YDOC_KEYS.EVENTS).observe(createArrayObserver(planId, YDOC_KEYS.EVENTS, PlanEventSchema));
+  doc.getArray(YDOC_KEYS.SNAPSHOTS).observe(createArrayObserver(planId, YDOC_KEYS.SNAPSHOTS, PlanSnapshotSchema));
+  doc.getArray(YDOC_KEYS.PR_REVIEW_COMMENTS).observe(
+    createArrayObserver(
+      planId,
+      YDOC_KEYS.PR_REVIEW_COMMENTS,
+      PRReviewCommentSchema
+    )
+  );
+  doc.getArray(YDOC_KEYS.INPUT_REQUESTS).observe(
+    createArrayObserver(planId, YDOC_KEYS.INPUT_REQUESTS, InputRequestSchema)
+  );
+  logger.debug({ planId }, "CRDT validation observers attached");
+}
+
+// src/git-local-changes.ts
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import { isAbsolute, join as join3, normalize } from "path";
+function execGit(command, opts) {
+  try {
+    return execSync(command, {
+      cwd: opts.cwd,
+      encoding: "utf-8",
+      timeout: opts.timeout ?? 5e3,
+      maxBuffer: opts.maxBuffer,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function ensureGitRepo(cwd) {
+  const isRepo = execGit("git rev-parse --is-inside-work-tree", { cwd });
+  if (isRepo !== null) return null;
+  logger.info({ cwd }, "Not a git repo, initializing with git init");
+  const initResult = execGit("git init", { cwd });
+  if (initResult === null) {
+    logger.error({ cwd }, "Failed to initialize git repository");
+    return {
+      available: false,
+      reason: "git_error",
+      message: "Failed to initialize git repository"
+    };
+  }
+  logger.info({ cwd }, "Git repository initialized");
+  return null;
+}
+function getCurrentBranchName(cwd) {
+  const branch = execGit("git rev-parse --abbrev-ref HEAD", { cwd });
+  if (!branch) {
+    logger.warn({ cwd }, "Could not get current branch");
+    return "unknown";
+  }
+  if (branch === "HEAD") {
+    return execGit("git rev-parse --short HEAD", { cwd }) ?? "unknown";
+  }
+  return branch;
+}
+function getGitDiff(cwd) {
+  const headDiff = execGit("git diff HEAD", { cwd, timeout: 3e4, maxBuffer: 10 * 1024 * 1024 });
+  if (headDiff !== null) return headDiff;
+  logger.debug({ cwd }, "git diff HEAD failed, trying --cached");
+  return execGit("git diff --cached", { cwd, timeout: 3e4, maxBuffer: 10 * 1024 * 1024 }) ?? "";
+}
+function mergeFilesWithStatus(staged, unstaged, diffFiles) {
+  const allPaths = /* @__PURE__ */ new Set([
+    ...staged.map((f) => f.path),
+    ...unstaged.map((f) => f.path),
+    ...diffFiles.map((f) => f.path)
+  ]);
+  const mergedFiles = [];
+  for (const path of allPaths) {
+    const diffFile = diffFiles.find((f) => f.path === path);
+    const stagedFile = staged.find((f) => f.path === path);
+    const unstagedFile = unstaged.find((f) => f.path === path);
+    if (diffFile) {
+      mergedFiles.push(diffFile);
+    } else {
+      const status = stagedFile?.status ?? unstagedFile?.status ?? "modified";
+      mergedFiles.push({
+        path,
+        status,
+        additions: 0,
+        deletions: 0,
+        patch: void 0
+      });
+    }
+  }
+  return mergedFiles.sort((a, b) => a.path.localeCompare(b.path));
+}
+function getLocalChanges(cwd) {
+  try {
+    const repoError = ensureGitRepo(cwd);
+    if (repoError) return repoError;
+    const branch = getCurrentBranchName(cwd);
+    let headSha;
+    try {
+      headSha = execGit("git rev-parse HEAD", { cwd }) ?? void 0;
+    } catch {
+      headSha = void 0;
+    }
+    const statusOutput = execGit("git status --porcelain", { cwd, timeout: 1e4 }) ?? "";
+    const { staged, unstaged, untracked } = parseGitStatus(statusOutput);
+    const diffOutput = getGitDiff(cwd);
+    const diffFiles = parseDiffOutput(diffOutput);
+    const mergedFiles = mergeFilesWithStatus(staged, unstaged, diffFiles);
+    logger.debug(
+      {
+        cwd,
+        branch,
+        headSha,
+        stagedCount: staged.length,
+        unstagedCount: unstaged.length,
+        untrackedCount: untracked.length,
+        filesCount: mergedFiles.length
+      },
+      "Got local changes"
+    );
+    return {
+      available: true,
+      branch,
+      baseBranch: "HEAD",
+      headSha,
+      staged,
+      unstaged,
+      untracked,
+      files: mergedFiles
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    logger.error({ error, cwd }, "Failed to get local changes");
+    return {
+      available: false,
+      reason: "git_error",
+      message: `Git error: ${message}`
+    };
+  }
+}
+function parseGitStatus(output) {
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  for (const line of output.split("\n")) {
+    if (!line || line.length < 3) continue;
+    const x = line[0];
+    const y = line[1];
+    let path = line.slice(3);
+    if (path.includes(" -> ")) {
+      path = path.split(" -> ")[1] ?? path;
+    }
+    if (x === "?" && y === "?") {
+      untracked.push(path);
+      continue;
+    }
+    if (x === "!" && y === "!") {
+      continue;
+    }
+    if (x && x !== " " && x !== "?") {
+      staged.push({
+        path,
+        status: parseStatusChar(x),
+        additions: 0,
+        deletions: 0
+      });
+    }
+    if (y && y !== " " && y !== "?") {
+      unstaged.push({
+        path,
+        status: parseStatusChar(y),
+        additions: 0,
+        deletions: 0
+      });
+    }
+  }
+  return { staged, unstaged, untracked };
+}
+function parseStatusChar(char) {
+  switch (char) {
+    case "A":
+      return "added";
+    case "M":
+      return "modified";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "copied";
+    case "U":
+      return "modified";
+    default:
+      return "modified";
+  }
+}
+function parseDiffOutput(diff) {
+  const files = [];
+  if (!diff.trim()) {
+    return files;
+  }
+  const fileDiffs = diff.split(/(?=diff --git )/);
+  for (const fileDiff of fileDiffs) {
+    if (!fileDiff.trim()) continue;
+    const headerMatch = fileDiff.match(/^diff --git a\/(.+?) b\/(.+)/m);
+    if (!headerMatch) continue;
+    const path = headerMatch[2] ?? headerMatch[1];
+    if (!path) continue;
+    if (fileDiff.includes("Binary files")) {
+      files.push({
+        path,
+        status: detectStatus(fileDiff),
+        additions: 0,
+        deletions: 0,
+        patch: void 0
+      });
+      continue;
+    }
+    let additions = 0;
+    let deletions = 0;
+    for (const line of fileDiff.split("\n")) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        additions++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        deletions++;
+      }
+    }
+    const patchStart = fileDiff.indexOf("@@");
+    const patch = patchStart >= 0 ? fileDiff.slice(patchStart) : void 0;
+    files.push({
+      path,
+      status: detectStatus(fileDiff),
+      additions,
+      deletions,
+      patch
+    });
+  }
+  return files;
+}
+function detectStatus(fileDiff) {
+  if (fileDiff.includes("new file mode")) {
+    return "added";
+  }
+  if (fileDiff.includes("deleted file mode")) {
+    return "deleted";
+  }
+  if (fileDiff.includes("rename from")) {
+    return "renamed";
+  }
+  if (fileDiff.includes("copy from")) {
+    return "copied";
+  }
+  return "modified";
+}
+function getFileContent(cwd, filePath) {
+  try {
+    const normalizedPath = normalize(filePath);
+    if (isAbsolute(normalizedPath) || normalizedPath.startsWith("..")) {
+      return { content: null, error: "Invalid file path" };
+    }
+    const fullPath = join3(cwd, normalizedPath);
+    if (!fullPath.startsWith(cwd)) {
+      return { content: null, error: "Invalid file path" };
+    }
+    const content = readFileSync(fullPath, { encoding: "utf-8" });
+    if (content.length > 10 * 1024 * 1024) {
+      return { content: null, error: "File too large to display" };
+    }
+    return { content };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    if (message.includes("ENOENT")) {
+      return { content: null, error: "File not found" };
+    }
+    if (message.includes("EISDIR")) {
+      return { content: null, error: "Path is a directory" };
+    }
+    return { content: null, error: `Failed to read file: ${message}` };
+  }
+}
+
+// src/github-artifacts.ts
+import { Octokit } from "@octokit/rest";
+
+// src/config/env/github.ts
+import { execSync as execSync2 } from "child_process";
+import { z as z6 } from "zod";
+function getTokenFromGhCli() {
+  try {
+    const token = execSync2("gh auth token", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (token) {
+      return token;
+    }
+  } catch {
+  }
+  return null;
+}
+var schema2 = z6.object({
+  GITHUB_USERNAME: z6.string().optional(),
+  GITHUB_TOKEN: z6.string().optional().transform((val) => val || getTokenFromGhCli() || null),
+  SHIPYARD_ARTIFACTS: z6.string().optional().transform((val) => {
+    if (!val) return true;
+    const setting = val.toLowerCase();
+    return setting !== "disabled" && setting !== "false" && setting !== "0";
+  })
+});
+var githubConfig = loadEnv(schema2);
+
+// src/github-artifacts.ts
+var ARTIFACTS_BRANCH = "plan-artifacts";
+function parseRepoString(repo) {
+  const parts = repo.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid repo format: "${repo}". Expected "owner/repo".`);
+  }
+  return { owner: parts[0], repoName: parts[1] };
+}
+function isArtifactsEnabled() {
+  return githubConfig.SHIPYARD_ARTIFACTS;
+}
+function resolveGitHubToken() {
+  return githubConfig.GITHUB_TOKEN;
+}
+function getErrorStatus(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const record = Object.fromEntries(Object.entries(error));
+  const status = record.status;
+  return typeof status === "number" ? status : void 0;
+}
+function isAuthError(error) {
+  const status = getErrorStatus(error);
+  return status === 401 || status === 403;
+}
+var GitHubAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitHubAuthError";
+  }
+};
+async function withTokenRetry(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    if (isAuthError(error)) {
+      logger.info("GitHub auth error, checking token and retrying...");
+      const newToken = resolveGitHubToken();
+      if (!newToken) {
+        throw new GitHubAuthError(
+          "GitHub token expired and could not be refreshed.\n\nTo fix this, run in your terminal:\n  gh auth login\n\nOr set GITHUB_TOKEN environment variable in your MCP config."
+        );
+      }
+      try {
+        return await operation();
+      } catch (retryError) {
+        if (isAuthError(retryError)) {
+          throw new GitHubAuthError(
+            "GitHub authentication failed after token refresh.\n\nYour token may not have the required permissions.\nRun: gh auth login --scopes repo\n\nOr check your GITHUB_TOKEN has repo access."
+          );
+        }
+        throw retryError;
+      }
+    }
+    throw error;
+  }
+}
+function getOctokit() {
+  const token = resolveGitHubToken();
+  if (!token) {
+    return null;
+  }
+  return new Octokit({ auth: token });
+}
+function isGitHubConfigured() {
+  return !!resolveGitHubToken();
+}
+async function ensureArtifactsBranch(repo) {
+  return withTokenRetry(async () => {
+    const octokit = getOctokit();
+    if (!octokit) {
+      throw new Error("GITHUB_TOKEN not set");
+    }
+    const { owner, repoName } = parseRepoString(repo);
+    try {
+      await octokit.repos.getBranch({
+        owner,
+        repo: repoName,
+        branch: ARTIFACTS_BRANCH
+      });
+      logger.debug({ repo }, "Artifacts branch exists");
+      return;
+    } catch (error) {
+      if (getErrorStatus(error) !== 404) {
+        throw error;
+      }
+    }
+    logger.info({ repo }, "Creating artifacts branch");
+    try {
+      const { data: repoData } = await octokit.repos.get({ owner, repo: repoName });
+      const defaultBranch = repoData.default_branch;
+      const { data: refData } = await octokit.git.getRef({
+        owner,
+        repo: repoName,
+        ref: `heads/${defaultBranch}`
+      });
+      await octokit.git.createRef({
+        owner,
+        repo: repoName,
+        ref: `refs/heads/${ARTIFACTS_BRANCH}`,
+        sha: refData.object.sha
+      });
+      logger.info({ repo, branch: ARTIFACTS_BRANCH }, "Created artifacts branch");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(
+        `Failed to create "${ARTIFACTS_BRANCH}" branch. Please create it manually:
+
+  git checkout --orphan ${ARTIFACTS_BRANCH}
+  git rm -rf .
+  git commit --allow-empty -m "Initialize plan artifacts"
+  git push -u origin ${ARTIFACTS_BRANCH}
+  git checkout main
+
+Error: ${message}`
+      );
+    }
+  });
+}
+async function uploadArtifact(params) {
+  return withTokenRetry(async () => {
+    const octokit = getOctokit();
+    if (!octokit) {
+      throw new Error("GITHUB_TOKEN not set");
+    }
+    const { repo, planId, filename, content } = params;
+    const { owner, repoName } = parseRepoString(repo);
+    const path = `plans/${planId}/${filename}`;
+    await ensureArtifactsBranch(repo);
+    let existingSha;
+    try {
+      const { data } = await octokit.repos.getContent({
+        owner,
+        repo: repoName,
+        path,
+        ref: ARTIFACTS_BRANCH
+      });
+      if (!Array.isArray(data) && data.type === "file") {
+        existingSha = data.sha;
+      }
+    } catch (error) {
+      if (getErrorStatus(error) !== 404) {
+        throw error;
+      }
+    }
+    await octokit.repos.createOrUpdateFileContents({
+      owner,
+      repo: repoName,
+      path,
+      message: `Add artifact: ${filename}`,
+      content,
+      branch: ARTIFACTS_BRANCH,
+      sha: existingSha
+    });
+    const url = `https://raw.githubusercontent.com/${repo}/${ARTIFACTS_BRANCH}/${path}`;
+    logger.info({ repo, path, url }, "Artifact uploaded");
+    return url;
+  });
+}
+
+// src/hook-handlers.ts
+import { ServerBlockNoteEditor } from "@blocknote/server-util";
+
+// ../../packages/shared/dist/index.mjs
+import { createHash, randomBytes } from "crypto";
+function computeHash(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function generateSessionToken() {
+  return randomBytes(32).toString("base64url");
+}
+function hashSessionToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+var APPROVAL_LONG_POLL_TIMEOUT_MS = 1800 * 1e3;
+var DEFAULT_TRPC_TIMEOUT_MS = 10 * 1e3;
+
+// src/hook-handlers.ts
+import { TRPCError as TRPCError2 } from "@trpc/server";
+import { nanoid as nanoid4 } from "nanoid";
+import open from "open";
+
+// src/config/env/web.ts
+import { z as z7 } from "zod";
+var schema3 = z7.object({
+  SHIPYARD_WEB_URL: z7.string().url().default("https://schoolai.github.io/shipyard")
+});
+var webConfig = loadEnv(schema3);
+
+// src/hub-client.ts
+import { WebsocketProvider } from "y-websocket";
+import * as Y3 from "yjs";
+var providers = /* @__PURE__ */ new Map();
+var docs = /* @__PURE__ */ new Map();
+var hubPort = null;
+var initialized = false;
+async function initHubClient(port) {
+  if (initialized) {
+    logger.warn("Hub client already initialized");
+    return;
+  }
+  hubPort = port;
+  initialized = true;
+  logger.info({ hubPort }, "Hub client initialized, will connect to registry hub");
+}
+function isHubClientInitialized() {
+  return initialized;
+}
+async function getOrCreateDoc(docName) {
+  const existing = docs.get(docName);
+  if (existing) {
+    return existing;
+  }
+  if (!initialized || !hubPort) {
+    throw new Error("Hub client not initialized. Call initHubClient() first.");
+  }
+  const doc = new Y3.Doc();
+  docs.set(docName, doc);
+  const hubUrl = `ws://localhost:${hubPort}`;
+  const provider = new WebsocketProvider(hubUrl, docName, doc, {
+    connect: true,
+    maxBackoffTime: 2500
+  });
+  providers.set(docName, provider);
+  await new Promise((resolve2, reject) => {
+    if (provider.synced) {
+      logger.debug({ docName }, "Provider already synced");
+      resolve2();
+      return;
+    }
+    const onSync = (isSynced) => {
+      if (isSynced) {
+        logger.debug({ docName }, "Provider synced via sync event");
+        provider.off("sync", onSync);
+        clearTimeout(timeoutId);
+        resolve2();
+      }
+    };
+    provider.on("sync", onSync);
+    const timeoutId = setTimeout(() => {
+      if (!provider.synced) {
+        provider.off("sync", onSync);
+        logger.error({ docName, synced: provider.synced }, "Hub sync timeout - cannot proceed");
+        reject(new Error(`Failed to sync document '${docName}' with hub within 10 seconds`));
+      }
+    }, 1e4);
+  });
+  logger.info({ docName, hubUrl }, "Connected to hub for document sync");
+  return doc;
+}
+async function hasActiveConnections(planId) {
+  if (!hubPort) return false;
+  try {
+    const res = await fetch(`http://localhost:${hubPort}${ROUTES.PLAN_HAS_CONNECTIONS(planId)}`, {
+      signal: AbortSignal.timeout(500)
+    });
+    if (!res.ok) return false;
+    const data = HasConnectionsResponseSchema.parse(await res.json());
+    return data.hasConnections;
+  } catch {
+    return false;
+  }
+}
+
+// src/webrtc-provider.ts
+import wrtc from "@roamhq/wrtc";
+import { WebrtcProvider } from "y-webrtc";
+
+// src/server-identity.ts
+import { execSync as execSync3 } from "child_process";
+import os from "os";
+import { basename } from "path";
+import { z as z8 } from "zod";
+var GitHubUserResponseSchema = z8.object({
+  login: z8.string().optional()
+});
+var cachedUsername = null;
+var usernameResolved = false;
+var cachedRepoName = null;
+function getRepositoryFullName() {
+  if (cachedRepoName !== null) {
+    return cachedRepoName || null;
+  }
+  try {
+    const repoName = execSync3("gh repo view --json nameWithOwner --jq .nameWithOwner", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!repoName) {
+      cachedRepoName = "";
+      return null;
+    }
+    cachedRepoName = repoName;
+    return cachedRepoName;
+  } catch {
+    cachedRepoName = "";
+    return null;
+  }
+}
+async function getGitHubUsername() {
+  if (usernameResolved && cachedUsername) {
+    return cachedUsername;
+  }
+  if (githubConfig.GITHUB_USERNAME) {
+    cachedUsername = githubConfig.GITHUB_USERNAME;
+    usernameResolved = true;
+    logger.info({ username: cachedUsername }, "Using GITHUB_USERNAME from env");
+    return cachedUsername;
+  }
+  if (githubConfig.GITHUB_TOKEN) {
+    const username = await getUsernameFromToken(githubConfig.GITHUB_TOKEN);
+    if (username) {
+      cachedUsername = username;
+      usernameResolved = true;
+      logger.info({ username }, "Resolved username from GITHUB_TOKEN via API");
+      return cachedUsername;
+    }
+  }
+  const cliUsername = getUsernameFromCLI();
+  if (cliUsername) {
+    cachedUsername = cliUsername;
+    usernameResolved = true;
+    logger.info({ username: cliUsername }, "Resolved username from gh CLI");
+    return cachedUsername;
+  }
+  const gitUsername = getUsernameFromGitConfig();
+  if (gitUsername) {
+    cachedUsername = gitUsername;
+    usernameResolved = true;
+    logger.warn({ username: gitUsername }, "Using git config user.name (UNVERIFIED)");
+    return cachedUsername;
+  }
+  const osUsername = process.env.USER || process.env.USERNAME;
+  if (osUsername) {
+    cachedUsername = osUsername.replace(/[^a-zA-Z0-9_-]/g, "_");
+    usernameResolved = true;
+    logger.warn(
+      { username: cachedUsername, original: osUsername },
+      "Using sanitized OS username (UNVERIFIED)"
+    );
+    return cachedUsername;
+  }
+  usernameResolved = true;
+  throw new Error(
+    'GitHub username required but could not be determined.\n\nConfigure ONE of:\n1. GITHUB_USERNAME=your-username (explicit)\n2. GITHUB_TOKEN=ghp_xxx (will fetch from API)\n3. gh auth login (uses CLI)\n4. git config --global user.name "your-username"\n5. Set USER or USERNAME environment variable\n\nFor remote agents: Use option 1 or 2'
+  );
+}
+async function getUsernameFromToken(token) {
+  try {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "shipyard-mcp-server"
+      },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) return null;
+    const user = GitHubUserResponseSchema.parse(await response.json());
+    return user.login ?? null;
+  } catch (error) {
+    logger.debug({ error }, "GitHub API failed");
+    return null;
+  }
+}
+function getUsernameFromCLI() {
+  try {
+    const username = execSync3("gh api user --jq .login", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return username || null;
+  } catch {
+    return null;
+  }
+}
+function getUsernameFromGitConfig() {
+  try {
+    const username = execSync3("git config user.name", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return username || null;
+  } catch {
+    return null;
+  }
+}
+async function getVerifiedGitHubUsername() {
+  if (githubConfig.GITHUB_USERNAME) {
+    logger.info({ username: githubConfig.GITHUB_USERNAME }, "Using GITHUB_USERNAME from env");
+    return githubConfig.GITHUB_USERNAME;
+  }
+  if (githubConfig.GITHUB_TOKEN) {
+    try {
+      const username = await getUsernameFromToken(githubConfig.GITHUB_TOKEN);
+      if (username) {
+        logger.info({ username }, "Got verified username from GITHUB_TOKEN");
+        return username;
+      }
+    } catch (error) {
+      logger.warn({ error }, "Failed to get username from GITHUB_TOKEN");
+    }
+  }
+  try {
+    const username = getUsernameFromCLI();
+    if (username) {
+      logger.info({ username }, "Got verified username from gh CLI");
+      return username;
+    }
+  } catch (error) {
+    logger.debug({ error }, "Failed to get username from gh CLI");
+  }
+  logger.warn("No verified GitHub authentication available");
+  return null;
+}
+function getGitBranch() {
+  try {
+    return execSync3("git branch --show-current", {
+      encoding: "utf-8",
+      timeout: 2e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getEnvironmentContext() {
+  return {
+    projectName: basename(process.cwd()) || void 0,
+    branch: getGitBranch(),
+    hostname: os.hostname(),
+    repo: getRepositoryFullName() || void 0
+  };
+}
+
+// src/webrtc-provider.ts
+var SIGNALING_SERVER = process.env.SIGNALING_URL || "wss://shipyard-signaling.jacob-191.workers.dev";
+var globalAny = globalThis;
+if (typeof globalAny.RTCPeerConnection === "undefined") {
+  globalAny.RTCPeerConnection = wrtc.RTCPeerConnection;
+  globalAny.RTCSessionDescription = wrtc.RTCSessionDescription;
+  globalAny.RTCIceCandidate = wrtc.RTCIceCandidate;
+}
+async function createWebRtcProvider(ydoc, planId) {
+  const iceServers = [
+    { urls: "stun:stun.l.google.com:19302" },
+    { urls: "stun:stun1.l.google.com:19302" }
+  ];
+  if (process.env.TURN_URL && process.env.TURN_USERNAME && process.env.TURN_CREDENTIAL) {
+    iceServers.push({
+      urls: process.env.TURN_URL,
+      username: process.env.TURN_USERNAME,
+      credential: process.env.TURN_CREDENTIAL
+    });
+    logger.info({ turnUrl: process.env.TURN_URL }, "TURN server configured");
+  }
+  const roomName = `shipyard-${planId}`;
+  const provider = new WebrtcProvider(roomName, ydoc, {
+    signaling: [SIGNALING_SERVER],
+    peerOpts: {
+      // @ts-expect-error - wrtc type definitions don't match runtime structure
+      wrtc: wrtc.default || wrtc,
+      config: {
+        iceServers
+      }
+    }
+  });
+  const username = await getGitHubUsername().catch(() => void 0);
+  const fallbackId = `mcp-anon-${crypto.randomUUID().slice(0, 8)}`;
+  const userId = username ? `mcp-${username}` : fallbackId;
+  const displayName = username ? `Claude Code (${username})` : "Claude Code";
+  const awarenessState = {
+    user: {
+      id: userId,
+      name: displayName,
+      color: "#0066cc"
+    },
+    platform: "claude-code",
+    status: "approved",
+    isOwner: true,
+    webrtcPeerId: crypto.randomUUID(),
+    context: getEnvironmentContext()
+  };
+  provider.awareness.setLocalStateField("planStatus", awarenessState);
+  logger.info(
+    { planId, username: username ?? fallbackId, platform: "claude-code", hasContext: true },
+    "MCP awareness state set"
+  );
+  sendApprovalStateToSignaling(provider, planId, username ?? fallbackId);
+  setupProviderListeners(provider, planId);
+  logger.info(
+    {
+      planId,
+      roomName,
+      signaling: SIGNALING_SERVER,
+      hasTurn: iceServers.length > 2
+    },
+    "WebRTC provider created"
+  );
+  return provider;
+}
+function sendApprovalStateToSignaling(provider, planId, username) {
+  const signalingConns = getSignalingConnections(provider);
+  if (signalingConns.length === 0) {
+    setTimeout(() => sendApprovalStateToSignaling(provider, planId, username), 1e3);
+    return;
+  }
+  const identifyMessage = JSON.stringify({
+    type: "subscribe",
+    topics: [],
+    userId: username
+  });
+  const approvalStateMessage = JSON.stringify({
+    type: "approval_state",
+    planId,
+    ownerId: username,
+    approvedUsers: [username],
+    rejectedUsers: []
+  });
+  for (const conn of signalingConns) {
+    const ws = conn.ws;
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(identifyMessage);
+      ws.send(approvalStateMessage);
+      logger.info({ planId, username }, "Pushed identity and approval state to signaling server");
+    }
+  }
+}
+function setupProviderListeners(provider, planId) {
+  provider.on("peers", (event) => {
+    const peerCount = event.webrtcPeers.length;
+    if (event.added.length > 0) {
+      logger.info(
+        {
+          planId,
+          added: event.added,
+          totalPeers: peerCount
+        },
+        "WebRTC peer connected"
+      );
+    }
+    if (event.removed.length > 0) {
+      logger.info(
+        {
+          planId,
+          removed: event.removed,
+          totalPeers: peerCount
+        },
+        "WebRTC peer disconnected"
+      );
+    }
+  });
+  provider.on("synced", (event) => {
+    logger.info(
+      {
+        planId,
+        synced: event.synced
+      },
+      "WebRTC sync status changed"
+    );
+  });
+  provider.on("status", (event) => {
+    logger.info(
+      {
+        planId,
+        connected: event.connected
+      },
+      "WebRTC signaling status changed"
+    );
+  });
+}
+
+// src/doc-store.ts
+var currentMode = "uninitialized";
+var webrtcProviders = /* @__PURE__ */ new Map();
+function initAsHub() {
+  if (currentMode !== "uninitialized") {
+    logger.warn({ currentMode }, "Doc store already initialized");
+    return;
+  }
+  currentMode = "hub";
+  logger.info("Doc store initialized as hub (registry server mode)");
+}
+async function initAsClient(registryPort) {
+  if (currentMode !== "uninitialized") {
+    logger.warn({ currentMode }, "Doc store already initialized");
+    return;
+  }
+  await initHubClient(registryPort);
+  currentMode = "client";
+  logger.info({ registryPort }, "Doc store initialized as client (hub-client mode)");
+}
+async function getOrCreateDoc3(docName) {
+  let doc;
+  switch (currentMode) {
+    case "hub":
+      doc = await getOrCreateDoc2(docName);
+      break;
+    case "client":
+      doc = await getOrCreateDoc(docName);
+      break;
+    case "uninitialized":
+      if (isHubClientInitialized()) {
+        currentMode = "client";
+        doc = await getOrCreateDoc(docName);
+      } else {
+        logger.warn("Doc store not initialized, defaulting to registry server mode");
+        currentMode = "hub";
+        doc = await getOrCreateDoc2(docName);
+      }
+  }
+  if (!webrtcProviders.has(docName)) {
+    try {
+      const provider = await createWebRtcProvider(doc, docName);
+      webrtcProviders.set(docName, provider);
+      logger.info({ docName }, "WebRTC P2P sync enabled for plan");
+    } catch (error) {
+      logger.error({ error, docName }, "Failed to create WebRTC provider - P2P sync unavailable");
+    }
+  }
+  return doc;
+}
+async function hasActiveConnections3(planId) {
+  switch (currentMode) {
+    case "hub":
+      return hasActiveConnections2(planId);
+    case "client":
+      return await hasActiveConnections(planId);
+    case "uninitialized":
+      return false;
+  }
+}
+
+// src/hook-handlers.ts
+async function parseMarkdownToBlocks(markdown) {
+  const editor = ServerBlockNoteEditor.create();
+  return await editor.tryParseMarkdownToBlocks(markdown);
+}
+function extractTitleFromBlocks(blocks) {
+  const UNTITLED = "Untitled Plan";
+  const firstBlock = blocks[0];
+  if (!firstBlock) return UNTITLED;
+  const content = firstBlock.content;
+  if (!content || !Array.isArray(content) || content.length === 0) {
+    return UNTITLED;
+  }
+  const firstContent = content[0];
+  if (!firstContent || typeof firstContent !== "object" || !("text" in firstContent)) {
+    return UNTITLED;
+  }
+  const record = Object.fromEntries(Object.entries(firstContent));
+  const text = record.text;
+  if (typeof text !== "string") {
+    return UNTITLED;
+  }
+  if (firstBlock.type === "heading") {
+    return text;
+  }
+  return text.slice(0, 50);
+}
+async function createSessionHandler(input, ctx) {
+  const existingSession = getSessionState(input.sessionId);
+  if (existingSession) {
+    const url2 = createPlanWebUrl(webConfig.SHIPYARD_WEB_URL, existingSession.planId);
+    ctx.logger.info(
+      { planId: existingSession.planId, sessionId: input.sessionId },
+      "Returning existing session (idempotent)"
+    );
+    return { planId: existingSession.planId, url: url2 };
+  }
+  const planId = nanoid4();
+  const now = Date.now();
+  ctx.logger.info(
+    { planId, sessionId: input.sessionId, agentType: input.agentType },
+    "Creating plan from hook"
+  );
+  const PLAN_IN_PROGRESS = "Plan in progress...";
+  const ownerId = await getGitHubUsername();
+  ctx.logger.info({ ownerId }, "GitHub username for plan ownership");
+  const repo = getRepositoryFullName() || void 0;
+  if (repo) {
+    ctx.logger.info({ repo }, "Auto-detected repository from current directory");
+  }
+  const ydoc = await ctx.getOrCreateDoc(planId);
+  const origin = parseClaudeCodeOrigin(input.metadata) || {
+    platform: "claude-code",
+    sessionId: input.sessionId,
+    transcriptPath: ""
+  };
+  initPlanMetadata(ydoc, {
+    id: planId,
+    title: PLAN_IN_PROGRESS,
+    ownerId,
+    repo,
+    origin
+  });
+  setAgentPresence(ydoc, {
+    agentType: input.agentType ?? "claude-code",
+    sessionId: input.sessionId,
+    connectedAt: now,
+    lastSeenAt: now
+  });
+  if (origin && origin.platform === "claude-code") {
+    const creator = typeof input.metadata?.ownerId === "string" ? input.metadata.ownerId : "unknown";
+    const initialVersion = createInitialConversationVersion({
+      versionId: nanoid4(),
+      creator,
+      platform: origin.platform,
+      sessionId: origin.sessionId,
+      messageCount: 0,
+      createdAt: now
+    });
+    addConversationVersion(ydoc, initialVersion);
+    ctx.logger.info(
+      { planId, versionId: initialVersion.versionId },
+      "Added initial conversation version"
+    );
+  }
+  const indexDoc = await ctx.getOrCreateDoc(PLAN_INDEX_DOC_NAME);
+  setPlanIndexEntry(indexDoc, {
+    id: planId,
+    title: PLAN_IN_PROGRESS,
+    status: "draft",
+    createdAt: now,
+    updatedAt: now,
+    ownerId,
+    deleted: false
+  });
+  const url = createPlanWebUrl(webConfig.SHIPYARD_WEB_URL, planId);
+  ctx.logger.info({ url }, "Plan URL generated");
+  setSessionState(input.sessionId, {
+    lifecycle: "created",
+    planId,
+    createdAt: now,
+    lastSyncedAt: now
+  });
+  ctx.logger.info({ sessionId: input.sessionId, planId }, "Session registered in registry");
+  if (await hasActiveConnections3(PLAN_INDEX_DOC_NAME)) {
+    indexDoc.getMap("navigation").set("target", planId);
+    ctx.logger.info({ url, planId }, "Browser already connected, navigating via CRDT");
+  } else {
+    await open(url);
+    ctx.logger.info({ url }, "Browser launched by server");
+  }
+  return { planId, url };
+}
+async function updateContentHandler(planId, input, ctx) {
+  ctx.logger.info(
+    { planId, contentLength: input.content.length },
+    "Updating plan content from hook"
+  );
+  const ydoc = await ctx.getOrCreateDoc(planId);
+  const metadata = getPlanMetadata(ydoc);
+  if (!metadata) {
+    throw new TRPCError2({
+      code: "NOT_FOUND",
+      message: "Plan not found"
+    });
+  }
+  const blocks = await parseMarkdownToBlocks(input.content);
+  const title = extractTitleFromBlocks(blocks);
+  const now = Date.now();
+  const editor = ServerBlockNoteEditor.create();
+  ydoc.transact(() => {
+    const fragment = ydoc.getXmlFragment("document");
+    while (fragment.length > 0) {
+      fragment.delete(0, 1);
+    }
+    editor.blocksToYXmlFragment(blocks, fragment);
+    const deliverablesArray = ydoc.getArray(YDOC_KEYS.DELIVERABLES);
+    deliverablesArray.delete(0, deliverablesArray.length);
+    const deliverables = extractDeliverables(blocks);
+    for (const deliverable of deliverables) {
+      addDeliverable(ydoc, deliverable);
+    }
+    if (deliverables.length > 0) {
+      ctx.logger.info({ count: deliverables.length }, "Deliverables extracted from hook content");
+    }
+  });
+  setPlanMetadata(ydoc, {
+    title
+  });
+  const indexDoc = await ctx.getOrCreateDoc(PLAN_INDEX_DOC_NAME);
+  if (metadata.ownerId) {
+    setPlanIndexEntry(indexDoc, {
+      id: planId,
+      title,
+      status: metadata.status,
+      createdAt: metadata.createdAt ?? now,
+      updatedAt: now,
+      ownerId: metadata.ownerId,
+      deleted: false
+    });
+  } else {
+    ctx.logger.warn({ planId }, "Cannot update plan index: missing ownerId");
+  }
+  const sessionId = getSessionIdByPlanId(planId);
+  if (sessionId) {
+    const session = getSessionStateByPlanId(planId);
+    if (session) {
+      const contentHash = computeHash(input.content);
+      switch (session.lifecycle) {
+        case "created":
+        case "approved_awaiting_token":
+          setSessionState(sessionId, {
+            ...session,
+            planFilePath: input.filePath
+          });
+          break;
+        case "synced":
+        case "approved":
+        case "reviewed":
+          setSessionState(sessionId, {
+            ...session,
+            contentHash,
+            planFilePath: input.filePath
+          });
+          break;
+        default:
+          assertNever(session);
+      }
+      ctx.logger.info(
+        { planId, sessionId, contentHash, lifecycle: session.lifecycle },
+        "Updated session registry with content hash"
+      );
+    }
+  }
+  ctx.logger.info({ planId, title, blockCount: blocks.length }, "Plan content updated");
+  return { success: true, updatedAt: now };
+}
+async function getReviewStatusHandler(planId, ctx) {
+  const ydoc = await ctx.getOrCreateDoc(planId);
+  const metadata = getPlanMetadata(ydoc);
+  if (!metadata) {
+    throw new TRPCError2({
+      code: "NOT_FOUND",
+      message: "Plan not found"
+    });
+  }
+  switch (metadata.status) {
+    case "draft":
+      return { status: "draft" };
+    case "pending_review":
+      return {
+        status: "pending_review",
+        reviewRequestId: metadata.reviewRequestId
+      };
+    case "changes_requested": {
+      const threadsMap = ydoc.getMap(YDOC_KEYS.THREADS);
+      const threadsData = threadsMap.toJSON();
+      const threads = parseThreads(threadsData);
+      const feedback = threads.map((thread) => ({
+        threadId: thread.id,
+        blockId: thread.selectedText,
+        comments: thread.comments.map((c) => ({
+          author: c.userId ?? "Reviewer",
+          content: typeof c.body === "string" ? c.body : JSON.stringify(c.body),
+          createdAt: c.createdAt ?? Date.now()
+        }))
+      }));
+      return {
+        status: "changes_requested",
+        reviewedAt: metadata.reviewedAt,
+        reviewedBy: metadata.reviewedBy,
+        reviewComment: metadata.reviewComment,
+        feedback: feedback.length > 0 ? feedback : void 0
+      };
+    }
+    case "in_progress":
+      return {
+        status: "in_progress",
+        reviewedAt: metadata.reviewedAt,
+        reviewedBy: metadata.reviewedBy
+      };
+    case "completed":
+      return {
+        status: "completed",
+        completedAt: metadata.completedAt,
+        completedBy: metadata.completedBy,
+        snapshotUrl: metadata.snapshotUrl
+      };
+    default:
+      assertNever(metadata);
+  }
+}
+async function updatePresenceHandler(planId, input, ctx) {
+  const ydoc = await ctx.getOrCreateDoc(planId);
+  const now = Date.now();
+  setAgentPresence(ydoc, {
+    agentType: input.agentType,
+    sessionId: input.sessionId,
+    connectedAt: now,
+    lastSeenAt: now
+  });
+  return { success: true };
+}
+async function setSessionTokenHandler(planId, sessionTokenHash, ctx) {
+  ctx.logger.info({ planId }, "Setting session token from hook");
+  const ydoc = await ctx.getOrCreateDoc(planId);
+  const metadata = getPlanMetadata(ydoc);
+  if (!metadata) {
+    throw new TRPCError2({
+      code: "NOT_FOUND",
+      message: "Plan not found"
+    });
+  }
+  setPlanMetadata(ydoc, {
+    sessionTokenHash
+  });
+  const url = createPlanWebUrl(webConfig.SHIPYARD_WEB_URL, planId);
+  const session = getSessionStateByPlanId(planId);
+  const sessionId = getSessionIdByPlanId(planId);
+  if (session && sessionId) {
+    switch (session.lifecycle) {
+      case "created":
+        setSessionState(sessionId, {
+          lifecycle: "synced",
+          planId: session.planId,
+          planFilePath: session.planFilePath,
+          createdAt: session.createdAt,
+          lastSyncedAt: session.lastSyncedAt,
+          contentHash: "",
+          sessionToken: sessionTokenHash,
+          url
+        });
+        ctx.logger.info({ planId, sessionId }, "Transitioned session to synced state");
+        break;
+      case "approved_awaiting_token":
+        setSessionState(sessionId, {
+          lifecycle: "approved",
+          planId: session.planId,
+          planFilePath: session.planFilePath,
+          createdAt: session.createdAt,
+          lastSyncedAt: session.lastSyncedAt,
+          contentHash: "",
+          sessionToken: sessionTokenHash,
+          url,
+          approvedAt: session.approvedAt,
+          deliverables: session.deliverables,
+          reviewComment: session.reviewComment,
+          reviewedBy: session.reviewedBy
+        });
+        ctx.logger.info(
+          { planId, sessionId },
+          "Transitioned session from approved_awaiting_token to approved"
+        );
+        break;
+      case "synced":
+      case "approved":
+      case "reviewed":
+        setSessionState(sessionId, {
+          ...session,
+          sessionToken: sessionTokenHash,
+          url
+        });
+        ctx.logger.info({ planId, sessionId }, "Updated session token");
+        break;
+      default:
+        assertNever(session);
+    }
+  }
+  ctx.logger.info({ planId }, "Session token set successfully");
+  return { url };
+}
+async function waitForApprovalHandler(planId, _reviewRequestIdParam, ctx) {
+  let ydoc;
+  try {
+    ydoc = await ctx.getOrCreateDoc(planId);
+  } catch (err) {
+    ctx.logger.error({ err, planId }, "Failed to get or create doc for approval waiting");
+    throw err;
+  }
+  const metadata = ydoc.getMap(YDOC_KEYS.METADATA);
+  const planMetadata = getPlanMetadata(ydoc);
+  const ownerId = planMetadata?.ownerId ?? "unknown";
+  let reviewRequestId;
+  if (planMetadata?.status === "pending_review" && planMetadata.reviewRequestId) {
+    reviewRequestId = planMetadata.reviewRequestId;
+    ctx.logger.info(
+      { planId, currentStatus: planMetadata.status, reviewRequestId },
+      "Status already pending_review, reusing existing reviewRequestId for observer"
+    );
+  } else {
+    reviewRequestId = nanoid4();
+    const result = transitionPlanStatus(
+      ydoc,
+      {
+        status: "pending_review",
+        reviewRequestId
+      },
+      ownerId
+    );
+    if (!result.success) {
+      ctx.logger.error({ planId, error: result.error }, "Failed to transition to pending_review");
+    }
+  }
+  ctx.logger.info(
+    { planId, reviewRequestId },
+    "[SERVER OBSERVER] Set reviewRequestId and status, starting observation"
+  );
+  const getReviewData = () => {
+    const meta = getPlanMetadata(ydoc);
+    if (meta?.status === "changes_requested" || meta?.status === "in_progress") {
+      return {
+        reviewComment: meta.reviewComment,
+        reviewedBy: meta.reviewedBy
+      };
+    }
+    return {
+      reviewComment: void 0,
+      reviewedBy: void 0
+    };
+  };
+  const updateSessionRegistry = (status, extraData = {}) => {
+    const sessionData = getSessionData();
+    if (!sessionData) return;
+    const { session, sessionId } = sessionData;
+    validateSessionStateForTransition(session);
+    const baseState = buildBaseState(session);
+    const syncedFields = buildSyncedFields(session);
+    const { reviewComment, reviewedBy } = getReviewData();
+    if (status === "in_progress") {
+      handleApprovedTransition(
+        sessionId,
+        baseState,
+        syncedFields,
+        extraData,
+        reviewComment,
+        reviewedBy
+      );
+    } else if (status === "changes_requested") {
+      handleReviewedTransition(
+        sessionId,
+        baseState,
+        syncedFields,
+        session,
+        extraData,
+        reviewComment,
+        reviewedBy
+      );
+    } else {
+      throw new Error(
+        `Invalid session state transition: missing required fields. status=${status}, hasApprovedAt=${!!extraData.approvedAt}, hasDeliverables=${!!extraData.deliverables}, hasReviewedBy=${!!reviewedBy}`
+      );
+    }
+    logRegistryUpdate(status, extraData);
+  };
+  const getSessionData = () => {
+    const session = getSessionStateByPlanId(planId);
+    const sessionId = getSessionIdByPlanId(planId);
+    if (!session || !sessionId) {
+      ctx.logger.warn(
+        { planId },
+        "Session not found in registry during approval - post-exit injection will not work"
+      );
+      return null;
+    }
+    return { session, sessionId };
+  };
+  const validateSessionStateForTransition = (_session) => {
+  };
+  const buildBaseState = (session) => ({
+    planId: session.planId,
+    planFilePath: session.planFilePath,
+    createdAt: session.createdAt,
+    lastSyncedAt: session.lastSyncedAt
+  });
+  const buildSyncedFields = (session) => {
+    if (isSessionStateSynced(session) || isSessionStateApproved(session) || isSessionStateReviewed(session)) {
+      return {
+        contentHash: session.contentHash,
+        sessionToken: session.sessionToken,
+        url: session.url
+      };
+    }
+    return null;
+  };
+  const handleApprovedTransition = (sessionId, baseState, syncedFields, extraData, reviewComment, reviewedBy) => {
+    if (!extraData.approvedAt || !extraData.deliverables) {
+      throw new Error(
+        `Invalid session state transition: missing required fields for approval. hasApprovedAt=${!!extraData.approvedAt}, hasDeliverables=${!!extraData.deliverables}`
+      );
+    }
+    const webUrl = webConfig.SHIPYARD_WEB_URL;
+    if (syncedFields) {
+      setSessionState(sessionId, {
+        lifecycle: "approved",
+        ...baseState,
+        ...syncedFields,
+        approvedAt: extraData.approvedAt,
+        deliverables: extraData.deliverables,
+        reviewComment,
+        reviewedBy
+      });
+    } else {
+      setSessionState(sessionId, {
+        lifecycle: "approved_awaiting_token",
+        ...baseState,
+        url: createPlanWebUrl(webUrl, baseState.planId),
+        approvedAt: extraData.approvedAt,
+        deliverables: extraData.deliverables,
+        reviewComment,
+        reviewedBy
+      });
+    }
+  };
+  const handleReviewedTransition = (sessionId, baseState, syncedFields, session, extraData, reviewComment, reviewedBy) => {
+    if (!reviewedBy) {
+      throw new Error(`Invalid session state transition: missing reviewedBy for changes_requested`);
+    }
+    const deliverables = extraData.deliverables || (isSessionStateApproved(session) || isSessionStateReviewed(session) || isSessionStateApprovedAwaitingToken(session) ? session.deliverables : []);
+    const webUrl = webConfig.SHIPYARD_WEB_URL;
+    setSessionState(sessionId, {
+      lifecycle: "reviewed",
+      ...baseState,
+      contentHash: syncedFields?.contentHash ?? "",
+      sessionToken: syncedFields?.sessionToken ?? "",
+      url: syncedFields?.url ?? createPlanWebUrl(webUrl, baseState.planId),
+      deliverables,
+      reviewComment: reviewComment || "",
+      reviewedBy,
+      reviewStatus: "changes_requested"
+    });
+  };
+  const logRegistryUpdate = (status, extraData) => {
+    const sessionId = getSessionIdByPlanId(planId);
+    ctx.logger.info(
+      {
+        planId,
+        sessionId,
+        ...extraData.deliverables && { deliverableCount: extraData.deliverables.length }
+      },
+      `Stored ${status === "in_progress" ? "approval" : "rejection"} data in session registry`
+    );
+  };
+  const handleApproved = () => {
+    const deliverables = getDeliverables(ydoc);
+    const deliverableInfos = deliverables.map((d) => ({ id: d.id, text: d.text }));
+    updateSessionRegistry("in_progress", {
+      approvedAt: Date.now(),
+      deliverables: deliverableInfos
+    });
+    const { reviewComment, reviewedBy } = getReviewData();
+    ctx.logger.info(
+      { planId, reviewRequestId, reviewedBy },
+      "[SERVER OBSERVER] Plan approved via Y.Doc - resolving promise"
+    );
+    return {
+      approved: true,
+      deliverables,
+      reviewComment,
+      reviewedBy: reviewedBy || "unknown",
+      status: "in_progress"
+    };
+  };
+  const handleChangesRequested = () => {
+    updateSessionRegistry("changes_requested");
+    const feedback = extractFeedbackFromYDoc(ydoc, ctx);
+    const { reviewComment, reviewedBy } = getReviewData();
+    ctx.logger.info(
+      { planId, reviewRequestId, feedback },
+      "[SERVER OBSERVER] Changes requested via Y.Doc"
+    );
+    return {
+      approved: false,
+      feedback: feedback || "Changes requested",
+      status: "changes_requested",
+      reviewComment,
+      reviewedBy
+    };
+  };
+  return new Promise((resolve2, reject) => {
+    const APPROVAL_TIMEOUT_MS = 30 * 60 * 1e3;
+    let timeout = null;
+    let checkStatus = null;
+    const shouldProcessStatusChange = () => {
+      const currentMeta = getPlanMetadata(ydoc);
+      if (!currentMeta) return false;
+      const currentReviewId = currentMeta.status === "pending_review" ? currentMeta.reviewRequestId : void 0;
+      const status = currentMeta.status;
+      if (currentReviewId !== reviewRequestId && currentMeta.status === "pending_review") {
+        ctx.logger.warn(
+          { planId, expected: reviewRequestId, actual: currentReviewId, status },
+          "[SERVER OBSERVER] Review ID mismatch, ignoring status change"
+        );
+        return false;
+      }
+      const isTerminalState = status === "in_progress" || status === "changes_requested";
+      return isTerminalState;
+    };
+    const cleanupObserver = () => {
+      if (timeout) clearTimeout(timeout);
+      if (checkStatus) metadata.unobserve(checkStatus);
+    };
+    try {
+      timeout = setTimeout(() => {
+        if (checkStatus) {
+          metadata.unobserve(checkStatus);
+        }
+        resolve2({
+          approved: false,
+          feedback: "Review timeout - no decision received in 30 minutes",
+          status: "timeout"
+        });
+      }, APPROVAL_TIMEOUT_MS);
+      checkStatus = () => {
+        const currentMeta = getPlanMetadata(ydoc);
+        const status = currentMeta?.status;
+        const currentReviewId = currentMeta?.status === "pending_review" ? currentMeta.reviewRequestId : void 0;
+        ctx.logger.debug(
+          { planId, status, currentReviewId, expectedReviewId: reviewRequestId },
+          "[SERVER OBSERVER] Metadata changed, checking status"
+        );
+        if (!shouldProcessStatusChange()) return;
+        cleanupObserver();
+        resolve2(status === "in_progress" ? handleApproved() : handleChangesRequested());
+      };
+      ctx.logger.info(
+        { planId, reviewRequestId },
+        "[SERVER OBSERVER] Registering metadata observer"
+      );
+      metadata.observe((event) => {
+        ctx.logger.info(
+          {
+            planId,
+            reviewRequestId,
+            keysChanged: Array.from(event.keysChanged),
+            target: event.target.constructor.name
+          },
+          "[SERVER OBSERVER] *** METADATA MAP CHANGED *** (Raw Y.Map observer)"
+        );
+      });
+      metadata.observe(checkStatus);
+      checkStatus();
+    } catch (err) {
+      if (timeout) clearTimeout(timeout);
+      if (checkStatus) {
+        try {
+          metadata.unobserve(checkStatus);
+        } catch (unobserveErr) {
+          ctx.logger.warn({ err: unobserveErr }, "Failed to unobserve during error cleanup");
+        }
+      }
+      ctx.logger.error({ err, planId }, "Failed to setup approval observer");
+      reject(err);
+    }
+  });
+}
+function extractFeedbackFromYDoc(ydoc, ctx) {
+  try {
+    const planMeta = getPlanMetadata(ydoc);
+    const reviewComment = planMeta?.status === "changes_requested" || planMeta?.status === "in_progress" ? planMeta.reviewComment : void 0;
+    const reviewedBy = planMeta?.status === "changes_requested" || planMeta?.status === "in_progress" ? planMeta.reviewedBy : void 0;
+    const threadsMap = ydoc.getMap(YDOC_KEYS.THREADS);
+    const threadsData = threadsMap.toJSON();
+    const threads = parseThreads(threadsData);
+    if (!reviewComment && threads.length === 0) {
+      return "Changes requested. Check the plan for reviewer comments.";
+    }
+    const contentFragment = ydoc.getXmlFragment(YDOC_KEYS.DOCUMENT_FRAGMENT);
+    const fragmentJson = contentFragment.toJSON();
+    let planText = "";
+    if (Array.isArray(fragmentJson)) {
+      planText = fragmentJson.map((block) => {
+        if (!block || typeof block !== "object") return "";
+        const blockRecord = Object.fromEntries(Object.entries(block));
+        const content = blockRecord.content;
+        if (!Array.isArray(content)) return "";
+        return content.map((item) => {
+          if (!item || typeof item !== "object") return "";
+          const itemRecord = Object.fromEntries(Object.entries(item));
+          const text = itemRecord.text;
+          return typeof text === "string" ? text : "";
+        }).join("");
+      }).filter(Boolean).join("\n");
+    }
+    const resolveUser = createUserResolver(ydoc);
+    const feedbackText = formatThreadsForLLM(threads, {
+      includeResolved: false,
+      selectedTextMaxLength: 100,
+      resolveUser
+    });
+    let output = "Changes requested:\n\n";
+    if (planText) {
+      output += "## Current Plan\n\n";
+      output += planText;
+      output += "\n\n---\n\n";
+    }
+    if (reviewComment) {
+      output += "## Reviewer Comment\n\n";
+      output += `> **${reviewedBy ?? "Reviewer"}:** ${reviewComment}
+`;
+      output += "\n---\n\n";
+    }
+    if (feedbackText) {
+      output += "## Inline Feedback\n\n";
+      output += feedbackText;
+    }
+    const deliverables = getDeliverables(ydoc);
+    const deliverablesText = formatDeliverablesForLLM(deliverables);
+    if (deliverablesText) {
+      output += "\n\n---\n\n";
+      output += deliverablesText;
+    }
+    return output;
+  } catch (err) {
+    ctx.logger.warn({ err }, "Failed to extract feedback from Y.Doc");
+    return "Changes requested. Check the plan for reviewer comments.";
+  }
+}
+async function getDeliverableContextHandler(planId, sessionToken, ctx) {
+  const ydoc = await ctx.getOrCreateDoc(planId);
+  const metadata = getPlanMetadata(ydoc);
+  if (!metadata) {
+    throw new TRPCError2({
+      code: "NOT_FOUND",
+      message: "Plan not found"
+    });
+  }
+  const deliverables = getDeliverables(ydoc);
+  const url = createPlanWebUrl(webConfig.SHIPYARD_WEB_URL, planId);
+  let deliverablesSection = "";
+  if (deliverables.length > 0) {
+    deliverablesSection = `
+## Deliverables
+
+Attach proof to each deliverable using add_artifact:
+
+`;
+    for (const d of deliverables) {
+      deliverablesSection += `- ${d.text}
+  deliverableId="${d.id}"
+`;
+    }
+  } else {
+    deliverablesSection = `
+## Deliverables
+
+No deliverables marked in this plan. You can still upload artifacts without linking them.`;
+  }
+  let feedbackSection = "";
+  if (metadata.status === "changes_requested" && metadata.reviewComment?.trim()) {
+    feedbackSection = `
+## Reviewer Feedback
+
+${metadata.reviewedBy ? `**From:** ${metadata.reviewedBy}
+
+` : ""}${metadata.reviewComment}
+
+`;
+  }
+  const approvalMessage = metadata.status === "changes_requested" ? "[SHIPYARD] Changes requested on your plan \u26A0\uFE0F" : "[SHIPYARD] Plan approved! \u{1F389}";
+  const context = `${approvalMessage}
+${deliverablesSection}${feedbackSection}
+## Session Info
+
+planId="${planId}"
+sessionToken="${sessionToken}"
+url="${url}"
+
+## How to Attach Proof
+
+For each deliverable above, call:
+\`\`\`
+add_artifact(
+  planId="${planId}",
+  sessionToken="${sessionToken}",
+  type="image",
+  filePath="/path/to/file.png",
+  deliverableId="<id from above>"
+)
+\`\`\`
+
+When the LAST deliverable gets an artifact, the task auto-completes and returns a snapshot URL for your PR.`;
+  return { context };
+}
+async function getSessionContextHandler(sessionId, ctx) {
+  ctx.logger.info({ sessionId }, "Getting session context for post-exit injection");
+  const sessionState = getSessionState(sessionId);
+  if (!sessionState) {
+    ctx.logger.warn({ sessionId }, "Session not found in registry");
+    return { found: false };
+  }
+  if (isSessionStateApproved(sessionState)) {
+    ctx.logger.info(
+      { sessionId, planId: sessionState.planId },
+      "Session context retrieved (approved state, idempotent)"
+    );
+    return {
+      found: true,
+      planId: sessionState.planId,
+      sessionToken: sessionState.sessionToken,
+      url: sessionState.url,
+      deliverables: sessionState.deliverables,
+      reviewComment: sessionState.reviewComment,
+      reviewedBy: sessionState.reviewedBy
+    };
+  }
+  if (isSessionStateReviewed(sessionState)) {
+    ctx.logger.info(
+      { sessionId, planId: sessionState.planId },
+      "Session context retrieved (reviewed state, idempotent)"
+    );
+    return {
+      found: true,
+      planId: sessionState.planId,
+      sessionToken: sessionState.sessionToken,
+      url: sessionState.url,
+      deliverables: sessionState.deliverables,
+      reviewComment: sessionState.reviewComment,
+      reviewedBy: sessionState.reviewedBy,
+      reviewStatus: sessionState.reviewStatus
+    };
+  }
+  ctx.logger.warn(
+    { sessionId, lifecycle: sessionState.lifecycle },
+    "Session not ready for post-exit injection"
+  );
+  return { found: false };
+}
+function createHookHandlers() {
+  return {
+    createSession: (input, ctx) => createSessionHandler(input, ctx),
+    updateContent: (planId, input, ctx) => updateContentHandler(planId, input, ctx),
+    getReviewStatus: (planId, ctx) => getReviewStatusHandler(planId, ctx),
+    updatePresence: (planId, input, ctx) => updatePresenceHandler(planId, input, ctx),
+    setSessionToken: (planId, sessionTokenHash, ctx) => setSessionTokenHandler(planId, sessionTokenHash, ctx),
+    waitForApproval: (planId, reviewRequestId, ctx) => waitForApprovalHandler(planId, reviewRequestId, ctx),
+    getDeliverableContext: (planId, sessionToken, ctx) => getDeliverableContextHandler(planId, sessionToken, ctx),
+    getSessionContext: (sessionId, ctx) => getSessionContextHandler(sessionId, ctx)
+  };
+}
+
+// src/subscriptions/manager.ts
+import { nanoid as nanoid5 } from "nanoid";
+var subscriptions = /* @__PURE__ */ new Map();
+var SUBSCRIPTION_TTL_MS = 5 * 60 * 1e3;
+function createSubscription(config) {
+  const id = nanoid5();
+  const now = Date.now();
+  const subscription = {
+    id,
+    config,
+    pendingChanges: [],
+    windowStartedAt: null,
+    lastFlushedAt: now,
+    lastActivityAt: now,
+    ready: false
+  };
+  let planSubs = subscriptions.get(config.planId);
+  if (!planSubs) {
+    planSubs = /* @__PURE__ */ new Map();
+    subscriptions.set(config.planId, planSubs);
+  }
+  planSubs.set(id, subscription);
+  logger.info(
+    { planId: config.planId, subscriptionId: id, subscribe: config.subscribe },
+    "Subscription created"
+  );
+  return id;
+}
+function deleteSubscription(planId, subscriptionId) {
+  const deleted = subscriptions.get(planId)?.delete(subscriptionId) ?? false;
+  if (deleted) {
+    logger.info({ planId, subscriptionId }, "Subscription deleted");
+    if (subscriptions.get(planId)?.size === 0) {
+      subscriptions.delete(planId);
+    }
+  }
+  return deleted;
+}
+function notifyChange(planId, change) {
+  const planSubs = subscriptions.get(planId);
+  if (!planSubs) return;
+  const now = Date.now();
+  for (const sub of planSubs.values()) {
+    if (!sub.config.subscribe.includes(change.type)) continue;
+    sub.pendingChanges.push(change);
+    sub.lastActivityAt = now;
+    if (sub.windowStartedAt === null) {
+      sub.windowStartedAt = now;
+    }
+    checkFlushConditions(sub);
+  }
+  logger.debug(
+    { planId, changeType: change.type, subscriberCount: planSubs.size },
+    "Change notified"
+  );
+}
+function getChanges(planId, subscriptionId) {
+  const sub = subscriptions.get(planId)?.get(subscriptionId);
+  if (!sub) return null;
+  const now = Date.now();
+  sub.lastActivityAt = now;
+  checkFlushConditions(sub);
+  if (!sub.ready) {
+    return {
+      ready: false,
+      pending: sub.pendingChanges.length,
+      windowExpiresIn: sub.windowStartedAt ? Math.max(0, sub.config.windowMs - (now - sub.windowStartedAt)) : sub.config.windowMs
+    };
+  }
+  const changes = sub.pendingChanges;
+  const summary = summarizeChanges(changes);
+  sub.pendingChanges = [];
+  sub.windowStartedAt = null;
+  sub.lastFlushedAt = now;
+  sub.ready = false;
+  logger.debug({ planId, subscriptionId, changeCount: changes.length }, "Changes flushed");
+  return {
+    ready: true,
+    changes: summary,
+    details: changes
+  };
+}
+function startCleanupInterval() {
+  startPeriodicCleanup();
+  setInterval(() => {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [planId, planSubs] of subscriptions.entries()) {
+      for (const [subId, sub] of planSubs.entries()) {
+        if (now - sub.lastActivityAt > SUBSCRIPTION_TTL_MS) {
+          planSubs.delete(subId);
+          cleanedCount++;
+        }
+      }
+      if (planSubs.size === 0) {
+        subscriptions.delete(planId);
+      }
+    }
+    if (cleanedCount > 0) {
+      logger.info({ cleanedCount }, "Cleaned up stale subscriptions");
+    }
+  }, 6e4);
+}
+function checkFlushConditions(sub) {
+  const now = Date.now();
+  const { windowMs, maxWindowMs, threshold } = sub.config;
+  if (sub.pendingChanges.length >= threshold) {
+    sub.ready = true;
+    return;
+  }
+  if (sub.windowStartedAt && now - sub.windowStartedAt >= windowMs) {
+    sub.ready = true;
+    return;
+  }
+  if (now - sub.lastFlushedAt >= maxWindowMs && sub.pendingChanges.length > 0) {
+    sub.ready = true;
+  }
+}
+function summarizeChanges(changes) {
+  const parts = [];
+  const statusChanges = changes.filter((c) => c.type === "status");
+  if (statusChanges.length > 0) {
+    const latest = statusChanges[statusChanges.length - 1];
+    if (latest) {
+      parts.push(`Status: ${latest.details?.newValue}`);
+    }
+  }
+  const commentChanges = changes.filter((c) => c.type === "comments");
+  if (commentChanges.length > 0) {
+    const totalAdded = commentChanges.reduce((acc, c) => {
+      const added = c.details?.added;
+      return acc + (typeof added === "number" ? added : 1);
+    }, 0);
+    parts.push(`${totalAdded} new comment(s)`);
+  }
+  const resolvedChanges = changes.filter((c) => c.type === "resolved");
+  if (resolvedChanges.length > 0) {
+    const totalResolved = resolvedChanges.reduce((acc, c) => {
+      const resolved = c.details?.resolved;
+      return acc + (typeof resolved === "number" ? resolved : 1);
+    }, 0);
+    parts.push(`${totalResolved} resolved`);
+  }
+  const contentChanges = changes.filter((c) => c.type === "content");
+  if (contentChanges.length > 0) {
+    parts.push("Content updated");
+  }
+  const artifactChanges = changes.filter((c) => c.type === "artifacts");
+  if (artifactChanges.length > 0) {
+    const totalAdded = artifactChanges.reduce((acc, c) => {
+      const added = c.details?.added;
+      return acc + (typeof added === "number" ? added : 1);
+    }, 0);
+    parts.push(`${totalAdded} artifact(s) added`);
+  }
+  return parts.join(" | ") || "No changes";
+}
+
+// src/subscriptions/observers.ts
+var previousState = /* @__PURE__ */ new Map();
+var lastContentEdit = /* @__PURE__ */ new Map();
+var CONTENT_EDIT_DEBOUNCE_MS = 5e3;
+function attachObservers(planId, doc) {
+  const metadata = getPlanMetadata(doc);
+  const threadsMap = doc.getMap(YDOC_KEYS.THREADS);
+  const threads = parseThreads(threadsMap.toJSON());
+  const deliverables = getDeliverables(doc);
+  const allFulfilled = deliverables.length > 0 && deliverables.every((d) => d.linkedArtifactId);
+  const initialCommentIds = /* @__PURE__ */ new Set();
+  for (const thread of threads) {
+    for (const comment of thread.comments) {
+      initialCommentIds.add(comment.id);
+    }
+  }
+  previousState.set(planId, {
+    status: metadata?.status,
+    commentCount: threads.reduce((acc, t2) => acc + t2.comments.length, 0),
+    resolvedCount: threads.filter((t2) => t2.resolved).length,
+    contentLength: doc.getXmlFragment("document").length,
+    artifactCount: doc.getArray(YDOC_KEYS.ARTIFACTS).length,
+    deliverablesFulfilled: allFulfilled,
+    commentIds: initialCommentIds
+  });
+  logger.debug({ planId }, "Attached observers to plan");
+  doc.getMap(YDOC_KEYS.METADATA).observe((event, transaction) => {
+    if (event.keysChanged.has("status")) {
+      let isValidStatus2 = function(s) {
+        return typeof s === "string" && (s === "draft" || s === "pending_review" || s === "changes_requested" || s === "in_progress" || s === "completed");
+      };
+      var isValidStatus = isValidStatus2;
+      const prev = previousState.get(planId);
+      const rawStatus = doc.getMap(YDOC_KEYS.METADATA).get("status");
+      const newStatus = isValidStatus2(rawStatus) ? rawStatus : void 0;
+      if (prev?.status && prev.status !== newStatus && newStatus) {
+        const actor = transaction.origin?.actor || "System";
+        logPlanEvent(doc, "status_changed", actor, {
+          fromStatus: prev.status,
+          toStatus: newStatus
+        });
+        const change = {
+          type: "status",
+          timestamp: Date.now(),
+          summary: `Status changed to ${newStatus}`,
+          details: { oldValue: prev.status, newValue: newStatus }
+        };
+        notifyChange(planId, change);
+        prev.status = newStatus;
+        logger.debug({ planId, oldStatus: prev.status, newStatus }, "Status change detected");
+      }
+    }
+  });
+  doc.getMap(YDOC_KEYS.THREADS).observeDeep((_events, transaction) => {
+    const prev = previousState.get(planId);
+    if (!prev) return;
+    const actor = transaction.origin?.actor || "System";
+    const threadsMap2 = doc.getMap(YDOC_KEYS.THREADS);
+    const threads2 = parseThreads(threadsMap2.toJSON());
+    handleNewComments(doc, planId, threads2, prev, actor);
+    handleResolvedComments(doc, planId, threads2, prev, actor);
+  });
+  doc.getXmlFragment("document").observeDeep((_events, transaction) => {
+    const now = Date.now();
+    const lastEdit = lastContentEdit.get(planId) || 0;
+    if (now - lastEdit > CONTENT_EDIT_DEBOUNCE_MS) {
+      const actor = transaction.origin?.actor || "System";
+      logPlanEvent(doc, "content_edited", actor);
+      lastContentEdit.set(planId, now);
+    }
+    notifyChange(planId, {
+      type: "content",
+      timestamp: Date.now(),
+      summary: "Content updated"
+    });
+    logger.debug({ planId }, "Content change detected");
+  });
+  doc.getArray(YDOC_KEYS.ARTIFACTS).observe((_event, transaction) => {
+    const prev = previousState.get(planId);
+    if (!prev) return;
+    const actor = transaction.origin?.actor || "System";
+    const newCount = doc.getArray(YDOC_KEYS.ARTIFACTS).length;
+    if (newCount > prev.artifactCount) {
+      const diff = newCount - prev.artifactCount;
+      const artifacts = doc.getArray(YDOC_KEYS.ARTIFACTS).toArray();
+      const lastArtifact = artifacts[artifacts.length - 1];
+      const artifactId = lastArtifact && typeof lastArtifact === "object" && "id" in lastArtifact ? String(lastArtifact.id) : "unknown";
+      logPlanEvent(doc, "artifact_uploaded", actor, {
+        artifactId
+      });
+      notifyChange(planId, {
+        type: "artifacts",
+        timestamp: Date.now(),
+        summary: `${diff} artifact(s) added`,
+        details: { added: diff }
+      });
+      prev.artifactCount = newCount;
+      logger.debug({ planId, added: diff }, "Artifacts added detected");
+    }
+  });
+  doc.getArray(YDOC_KEYS.DELIVERABLES).observeDeep((_events, transaction) => {
+    const prev = previousState.get(planId);
+    if (!prev) return;
+    const deliverables2 = getDeliverables(doc);
+    const allFulfilled2 = deliverables2.length > 0 && deliverables2.every((d) => d.linkedArtifactId);
+    if (allFulfilled2 && !prev.deliverablesFulfilled) {
+      const actor = transaction.origin?.actor || "System";
+      logPlanEvent(
+        doc,
+        "deliverable_linked",
+        actor,
+        {
+          allFulfilled: true
+        },
+        {
+          inboxWorthy: true,
+          inboxFor: "owner"
+        }
+      );
+      prev.deliverablesFulfilled = true;
+      logger.debug({ planId }, "All deliverables fulfilled - inbox-worthy event logged");
+    }
+  });
+}
+function detectNewComments(threads, prevCommentIds) {
+  const newComments = [];
+  for (const thread of threads) {
+    for (const comment of thread.comments) {
+      if (!prevCommentIds.has(comment.id)) {
+        newComments.push(comment);
+      }
+    }
+  }
+  return newComments;
+}
+function logCommentWithMentions(doc, planId, comment, actor) {
+  const mentions = extractMentions(comment.body);
+  const hasMentions = mentions.length > 0;
+  logPlanEvent(
+    doc,
+    "comment_added",
+    actor,
+    { commentId: comment.id, mentions: hasMentions },
+    {
+      inboxWorthy: hasMentions,
+      inboxFor: hasMentions ? mentions : void 0
+    }
+  );
+  if (hasMentions) {
+    logger.debug(
+      { planId, commentId: comment.id, mentions },
+      "Comment with @mentions logged as inbox-worthy"
+    );
+  }
+}
+function handleNewComments(doc, planId, threads, prev, actor) {
+  const newCommentCount = threads.reduce((acc, t2) => acc + t2.comments.length, 0);
+  if (newCommentCount <= prev.commentCount) return;
+  const diff = newCommentCount - prev.commentCount;
+  const newComments = detectNewComments(threads, prev.commentIds);
+  for (const comment of newComments) {
+    prev.commentIds.add(comment.id);
+    logCommentWithMentions(doc, planId, comment, actor);
+  }
+  notifyChange(planId, {
+    type: "comments",
+    timestamp: Date.now(),
+    summary: `${diff} new comment(s)`,
+    details: { added: diff }
+  });
+  prev.commentCount = newCommentCount;
+  logger.debug({ planId, added: diff }, "New comments detected");
+}
+function handleResolvedComments(doc, planId, threads, prev, actor) {
+  const newResolvedCount = threads.filter((t2) => t2.resolved).length;
+  if (newResolvedCount <= prev.resolvedCount) return;
+  const diff = newResolvedCount - prev.resolvedCount;
+  logPlanEvent(doc, "comment_resolved", actor, { resolvedCount: diff });
+  notifyChange(planId, {
+    type: "resolved",
+    timestamp: Date.now(),
+    summary: `${diff} comment(s) resolved`,
+    details: { resolved: diff }
+  });
+  prev.resolvedCount = newResolvedCount;
+  logger.debug({ planId, resolved: diff }, "Comments resolved detected");
+}
+
+// src/registry-server.ts
+function getParam(value) {
+  if (Array.isArray(value)) return value[0];
+  return value;
+}
+function getErrorStatus2(error) {
+  if (!error || typeof error !== "object") return 500;
+  const record = Object.fromEntries(Object.entries(error));
+  const status = record.status;
+  return typeof status === "number" ? status : 500;
+}
+var PERSISTENCE_DIR = join4(homedir3(), ".shipyard", "plans");
+var HUB_LOCK_FILE = join4(homedir3(), ".shipyard", "hub.lock");
+var SHIPYARD_DIR = join4(homedir3(), ".shipyard");
+var MAX_LOCK_RETRIES = 3;
+var messageSync = 0;
+var messageAwareness = 1;
+var docs2 = /* @__PURE__ */ new Map();
+var awarenessMap = /* @__PURE__ */ new Map();
+var conns = /* @__PURE__ */ new Map();
+var ldb = null;
+async function readLockHolderPid() {
+  try {
+    const content = await readFile(HUB_LOCK_FILE, "utf-8");
+    const pidStr = content.split("\n")[0] ?? "";
+    return Number.parseInt(pidStr, 10);
+  } catch (readErr) {
+    logger.error({ err: readErr }, "Failed to read hub lock file");
+    return null;
+  }
+}
+function isLockHolderAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function tryRemoveStaleLock(stalePid, retryCount) {
+  logger.warn({ stalePid, retryCount }, "Removing stale hub lock");
+  try {
+    await unlink(HUB_LOCK_FILE);
+    return true;
+  } catch (unlinkErr) {
+    logger.error({ err: unlinkErr, stalePid, retryCount }, "Failed to remove stale hub lock");
+    return false;
+  }
+}
+function registerLockCleanupHandler() {
+  process.once("exit", () => {
+    try {
+      unlinkSync(HUB_LOCK_FILE);
+    } catch {
+    }
+  });
+}
+async function handleExistingLock(retryCount) {
+  const pid = await readLockHolderPid();
+  if (pid === null) return false;
+  if (isLockHolderAlive(pid)) {
+    logger.debug({ holderPid: pid }, "Hub lock held by active process");
+    return false;
+  }
+  if (retryCount >= MAX_LOCK_RETRIES) {
+    logger.error(
+      { stalePid: pid, retryCount },
+      "Max retries exceeded while removing stale hub lock"
+    );
+    return false;
+  }
+  await tryRemoveStaleLock(pid, retryCount);
+  return tryAcquireHubLock(retryCount + 1);
+}
+async function tryAcquireHubLock(retryCount = 0) {
+  try {
+    mkdirSync(SHIPYARD_DIR, { recursive: true });
+    await writeFile2(HUB_LOCK_FILE, `${process.pid}
+${Date.now()}`, { flag: "wx" });
+    registerLockCleanupHandler();
+    logger.info({ pid: process.pid }, "Acquired hub lock");
+    return true;
+  } catch (err) {
+    if (hasErrorCode(err, "EEXIST")) {
+      return handleExistingLock(retryCount);
+    }
+    logger.error({ err }, "Failed to acquire hub lock");
+    return false;
+  }
+}
+async function releaseHubLock() {
+  try {
+    await unlink(HUB_LOCK_FILE);
+    logger.info("Released hub lock");
+  } catch (err) {
+    logger.debug({ err }, "Hub lock already released");
+  }
+}
+function isLevelDbLockError(error) {
+  return error.message?.includes("LOCK") || error.message?.includes("lock");
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tryRecoverStaleLock(originalError) {
+  const lockFile = join4(PERSISTENCE_DIR, "LOCK");
+  try {
+    const hubLockContent = readFileSync2(HUB_LOCK_FILE, "utf-8");
+    const pidStr = hubLockContent.split("\n")[0] ?? "";
+    const pid = Number.parseInt(pidStr, 10);
+    if (isProcessAlive(pid)) {
+      logger.error({ holderPid: pid }, "LevelDB locked by active process, cannot recover");
+      throw originalError;
+    }
+    logger.warn("Hub process dead, removing stale LevelDB lock");
+    unlinkSync(lockFile);
+    return true;
+  } catch (hubLockErr) {
+    if (hubLockErr === originalError) {
+      throw hubLockErr;
+    }
+    logger.warn("No hub.lock found, assuming LevelDB lock is stale");
+    unlinkSync(lockFile);
+    return true;
+  }
+}
+function initPersistence() {
+  if (ldb) return;
+  mkdirSync(PERSISTENCE_DIR, { recursive: true });
+  try {
+    ldb = new LeveldbPersistence(PERSISTENCE_DIR);
+    logger.info({ dir: PERSISTENCE_DIR }, "LevelDB persistence initialized");
+    return;
+  } catch (err) {
+    if (!(err instanceof Error)) {
+      logger.error({ err }, "Failed to initialize LevelDB persistence with unknown error");
+      throw new Error(String(err));
+    }
+    if (!isLevelDbLockError(err)) {
+      logger.error({ err }, "Failed to initialize LevelDB persistence");
+      throw err;
+    }
+    logger.warn({ err }, "LevelDB locked, checking for stale lock");
+    tryRecoverStaleLock(err);
+    ldb = new LeveldbPersistence(PERSISTENCE_DIR);
+    logger.info("Recovered from stale LevelDB lock");
+  }
+}
+async function getDoc(docName) {
+  initPersistence();
+  const persistence = ldb;
+  if (!persistence) {
+    throw new Error("LevelDB persistence failed to initialize");
+  }
+  let doc = docs2.get(docName);
+  if (!doc) {
+    doc = new Y4.Doc();
+    const persistedDoc = await persistence.getYDoc(docName);
+    const state = Y4.encodeStateAsUpdate(persistedDoc);
+    Y4.applyUpdate(doc, state);
+    doc.on("update", (update) => {
+      persistence.storeUpdate(docName, update);
+    });
+    docs2.set(docName, doc);
+    const awareness = new awarenessProtocol.Awareness(doc);
+    awarenessMap.set(docName, awareness);
+    attachObservers(docName, doc);
+    attachCRDTValidation(docName, doc);
+  }
+  return doc;
+}
+async function getOrCreateDoc2(docName) {
+  return getDoc(docName);
+}
+function hasActiveConnections2(planId) {
+  const connections = conns.get(planId);
+  return connections !== void 0 && connections.size > 0;
+}
+function send(ws, message) {
+  if (ws.readyState === ws.OPEN) {
+    ws.send(message);
+  }
+}
+function broadcastUpdate(docName, update, origin) {
+  const docConns = conns.get(docName);
+  if (!docConns) return;
+  const encoder = encoding.createEncoder();
+  encoding.writeVarUint(encoder, messageSync);
+  syncProtocol.writeUpdate(encoder, update);
+  const message = encoding.toUint8Array(encoder);
+  for (const conn of docConns) {
+    if (conn !== origin) {
+      send(conn, message);
+    }
+  }
+}
+function processMessage(message, doc, awareness, planId, ws) {
+  try {
+    const decoder = decoding.createDecoder(new Uint8Array(message));
+    const messageType = decoding.readVarUint(decoder);
+    switch (messageType) {
+      case messageSync: {
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, messageSync);
+        syncProtocol.readSyncMessage(decoder, encoder, doc, ws);
+        if (encoding.length(encoder) > 1) {
+          send(ws, encoding.toUint8Array(encoder));
+        }
+        break;
+      }
+      case messageAwareness: {
+        awarenessProtocol.applyAwarenessUpdate(awareness, decoding.readVarUint8Array(decoder), ws);
+        break;
+      }
+    }
+  } catch (err) {
+    logger.error({ err, planId }, "Failed to process message");
+  }
+}
+function handleWebSocketConnection(ws, req) {
+  const planId = req.url?.slice(1) || "default";
+  logger.info({ planId }, "WebSocket client connected to registry");
+  const pendingMessages = [];
+  let docReady = false;
+  let doc;
+  let awareness;
+  ws.on("message", (message) => {
+    if (!docReady) {
+      pendingMessages.push(message);
+      logger.debug(
+        { planId, bufferedCount: pendingMessages.length },
+        "Buffering message (doc not ready)"
+      );
+      return;
+    }
+    processMessage(message, doc, awareness, planId, ws);
+  });
+  ws.on("error", (err) => {
+    logger.error({ err, planId }, "WebSocket error");
+  });
+  (async () => {
+    try {
+      doc = await getDoc(planId);
+      const awarenessResult = awarenessMap.get(planId);
+      if (!awarenessResult) {
+        throw new Error(`Awareness not found for planId: ${planId}`);
+      }
+      awareness = awarenessResult;
+      logger.debug({ planId }, "Got doc and awareness");
+      if (!conns.has(planId)) {
+        conns.set(planId, /* @__PURE__ */ new Set());
+      }
+      const planConns = conns.get(planId);
+      planConns?.add(ws);
+      const updateHandler = (update, origin) => {
+        broadcastUpdate(planId, update, origin);
+      };
+      doc.on("update", updateHandler);
+      const awarenessHandler = ({ added, updated, removed }, _origin) => {
+        const changedClients = added.concat(updated, removed);
+        const encoder2 = encoding.createEncoder();
+        encoding.writeVarUint(encoder2, messageAwareness);
+        encoding.writeVarUint8Array(
+          encoder2,
+          awarenessProtocol.encodeAwarenessUpdate(awareness, changedClients)
+        );
+        const message = encoding.toUint8Array(encoder2);
+        for (const conn of conns.get(planId) || []) {
+          send(conn, message);
+        }
+      };
+      awareness.on("update", awarenessHandler);
+      docReady = true;
+      if (pendingMessages.length > 0) {
+        logger.debug({ planId, count: pendingMessages.length }, "Processing buffered messages");
+        for (const msg of pendingMessages) {
+          processMessage(msg, doc, awareness, planId, ws);
+        }
+        pendingMessages.length = 0;
+      }
+      const encoder = encoding.createEncoder();
+      encoding.writeVarUint(encoder, messageSync);
+      syncProtocol.writeSyncStep1(encoder, doc);
+      send(ws, encoding.toUint8Array(encoder));
+      const awarenessStates = awareness.getStates();
+      if (awarenessStates.size > 0) {
+        const awarenessEncoder = encoding.createEncoder();
+        encoding.writeVarUint(awarenessEncoder, messageAwareness);
+        encoding.writeVarUint8Array(
+          awarenessEncoder,
+          awarenessProtocol.encodeAwarenessUpdate(awareness, Array.from(awarenessStates.keys()))
+        );
+        send(ws, encoding.toUint8Array(awarenessEncoder));
+      }
+      ws.on("close", () => {
+        logger.info({ planId }, "WebSocket client disconnected from registry");
+        doc.off("update", updateHandler);
+        awareness.off("update", awarenessHandler);
+        conns.get(planId)?.delete(ws);
+        awarenessProtocol.removeAwarenessStates(awareness, [doc.clientID], null);
+      });
+    } catch (err) {
+      logger.error({ err, planId }, "Error handling WebSocket connection");
+      ws.close();
+    }
+  })();
+}
+async function handleHealthCheck(_req, res) {
+  res.json({ status: "ok" });
+}
+async function handleGetPRDiff(req, res) {
+  const planId = getParam(req.params.id);
+  const prNumber = getParam(req.params.prNumber);
+  if (!planId || !prNumber) {
+    res.status(400).json({ error: "Missing plan ID or PR number" });
+    return;
+  }
+  try {
+    const doc = await getOrCreateDoc2(planId);
+    const metadata = getPlanMetadata(doc);
+    if (!metadata || !metadata.repo) {
+      res.status(404).json({ error: "Plan not found or repo not set" });
+      return;
+    }
+    const octokit = getOctokit();
+    if (!octokit) {
+      res.status(500).json({ error: "GitHub authentication not configured" });
+      return;
+    }
+    const { owner, repoName } = parseRepoString(metadata.repo);
+    const prNum = Number.parseInt(prNumber, 10);
+    const response = await octokit.request("GET /repos/{owner}/{repo}/pulls/{pull_number}", {
+      owner,
+      repo: repoName,
+      pull_number: prNum,
+      headers: {
+        accept: "application/vnd.github.diff"
+      }
+    });
+    res.type("text/plain").send(response.data);
+    logger.debug({ planId, prNumber: prNum, repo: metadata.repo }, "Served PR diff");
+  } catch (error) {
+    logger.error({ error, planId, prNumber }, "Failed to fetch PR diff");
+    const status = getErrorStatus2(error);
+    res.status(status).json({ error: "Failed to fetch PR diff" });
+  }
+}
+async function handleGetPRFiles(req, res) {
+  const planId = getParam(req.params.id);
+  const prNumber = getParam(req.params.prNumber);
+  if (!planId || !prNumber) {
+    res.status(400).json({ error: "Missing plan ID or PR number" });
+    return;
+  }
+  try {
+    const doc = await getOrCreateDoc2(planId);
+    const metadata = getPlanMetadata(doc);
+    if (!metadata || !metadata.repo) {
+      res.status(404).json({ error: "Plan not found or repo not set" });
+      return;
+    }
+    const octokit = getOctokit();
+    if (!octokit) {
+      res.status(500).json({ error: "GitHub authentication not configured" });
+      return;
+    }
+    const { owner, repoName } = parseRepoString(metadata.repo);
+    const prNum = Number.parseInt(prNumber, 10);
+    const { data: files } = await octokit.pulls.listFiles({
+      owner,
+      repo: repoName,
+      pull_number: prNum
+    });
+    const fileList = files.map((file) => ({
+      filename: file.filename,
+      status: file.status,
+      additions: file.additions,
+      deletions: file.deletions,
+      changes: file.changes,
+      patch: file.patch
+    }));
+    res.json({ files: fileList });
+    logger.debug({ planId, prNumber: prNum, fileCount: fileList.length }, "Served PR files");
+  } catch (error) {
+    logger.error({ error, planId, prNumber }, "Failed to fetch PR files");
+    const status = getErrorStatus2(error);
+    res.status(status).json({ error: "Failed to fetch PR files" });
+  }
+}
+async function handleGetTranscript(req, res) {
+  const planId = getParam(req.params.id);
+  if (!planId) {
+    res.status(400).json({ error: "Missing plan ID" });
+    return;
+  }
+  try {
+    const doc = await getOrCreateDoc2(planId);
+    const metadata = getPlanMetadata(doc);
+    if (!metadata?.origin) {
+      res.status(404).json({ error: "Plan has no origin metadata" });
+      return;
+    }
+    if (metadata.origin.platform !== "claude-code") {
+      res.status(400).json({ error: "Transcript only available for Claude Code plans" });
+      return;
+    }
+    const originRecord = Object.fromEntries(Object.entries(metadata.origin));
+    const transcriptPath = originRecord.transcriptPath;
+    if (typeof transcriptPath !== "string" || !transcriptPath) {
+      res.status(404).json({ error: "No transcript path in origin metadata" });
+      return;
+    }
+    const content = await readFile(transcriptPath, "utf-8");
+    res.type("text/plain").send(content);
+    logger.debug({ planId, transcriptPath, size: content.length }, "Served transcript for handoff");
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      res.status(404).json({ error: "Transcript file not found" });
+    } else {
+      logger.error({ error, planId }, "Failed to read transcript");
+      res.status(500).json({ error: "Failed to read transcript" });
+    }
+  }
+}
+function createPlanStore() {
+  return {
+    createSubscription: (params) => {
+      const subscribe = params.subscribe.filter(
+        (s) => s === "status" || s === "comments" || s === "resolved" || s === "content" || s === "artifacts"
+      );
+      return createSubscription({
+        planId: params.planId,
+        subscribe,
+        windowMs: params.windowMs,
+        maxWindowMs: params.maxWindowMs,
+        threshold: params.threshold
+      });
+    },
+    getChanges: (planId, clientId) => getChanges(planId, clientId),
+    deleteSubscription: (planId, clientId) => deleteSubscription(planId, clientId),
+    hasActiveConnections: async (planId) => hasActiveConnections2(planId)
+  };
+}
+function createContext() {
+  return {
+    getOrCreateDoc: getOrCreateDoc2,
+    getPlanStore: createPlanStore,
+    logger,
+    hookHandlers: createHookHandlers(),
+    conversationHandlers: createConversationHandlers(),
+    getLocalChanges,
+    getFileContent
+  };
+}
+function createApp() {
+  const app = express();
+  const httpServer = http.createServer(app);
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    next();
+  });
+  app.options("{*splat}", (_req, res) => {
+    res.sendStatus(204);
+  });
+  app.use(express.json({ limit: "10mb" }));
+  app.use(
+    "/trpc",
+    createExpressMiddleware({
+      router: appRouter,
+      createContext
+    })
+  );
+  app.get("/registry", handleHealthCheck);
+  app.get("/api/plan/:planId/has-connections", (req, res) => {
+    const planId = req.params.planId;
+    if (!planId) {
+      res.status(400).json({ error: "Missing plan ID" });
+      return;
+    }
+    const hasConnections = hasActiveConnections2(planId);
+    res.json({ hasConnections });
+  });
+  app.get("/api/plan/:id/transcript", handleGetTranscript);
+  app.get("/api/plans/:id/pr-diff/:prNumber", handleGetPRDiff);
+  app.get("/api/plans/:id/pr-files/:prNumber", handleGetPRFiles);
+  app.get("/artifacts/:planId/:filename", async (req, res) => {
+    const planId = getParam(req.params.planId);
+    const filename = getParam(req.params.filename);
+    if (!planId || !filename) {
+      res.status(400).json({ error: "Missing planId or filename" });
+      return;
+    }
+    const ARTIFACTS_DIR = join4(homedir3(), ".shipyard", "artifacts");
+    const fullPath = resolve(ARTIFACTS_DIR, planId, filename);
+    if (!fullPath.startsWith(ARTIFACTS_DIR + sep)) {
+      res.status(400).json({ error: "Invalid artifact path" });
+      return;
+    }
+    const buffer = await readFile(fullPath).catch(() => null);
+    if (!buffer) {
+      res.status(404).json({ error: "Artifact not found" });
+      return;
+    }
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const mimeTypes = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      json: "application/json",
+      txt: "text/plain"
+    };
+    const contentType = mimeTypes[ext || ""] || "application/octet-stream";
+    res.setHeader("Content-Type", contentType);
+    res.setHeader("Content-Length", buffer.length);
+    res.setHeader("Cache-Control", "public, max-age=31536000");
+    res.send(buffer);
+  });
+  return { app, httpServer };
+}
+async function startRegistryServer() {
+  const ports = registryConfig.REGISTRY_PORT;
+  const { httpServer } = createApp();
+  const wss = new WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (request, socket, head) => {
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      wss.emit("connection", ws, request);
+    });
+  });
+  wss.on("connection", handleWebSocketConnection);
+  process.once("SIGINT", async () => {
+    logger.info("SIGINT received, shutting down gracefully");
+    const { stopPeriodicCleanup } = await import("./session-registry-CBDXMXY3.js");
+    stopPeriodicCleanup();
+    await releaseHubLock();
+    process.exit(0);
+  });
+  process.once("SIGTERM", async () => {
+    logger.info("SIGTERM received, shutting down gracefully");
+    const { stopPeriodicCleanup } = await import("./session-registry-CBDXMXY3.js");
+    stopPeriodicCleanup();
+    await releaseHubLock();
+    process.exit(0);
+  });
+  for (const port of ports) {
+    try {
+      await new Promise((resolve2, reject) => {
+        httpServer.listen(port, "127.0.0.1", () => {
+          logger.info(
+            { port, persistence: PERSISTENCE_DIR },
+            "Registry server started with WebSocket and tRPC support"
+          );
+          startCleanupInterval();
+          resolve2();
+        });
+        httpServer.on("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            reject(err);
+          } else {
+            logger.error({ err, port }, "Registry server error");
+          }
+        });
+      });
+      return port;
+    } catch (err) {
+      logger.debug({ err, port }, "Port unavailable or server failed to start");
+    }
+  }
+  logger.warn({ ports }, "All registry ports in use");
+  return null;
+}
+async function isRegistryRunning() {
+  const ports = registryConfig.REGISTRY_PORT;
+  for (const port of ports) {
+    try {
+      const res = await fetch(`http://localhost:${port}/registry`, {
+        signal: AbortSignal.timeout(1e3)
+      });
+      if (res.ok) {
+        return port;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+export {
+  PlanStatusValues,
+  createLinkedPR,
   InputRequestSchema,
   createInputRequest,
-  normalizeChoiceOptions,
-  CHOICE_DROPDOWN_THRESHOLD,
-  MAX_QUESTIONS_PER_REQUEST,
-  QuestionSchema,
-  MultiQuestionInputRequestSchema,
-  AnyInputRequestSchema,
   createMultiQuestionInputRequest,
   YDOC_KEYS,
-  isValidYDocKey,
-  ThreadCommentSchema,
-  ThreadSchema,
-  isThread,
   parseThreads,
   extractTextFromCommentBody,
-  extractMentions,
-  VALID_STATUS_TRANSITIONS,
   getPlanMetadata,
-  getPlanMetadataWithValidation,
   setPlanMetadata,
   resetPlanToDraft,
   transitionPlanStatus,
   initPlanMetadata,
-  getStepCompletions,
-  toggleStepCompletion,
-  isStepCompleted,
   getArtifacts,
   addArtifact,
-  removeArtifact,
-  getAgentPresences,
-  setAgentPresence,
-  clearAgentPresence,
-  getAgentPresence,
   getDeliverables,
   addDeliverable,
   linkArtifactToDeliverable,
-  getPlanOwnerId,
-  isApprovalRequired,
-  getApprovedUsers,
-  isUserApproved,
-  approveUser,
-  revokeUser,
-  getRejectedUsers,
-  isUserRejected,
-  rejectUser,
-  unrejectUser,
   getLinkedPRs,
   linkPR,
-  unlinkPR,
-  getLinkedPR,
-  updateLinkedPRStatus,
   getPRReviewComments,
-  getPRReviewCommentsForPR,
-  addPRReviewComment,
-  resolvePRReviewComment,
-  removePRReviewComment,
   getLocalDiffComments,
-  getLocalDiffCommentsForFile,
-  addLocalDiffComment,
-  resolveLocalDiffComment,
-  removeLocalDiffComment,
-  markPlanAsViewed,
-  getViewedBy,
-  isPlanUnread,
-  getConversationVersions,
-  addConversationVersion,
-  markVersionHandedOff,
   logPlanEvent,
   getPlanEvents,
   getSnapshots,
   addSnapshot,
   createPlanSnapshot,
-  getLatestSnapshot,
-  addPlanTag,
-  removePlanTag,
-  getAllTagsFromIndex,
-  archivePlan,
-  unarchivePlan,
-  answerInputRequest,
-  answerMultiQuestionInputRequest,
-  cancelInputRequest,
-  declineInputRequest,
   atomicRegenerateTokenIfOwner,
-  isUrlEncodedPlanV1,
-  isUrlEncodedPlanV2,
-  encodePlan,
-  decodePlan,
-  createPlanUrl,
   createPlanUrlWithHistory,
-  getPlanFromUrl,
-  A2ATextPartSchema,
-  A2ADataPartSchema,
-  A2AFilePartSchema,
-  A2APartSchema,
-  A2AMessageSchema,
-  ConversationExportMetaSchema,
-  ClaudeCodeMessageSchema,
-  parseClaudeCodeTranscriptString,
-  claudeCodeToA2A,
-  validateA2AMessages,
-  summarizeA2AConversation,
-  a2aToClaudeCode,
-  formatAsClaudeCodeJSONL,
   formatDeliverablesForLLM,
   extractDeliverables,
-  hashLineContent,
-  computeCommentStaleness,
-  isLineContentStale,
-  withStalenessInfo,
-  withStalenessInfoBatch,
-  buildLineContentMap,
-  formatStalenessMarker,
   formatDiffCommentsForLLM,
-  formatPRCommentsForLLM,
-  getPRCommentsSummary,
-  EnvironmentContextSchema,
   GitHubPRResponseSchema,
-  asPlanId,
-  asAwarenessClientId,
-  asWebRTCPeerId,
-  asGitHubUsername,
-  ROUTES,
   createPlanWebUrl,
-  InviteTokenSchema,
-  InviteRedemptionSchema,
-  parseInviteFromUrl,
-  buildInviteUrl,
-  getTokenTimeRemaining,
-  GitFileStatusSchema,
-  LocalFileChangeSchema,
-  LocalChangesResponseSchema,
-  LocalChangesUnavailableReasonSchema,
-  LocalChangesUnavailableSchema,
-  LocalChangesResultSchema,
-  P2PMessageType,
-  ConversationExportStartMetaSchema,
-  ChunkMessageSchema,
-  ConversationExportEndSchema,
-  isConversationExportStart,
-  isConversationChunk,
-  isConversationExportEnd,
-  isP2PConversationMessage,
-  encodeExportStartMessage,
-  decodeExportStartMessage,
-  encodeChunkMessage,
-  decodeChunkMessage,
-  encodeExportEndMessage,
-  decodeExportEndMessage,
-  decodeP2PMessage,
-  assertNeverP2PMessage,
   PLAN_INDEX_DOC_NAME,
-  PLAN_INDEX_VIEWED_BY_KEY,
-  NON_PLAN_DB_NAMES,
-  PlanIndexEntrySchema,
-  getPlanIndex,
-  getPlanIndexEntry,
   setPlanIndexEntry,
-  removePlanIndexEntry,
   touchPlanIndexEntry,
-  getViewedByFromIndex,
-  updatePlanIndexViewedBy,
-  clearPlanIndexViewedBy,
-  getAllViewedByFromIndex,
-  removeViewedByFromIndex,
-  PLAN_INDEX_EVENT_VIEWED_BY_KEY,
-  markEventAsViewed,
-  clearEventViewedBy,
-  isEventUnread,
-  getAllEventViewedByForPlan,
-  formatThreadsForLLM,
   TOOL_NAMES,
-  PlanIdSchema,
-  PlanStatusResponseSchema,
-  HasConnectionsResponseSchema,
-  SubscriptionClientIdSchema,
-  ChangeSchema,
-  ChangesResponseSchema,
-  DeleteSubscriptionResponseSchema,
-  SetSessionTokenRequestSchema,
-  SetSessionTokenResponseSchema,
-  ImportConversationRequestSchema,
-  ImportConversationResponseSchema,
-  conversationRouter,
-  hookRouter,
-  planRouter,
-  subscriptionRouter,
-  appRouter,
-  isErrnoException,
   hasErrorCode,
-  isBuffer,
   createUserResolver,
-  getSignalingConnections,
-  getWebrtcPeerId,
-  getWebrtcRoom
+  registryConfig,
+  getLocalChanges,
+  parseRepoString,
+  isArtifactsEnabled,
+  GitHubAuthError,
+  getOctokit,
+  isGitHubConfigured,
+  uploadArtifact,
+  generateSessionToken,
+  hashSessionToken,
+  webConfig,
+  getRepositoryFullName,
+  getGitHubUsername,
+  getVerifiedGitHubUsername,
+  tryAcquireHubLock,
+  releaseHubLock,
+  startRegistryServer,
+  isRegistryRunning,
+  initAsHub,
+  initAsClient,
+  getOrCreateDoc3 as getOrCreateDoc,
+  hasActiveConnections3 as hasActiveConnections
 };