@schoolai/shipyard-mcp 0.1.0-next.433

package/apps/hook/dist/index.js

@@ -0,0 +1,3078 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/lz-string@1.5.0/node_modules/lz-string/libs/lz-string.js
+var require_lz_string = __commonJS({
+  "../../node_modules/.pnpm/lz-string@1.5.0/node_modules/lz-string/libs/lz-string.js"(exports, module) {
+    "use strict";
+    var LZString = (function() {
+      var f = String.fromCharCode;
+      var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+      var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
+      var baseReverseDic = {};
+      function getBaseValue(alphabet, character) {
+        if (!baseReverseDic[alphabet]) {
+          baseReverseDic[alphabet] = {};
+          for (var i = 0; i < alphabet.length; i++) {
+            baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+          }
+        }
+        return baseReverseDic[alphabet][character];
+      }
+      var LZString2 = {
+        compressToBase64: function(input) {
+          if (input == null) return "";
+          var res = LZString2._compress(input, 6, function(a) {
+            return keyStrBase64.charAt(a);
+          });
+          switch (res.length % 4) {
+            // To produce valid Base64
+            default:
+            // When could this happen ?
+            case 0:
+              return res;
+            case 1:
+              return res + "===";
+            case 2:
+              return res + "==";
+            case 3:
+              return res + "=";
+          }
+        },
+        decompressFromBase64: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrBase64, input.charAt(index));
+          });
+        },
+        compressToUTF16: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 15, function(a) {
+            return f(a + 32);
+          }) + " ";
+        },
+        decompressFromUTF16: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 16384, function(index) {
+            return compressed.charCodeAt(index) - 32;
+          });
+        },
+        //compress into uint8array (UCS-2 big endian format)
+        compressToUint8Array: function(uncompressed) {
+          var compressed = LZString2.compress(uncompressed);
+          var buf = new Uint8Array(compressed.length * 2);
+          for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
+            var current_value = compressed.charCodeAt(i);
+            buf[i * 2] = current_value >>> 8;
+            buf[i * 2 + 1] = current_value % 256;
+          }
+          return buf;
+        },
+        //decompress from uint8array (UCS-2 big endian format)
+        decompressFromUint8Array: function(compressed) {
+          if (compressed === null || compressed === void 0) {
+            return LZString2.decompress(compressed);
+          } else {
+            var buf = new Array(compressed.length / 2);
+            for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) {
+              buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1];
+            }
+            var result = [];
+            buf.forEach(function(c) {
+              result.push(f(c));
+            });
+            return LZString2.decompress(result.join(""));
+          }
+        },
+        //compress into a string that is already URI encoded
+        compressToEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          return LZString2._compress(input, 6, function(a) {
+            return keyStrUriSafe.charAt(a);
+          });
+        },
+        //decompress from an output of compressToEncodedURIComponent
+        decompressFromEncodedURIComponent: function(input) {
+          if (input == null) return "";
+          if (input == "") return null;
+          input = input.replace(/ /g, "+");
+          return LZString2._decompress(input.length, 32, function(index) {
+            return getBaseValue(keyStrUriSafe, input.charAt(index));
+          });
+        },
+        compress: function(uncompressed) {
+          return LZString2._compress(uncompressed, 16, function(a) {
+            return f(a);
+          });
+        },
+        _compress: function(uncompressed, bitsPerChar, getCharFromInt) {
+          if (uncompressed == null) return "";
+          var i, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
+          for (ii = 0; ii < uncompressed.length; ii += 1) {
+            context_c = uncompressed.charAt(ii);
+            if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+              context_dictionary[context_c] = context_dictSize++;
+              context_dictionaryToCreate[context_c] = true;
+            }
+            context_wc = context_w + context_c;
+            if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
+              context_w = context_wc;
+            } else {
+              if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+                if (context_w.charCodeAt(0) < 256) {
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 8; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                } else {
+                  value = 1;
+                  for (i = 0; i < context_numBits; i++) {
+                    context_data_val = context_data_val << 1 | value;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = 0;
+                  }
+                  value = context_w.charCodeAt(0);
+                  for (i = 0; i < 16; i++) {
+                    context_data_val = context_data_val << 1 | value & 1;
+                    if (context_data_position == bitsPerChar - 1) {
+                      context_data_position = 0;
+                      context_data.push(getCharFromInt(context_data_val));
+                      context_data_val = 0;
+                    } else {
+                      context_data_position++;
+                    }
+                    value = value >> 1;
+                  }
+                }
+                context_enlargeIn--;
+                if (context_enlargeIn == 0) {
+                  context_enlargeIn = Math.pow(2, context_numBits);
+                  context_numBits++;
+                }
+                delete context_dictionaryToCreate[context_w];
+              } else {
+                value = context_dictionary[context_w];
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              context_dictionary[context_wc] = context_dictSize++;
+              context_w = String(context_c);
+            }
+          }
+          if (context_w !== "") {
+            if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+              if (context_w.charCodeAt(0) < 256) {
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 8; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              } else {
+                value = 1;
+                for (i = 0; i < context_numBits; i++) {
+                  context_data_val = context_data_val << 1 | value;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = 0;
+                }
+                value = context_w.charCodeAt(0);
+                for (i = 0; i < 16; i++) {
+                  context_data_val = context_data_val << 1 | value & 1;
+                  if (context_data_position == bitsPerChar - 1) {
+                    context_data_position = 0;
+                    context_data.push(getCharFromInt(context_data_val));
+                    context_data_val = 0;
+                  } else {
+                    context_data_position++;
+                  }
+                  value = value >> 1;
+                }
+              }
+              context_enlargeIn--;
+              if (context_enlargeIn == 0) {
+                context_enlargeIn = Math.pow(2, context_numBits);
+                context_numBits++;
+              }
+              delete context_dictionaryToCreate[context_w];
+            } else {
+              value = context_dictionary[context_w];
+              for (i = 0; i < context_numBits; i++) {
+                context_data_val = context_data_val << 1 | value & 1;
+                if (context_data_position == bitsPerChar - 1) {
+                  context_data_position = 0;
+                  context_data.push(getCharFromInt(context_data_val));
+                  context_data_val = 0;
+                } else {
+                  context_data_position++;
+                }
+                value = value >> 1;
+              }
+            }
+            context_enlargeIn--;
+            if (context_enlargeIn == 0) {
+              context_enlargeIn = Math.pow(2, context_numBits);
+              context_numBits++;
+            }
+          }
+          value = 2;
+          for (i = 0; i < context_numBits; i++) {
+            context_data_val = context_data_val << 1 | value & 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+          while (true) {
+            context_data_val = context_data_val << 1;
+            if (context_data_position == bitsPerChar - 1) {
+              context_data.push(getCharFromInt(context_data_val));
+              break;
+            } else context_data_position++;
+          }
+          return context_data.join("");
+        },
+        decompress: function(compressed) {
+          if (compressed == null) return "";
+          if (compressed == "") return null;
+          return LZString2._decompress(compressed.length, 32768, function(index) {
+            return compressed.charCodeAt(index);
+          });
+        },
+        _decompress: function(length, 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;
+          }
+          bits = 0;
+          maxpower = Math.pow(2, 2);
+          power = 1;
+          while (power != maxpower) {
+            resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position == 0) {
+              data.position = resetValue;
+              data.val = getNextValue(data.index++);
+            }
+            bits |= (resb > 0 ? 1 : 0) * power;
+            power <<= 1;
+          }
+          switch (next = bits) {
+            case 0:
+              bits = 0;
+              maxpower = Math.pow(2, 8);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 1:
+              bits = 0;
+              maxpower = Math.pow(2, 16);
+              power = 1;
+              while (power != maxpower) {
+                resb = data.val & data.position;
+                data.position >>= 1;
+                if (data.position == 0) {
+                  data.position = resetValue;
+                  data.val = getNextValue(data.index++);
+                }
+                bits |= (resb > 0 ? 1 : 0) * power;
+                power <<= 1;
+              }
+              c = f(bits);
+              break;
+            case 2:
+              return "";
+          }
+          dictionary[3] = c;
+          w = c;
+          result.push(c);
+          while (true) {
+            if (data.index > length) {
+              return "";
+            }
+            bits = 0;
+            maxpower = Math.pow(2, numBits);
+            power = 1;
+            while (power != maxpower) {
+              resb = data.val & data.position;
+              data.position >>= 1;
+              if (data.position == 0) {
+                data.position = resetValue;
+                data.val = getNextValue(data.index++);
+              }
+              bits |= (resb > 0 ? 1 : 0) * power;
+              power <<= 1;
+            }
+            switch (c = bits) {
+              case 0:
+                bits = 0;
+                maxpower = Math.pow(2, 8);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 1:
+                bits = 0;
+                maxpower = Math.pow(2, 16);
+                power = 1;
+                while (power != maxpower) {
+                  resb = data.val & data.position;
+                  data.position >>= 1;
+                  if (data.position == 0) {
+                    data.position = resetValue;
+                    data.val = getNextValue(data.index++);
+                  }
+                  bits |= (resb > 0 ? 1 : 0) * power;
+                  power <<= 1;
+                }
+                dictionary[dictSize++] = f(bits);
+                c = dictSize - 1;
+                enlargeIn--;
+                break;
+              case 2:
+                return result.join("");
+            }
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+            if (dictionary[c]) {
+              entry = dictionary[c];
+            } else {
+              if (c === dictSize) {
+                entry = w + w.charAt(0);
+              } else {
+                return null;
+              }
+            }
+            result.push(entry);
+            dictionary[dictSize++] = w + entry.charAt(0);
+            enlargeIn--;
+            w = entry;
+            if (enlargeIn == 0) {
+              enlargeIn = Math.pow(2, numBits);
+              numBits++;
+            }
+          }
+        }
+      };
+      return LZString2;
+    })();
+    if (typeof define === "function" && define.amd) {
+      define(function() {
+        return LZString;
+      });
+    } else if (typeof module !== "undefined" && module != null) {
+      module.exports = LZString;
+    } else if (typeof angular !== "undefined" && angular != null) {
+      angular.module("LZString", []).factory("LZString", function() {
+        return LZString;
+      });
+    }
+  }
+});
+
+// ../../packages/schema/dist/plan.mjs
+import { z } from "zod";
+import { nanoid } from "nanoid";
+var PlanStatusValues = [
+  "draft",
+  "pending_review",
+  "changes_requested",
+  "in_progress",
+  "completed"
+];
+var OriginPlatformValues = [
+  "claude-code",
+  "devin",
+  "cursor",
+  "windsurf",
+  "aider",
+  "unknown"
+];
+var ClaudeCodeOriginMetadataSchema = z.object({
+  platform: z.literal("claude-code"),
+  sessionId: z.string(),
+  transcriptPath: z.string(),
+  cwd: z.string().optional()
+});
+var DevinOriginMetadataSchema = z.object({
+  platform: z.literal("devin"),
+  sessionId: z.string()
+});
+var CursorOriginMetadataSchema = z.object({
+  platform: z.literal("cursor"),
+  conversationId: z.string(),
+  generationId: z.string().optional()
+});
+var UnknownOriginMetadataSchema = z.object({ platform: z.literal("unknown") });
+var OriginMetadataSchema = z.discriminatedUnion("platform", [
+  ClaudeCodeOriginMetadataSchema,
+  DevinOriginMetadataSchema,
+  CursorOriginMetadataSchema,
+  UnknownOriginMetadataSchema
+]);
+var ConversationVersionBaseSchema = z.object({
+  versionId: z.string(),
+  creator: z.string(),
+  platform: z.enum(OriginPlatformValues),
+  sessionId: z.string(),
+  messageCount: z.number(),
+  createdAt: z.number()
+});
+var ConversationVersionSchema = z.discriminatedUnion("handedOff", [ConversationVersionBaseSchema.extend({ handedOff: z.literal(false) }), ConversationVersionBaseSchema.extend({
+  handedOff: z.literal(true),
+  handedOffAt: z.number(),
+  handedOffTo: z.string()
+})]);
+var PlanEventBaseSchema = z.object({
+  id: z.string(),
+  actor: z.string(),
+  timestamp: z.number(),
+  inboxWorthy: z.boolean().optional(),
+  inboxFor: z.union([z.string(), z.array(z.string())]).optional()
+});
+var AgentActivityDataSchema = z.discriminatedUnion("activityType", [
+  z.object({
+    activityType: z.literal("help_request"),
+    requestId: z.string(),
+    message: z.string()
+  }),
+  z.object({
+    activityType: z.literal("help_request_resolved"),
+    requestId: z.string(),
+    resolution: z.string().optional()
+  }),
+  z.object({
+    activityType: z.literal("blocker"),
+    message: z.string(),
+    requestId: z.string()
+  }),
+  z.object({
+    activityType: z.literal("blocker_resolved"),
+    requestId: z.string(),
+    resolution: z.string().optional()
+  })
+]);
+var PlanEventSchema = z.discriminatedUnion("type", [
+  PlanEventBaseSchema.extend({ type: z.enum([
+    "plan_created",
+    "content_edited",
+    "plan_archived",
+    "plan_unarchived",
+    "plan_shared"
+  ]) }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("status_changed"),
+    data: z.object({
+      fromStatus: z.enum(PlanStatusValues),
+      toStatus: z.enum(PlanStatusValues)
+    })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("artifact_uploaded"),
+    data: z.object({ artifactId: z.string() })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("comment_added"),
+    data: z.object({
+      commentId: z.string().optional(),
+      prNumber: z.number().optional(),
+      mentions: z.boolean().optional()
+    }).optional()
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("comment_resolved"),
+    data: z.object({
+      commentId: z.string().optional(),
+      resolvedCount: z.number().optional()
+    }).optional()
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("deliverable_linked"),
+    data: z.object({
+      deliverableId: z.string().optional(),
+      artifactId: z.string().optional(),
+      allFulfilled: z.boolean().optional()
+    }).optional()
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("pr_linked"),
+    data: z.object({
+      prNumber: z.number(),
+      url: z.string().optional()
+    })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.enum(["approved", "changes_requested"]),
+    data: z.object({ comment: z.string().optional() }).optional()
+  }),
+  PlanEventBaseSchema.extend({ type: z.literal("completed") }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("step_completed"),
+    data: z.object({
+      stepId: z.string(),
+      completed: z.boolean()
+    })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("conversation_imported"),
+    data: z.object({
+      sourcePlatform: z.string().optional(),
+      messageCount: z.number(),
+      sourceSessionId: z.string().optional()
+    })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("conversation_exported"),
+    data: z.object({ messageCount: z.number() })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("conversation_handed_off"),
+    data: z.object({
+      handedOffTo: z.string(),
+      messageCount: z.number()
+    })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("approval_requested"),
+    data: z.object({ requesterName: z.string().optional() }).optional()
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("input_request_created"),
+    data: z.object({
+      requestId: z.string(),
+      requestType: z.enum([
+        "text",
+        "multiline",
+        "choice",
+        "confirm"
+      ]),
+      requestMessage: z.string()
+    })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("input_request_answered"),
+    data: z.object({
+      requestId: z.string(),
+      response: z.unknown(),
+      answeredBy: z.string()
+    })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("input_request_declined"),
+    data: z.object({ requestId: z.string() })
+  }),
+  PlanEventBaseSchema.extend({
+    type: z.literal("agent_activity"),
+    data: AgentActivityDataSchema
+  })
+]);
+var PlanMetadataBaseSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  repo: z.string().optional(),
+  pr: z.number().optional(),
+  ownerId: z.string().optional(),
+  approvalRequired: z.boolean().optional(),
+  approvedUsers: z.array(z.string()).optional(),
+  rejectedUsers: z.array(z.string()).optional(),
+  sessionTokenHash: z.string().optional(),
+  archivedAt: z.number().optional(),
+  archivedBy: z.string().optional(),
+  origin: OriginMetadataSchema.optional(),
+  viewedBy: z.record(z.string(), z.number()).optional(),
+  conversationVersions: z.array(ConversationVersionSchema).optional(),
+  events: z.array(PlanEventSchema).optional(),
+  tags: z.array(z.string()).optional()
+});
+var PlanMetadataSchema = z.discriminatedUnion("status", [
+  PlanMetadataBaseSchema.extend({ status: z.literal("draft") }),
+  PlanMetadataBaseSchema.extend({
+    status: z.literal("pending_review"),
+    reviewRequestId: z.string()
+  }),
+  PlanMetadataBaseSchema.extend({
+    status: z.literal("changes_requested"),
+    reviewedAt: z.number(),
+    reviewedBy: z.string(),
+    reviewComment: z.string().optional()
+  }),
+  PlanMetadataBaseSchema.extend({
+    status: z.literal("in_progress"),
+    reviewedAt: z.number(),
+    reviewedBy: z.string(),
+    reviewComment: z.string().optional()
+  }),
+  PlanMetadataBaseSchema.extend({
+    status: z.literal("completed"),
+    completedAt: z.number(),
+    completedBy: z.string(),
+    snapshotUrl: z.string().optional()
+  })
+]);
+var BaseArtifactSchema = z.object({
+  id: z.string(),
+  type: z.enum([
+    "screenshot",
+    "video",
+    "test_results",
+    "diff"
+  ]),
+  filename: z.string(),
+  description: z.string().optional(),
+  uploadedAt: z.number().optional()
+});
+var GitHubArtifactSchema = BaseArtifactSchema.extend({
+  storage: z.literal("github"),
+  url: z.string()
+});
+var LocalArtifactSchema = BaseArtifactSchema.extend({
+  storage: z.literal("local"),
+  localArtifactId: z.string()
+});
+var ArtifactSchema = z.discriminatedUnion("storage", [GitHubArtifactSchema, LocalArtifactSchema]);
+var DeliverableSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  linkedArtifactId: z.string().optional(),
+  linkedAt: z.number().optional()
+});
+var PlanSnapshotSchema = z.object({
+  id: z.string(),
+  status: z.enum(PlanStatusValues),
+  createdBy: z.string(),
+  reason: z.string(),
+  createdAt: z.number(),
+  content: z.array(z.unknown()),
+  threadSummary: z.object({
+    total: z.number(),
+    unresolved: z.number()
+  }).optional(),
+  artifacts: z.array(ArtifactSchema).optional(),
+  deliverables: z.array(DeliverableSchema).optional()
+});
+var LinkedPRStatusValues = [
+  "draft",
+  "open",
+  "merged",
+  "closed"
+];
+var LinkedPRSchema = z.object({
+  prNumber: z.number(),
+  url: z.string(),
+  linkedAt: z.number(),
+  status: z.enum(LinkedPRStatusValues),
+  branch: z.string().optional(),
+  title: z.string().optional()
+});
+var PRReviewCommentSchema = z.object({
+  id: z.string(),
+  prNumber: z.number(),
+  path: z.string(),
+  line: z.number(),
+  body: z.string(),
+  author: z.string(),
+  createdAt: z.number(),
+  resolved: z.boolean().optional()
+});
+
+// ../../packages/schema/dist/yjs-helpers-xzZyVQl7.mjs
+import { z as z2 } from "zod";
+import { nanoid as nanoid2 } from "nanoid";
+import * as Y from "yjs";
+function assertNever(value) {
+  throw new Error(`Unhandled discriminated union member: ${JSON.stringify(value)}`);
+}
+var AgentPresenceSchema = z2.object({
+  agentType: z2.string(),
+  sessionId: z2.string(),
+  connectedAt: z2.number(),
+  lastSeenAt: z2.number()
+});
+var ReviewCommentSchema = z2.object({
+  author: z2.string(),
+  content: z2.string(),
+  createdAt: z2.number()
+});
+var ReviewFeedbackSchema = z2.object({
+  threadId: z2.string(),
+  blockId: z2.string().optional(),
+  comments: z2.array(ReviewCommentSchema)
+});
+var CreateHookSessionRequestSchema = z2.object({
+  sessionId: z2.string(),
+  agentType: z2.string().default("claude-code"),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
+});
+var CreateHookSessionResponseSchema = z2.object({
+  planId: z2.string(),
+  url: z2.string()
+});
+var UpdatePlanContentRequestSchema = z2.object({
+  content: z2.string(),
+  filePath: z2.string().optional()
+});
+var UpdatePlanContentResponseSchema = z2.object({
+  success: z2.boolean(),
+  updatedAt: z2.number()
+});
+var GetReviewStatusResponseSchema = z2.discriminatedUnion("status", [
+  z2.object({ status: z2.literal("draft") }),
+  z2.object({
+    status: z2.literal("pending_review"),
+    reviewRequestId: z2.string()
+  }),
+  z2.object({
+    status: z2.literal("changes_requested"),
+    reviewedAt: z2.number(),
+    reviewedBy: z2.string(),
+    reviewComment: z2.string().optional(),
+    feedback: z2.array(ReviewFeedbackSchema).optional()
+  }),
+  z2.object({
+    status: z2.literal("in_progress"),
+    reviewedAt: z2.number(),
+    reviewedBy: z2.string()
+  }),
+  z2.object({
+    status: z2.literal("completed"),
+    completedAt: z2.number(),
+    completedBy: z2.string(),
+    snapshotUrl: z2.string().optional()
+  })
+]);
+var UpdatePresenceRequestSchema = z2.object({
+  agentType: z2.string(),
+  sessionId: z2.string()
+});
+var UpdatePresenceResponseSchema = z2.object({ success: z2.boolean() });
+var HookApiErrorSchema = z2.object({ error: z2.string() });
+var RegisterServerRequestSchema = z2.object({
+  port: z2.number().int().positive(),
+  pid: z2.number().int().positive()
+});
+var RegisterServerResponseSchema = z2.object({
+  success: z2.boolean(),
+  entry: z2.object({
+    port: z2.number(),
+    pid: z2.number(),
+    url: z2.string(),
+    registeredAt: z2.number()
+  })
+});
+var UnregisterServerRequestSchema = z2.object({ pid: z2.number().int().positive() });
+var UnregisterServerResponseSchema = z2.object({
+  success: z2.boolean(),
+  existed: z2.boolean()
+});
+var CreateSubscriptionRequestSchema = z2.object({
+  subscribe: z2.array(z2.string()).optional(),
+  windowMs: z2.number().positive().optional(),
+  maxWindowMs: z2.number().positive().optional(),
+  threshold: z2.number().positive().optional()
+});
+var CreateSubscriptionResponseSchema = z2.object({ clientId: z2.string() });
+var InputRequestStatusValues = [
+  "pending",
+  "answered",
+  "declined",
+  "cancelled"
+];
+var InputRequestBaseSchema = z2.object({
+  id: z2.string(),
+  createdAt: z2.number(),
+  message: z2.string().min(1, "Message cannot be empty"),
+  status: z2.enum(InputRequestStatusValues),
+  defaultValue: z2.string().optional(),
+  timeout: z2.number().int().min(10, "Timeout must be at least 10 seconds").max(900, "Timeout cannot exceed 15 minutes").optional(),
+  planId: z2.string().optional(),
+  response: z2.unknown().optional(),
+  answeredAt: z2.number().optional(),
+  answeredBy: z2.string().optional()
+});
+var TextInputSchema = InputRequestBaseSchema.extend({ type: z2.literal("text") });
+var MultilineInputSchema = InputRequestBaseSchema.extend({ type: z2.literal("multiline") });
+var ChoiceInputSchema = InputRequestBaseSchema.extend({
+  type: z2.literal("choice"),
+  options: z2.array(z2.string()).min(1, "Choice requests must have at least one option"),
+  multiSelect: z2.boolean().optional()
+});
+var ConfirmInputSchema = InputRequestBaseSchema.extend({ type: z2.literal("confirm") });
+var InputRequestSchema = z2.discriminatedUnion("type", [
+  TextInputSchema,
+  MultilineInputSchema,
+  ChoiceInputSchema,
+  ConfirmInputSchema
+]);
+var YDOC_KEYS = {
+  METADATA: "metadata",
+  DOCUMENT_FRAGMENT: "document",
+  THREADS: "threads",
+  STEP_COMPLETIONS: "stepCompletions",
+  PLANS: "plans",
+  ARTIFACTS: "artifacts",
+  DELIVERABLES: "deliverables",
+  PRESENCE: "presence",
+  LINKED_PRS: "linkedPRs",
+  PR_REVIEW_COMMENTS: "prReviewComments",
+  EVENTS: "events",
+  SNAPSHOTS: "snapshots",
+  INPUT_REQUESTS: "inputRequests"
+};
+var CommentBodySchema = z2.union([z2.string(), z2.array(z2.unknown())]);
+var ThreadCommentSchema = z2.object({
+  id: z2.string(),
+  userId: z2.string(),
+  body: CommentBodySchema,
+  createdAt: z2.number()
+});
+var ThreadSchema = z2.object({
+  id: z2.string(),
+  comments: z2.array(ThreadCommentSchema),
+  resolved: z2.boolean().optional(),
+  selectedText: z2.string().optional()
+});
+function extractTextFromCommentBody(body) {
+  if (typeof body === "string") return body;
+  if (!Array.isArray(body)) return "";
+  return body.map((block) => {
+    if (typeof block === "string") return block;
+    if (typeof block !== "object" || block === null) return "";
+    const blockObj = block;
+    if (Array.isArray(blockObj.content)) return blockObj.content.map((item) => {
+      if (typeof item === "string") return item;
+      if (typeof item === "object" && item !== null && "text" in item) return item.text;
+      return "";
+    }).join("");
+    return "";
+  }).join("\n");
+}
+function getPlanMetadata(ydoc) {
+  const result = getPlanMetadataWithValidation(ydoc);
+  return result.success ? result.data : null;
+}
+function getPlanMetadataWithValidation(ydoc) {
+  const data = ydoc.getMap(YDOC_KEYS.METADATA).toJSON();
+  if (!data || Object.keys(data).length === 0) return {
+    success: false,
+    error: "No metadata found in Y.Doc"
+  };
+  const result = PlanMetadataSchema.safeParse(data);
+  if (!result.success) return {
+    success: false,
+    error: `Invalid metadata: ${result.error.message}`
+  };
+  return {
+    success: true,
+    data: result.data
+  };
+}
+
+// ../../packages/schema/dist/url-encoding.mjs
+var import_lz_string = __toESM(require_lz_string(), 1);
+
+// ../../packages/schema/dist/index.mjs
+import { z as z3 } from "zod";
+import * as Y2 from "yjs";
+
+// ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/codes-DagpWZLc.mjs
+function mergeWithoutOverrides(obj1, ...objs) {
+  const newObj = Object.assign(emptyObject(), obj1);
+  for (const overrides of objs) for (const key in overrides) {
+    if (key in newObj && newObj[key] !== overrides[key]) throw new Error(`Duplicate key ${key}`);
+    newObj[key] = overrides[key];
+  }
+  return newObj;
+}
+function isObject(value) {
+  return !!value && !Array.isArray(value) && typeof value === "object";
+}
+function isFunction(fn) {
+  return typeof fn === "function";
+}
+function emptyObject() {
+  return /* @__PURE__ */ Object.create(null);
+}
+var TRPC_ERROR_CODES_BY_KEY = {
+  PARSE_ERROR: -32700,
+  BAD_REQUEST: -32600,
+  INTERNAL_SERVER_ERROR: -32603,
+  NOT_IMPLEMENTED: -32603,
+  BAD_GATEWAY: -32603,
+  SERVICE_UNAVAILABLE: -32603,
+  GATEWAY_TIMEOUT: -32603,
+  UNAUTHORIZED: -32001,
+  PAYMENT_REQUIRED: -32002,
+  FORBIDDEN: -32003,
+  NOT_FOUND: -32004,
+  METHOD_NOT_SUPPORTED: -32005,
+  TIMEOUT: -32008,
+  CONFLICT: -32009,
+  PRECONDITION_FAILED: -32012,
+  PAYLOAD_TOO_LARGE: -32013,
+  UNSUPPORTED_MEDIA_TYPE: -32015,
+  UNPROCESSABLE_CONTENT: -32022,
+  PRECONDITION_REQUIRED: -32028,
+  TOO_MANY_REQUESTS: -32029,
+  CLIENT_CLOSED_REQUEST: -32099
+};
+var retryableRpcCodes = [
+  TRPC_ERROR_CODES_BY_KEY.BAD_GATEWAY,
+  TRPC_ERROR_CODES_BY_KEY.SERVICE_UNAVAILABLE,
+  TRPC_ERROR_CODES_BY_KEY.GATEWAY_TIMEOUT,
+  TRPC_ERROR_CODES_BY_KEY.INTERNAL_SERVER_ERROR
+];
+
+// ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/getErrorShape-vC8mUXJD.mjs
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS2 = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key; i < n; i++) {
+    key = keys[i];
+    if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
+      get: ((k) => from[k]).bind(null, key),
+      enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var noop = () => {
+};
+var freezeIfAvailable = (obj) => {
+  if (Object.freeze) Object.freeze(obj);
+};
+function createInnerProxy(callback, path, memo) {
+  var _memo$cacheKey;
+  const cacheKey = path.join(".");
+  (_memo$cacheKey = memo[cacheKey]) !== null && _memo$cacheKey !== void 0 || (memo[cacheKey] = new Proxy(noop, {
+    get(_obj, key) {
+      if (typeof key !== "string" || key === "then") return void 0;
+      return createInnerProxy(callback, [...path, key], memo);
+    },
+    apply(_1, _2, args) {
+      const lastOfPath = path[path.length - 1];
+      let opts = {
+        args,
+        path
+      };
+      if (lastOfPath === "call") opts = {
+        args: args.length >= 2 ? [args[1]] : [],
+        path: path.slice(0, -1)
+      };
+      else if (lastOfPath === "apply") opts = {
+        args: args.length >= 2 ? args[1] : [],
+        path: path.slice(0, -1)
+      };
+      freezeIfAvailable(opts.args);
+      freezeIfAvailable(opts.path);
+      return callback(opts);
+    }
+  }));
+  return memo[cacheKey];
+}
+var createRecursiveProxy = (callback) => createInnerProxy(callback, [], emptyObject());
+var require_typeof = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(exports, module) {
+  function _typeof$2(o) {
+    "@babel/helpers - typeof";
+    return module.exports = _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+      return typeof o$1;
+    } : function(o$1) {
+      return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+    }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof$2(o);
+  }
+  module.exports = _typeof$2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPrimitive = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(exports, module) {
+  var _typeof$1 = require_typeof()["default"];
+  function toPrimitive$1(t2, r) {
+    if ("object" != _typeof$1(t2) || !t2) return t2;
+    var e = t2[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t2, r || "default");
+      if ("object" != _typeof$1(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t2);
+  }
+  module.exports = toPrimitive$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_toPropertyKey = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(exports, module) {
+  var _typeof = require_typeof()["default"];
+  var toPrimitive = require_toPrimitive();
+  function toPropertyKey$1(t2) {
+    var i = toPrimitive(t2, "string");
+    return "symbol" == _typeof(i) ? i : i + "";
+  }
+  module.exports = toPropertyKey$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_defineProperty = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(exports, module) {
+  var toPropertyKey = require_toPropertyKey();
+  function _defineProperty(e, r, t2) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t2,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t2, e;
+  }
+  module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectSpread2 = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(exports, module) {
+  var defineProperty = require_defineProperty();
+  function ownKeys(e, r) {
+    var t2 = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r$1) {
+        return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+      })), t2.push.apply(t2, o);
+    }
+    return t2;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t2 = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t2), true).forEach(function(r$1) {
+        defineProperty(e, r$1, t2[r$1]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t2)) : ownKeys(Object(t2)).forEach(function(r$1) {
+        Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t2, r$1));
+      });
+    }
+    return e;
+  }
+  module.exports = _objectSpread2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_objectSpread2 = __toESM2(require_objectSpread2(), 1);
+
+// ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/tracked-D4V22yc5.mjs
+var defaultFormatter = ({ shape }) => {
+  return shape;
+};
+var import_defineProperty = __toESM2(require_defineProperty(), 1);
+var UnknownCauseError = class extends Error {
+};
+function getCauseFromUnknown(cause) {
+  if (cause instanceof Error) return cause;
+  const type = typeof cause;
+  if (type === "undefined" || type === "function" || cause === null) return void 0;
+  if (type !== "object") return new Error(String(cause));
+  if (isObject(cause)) return Object.assign(new UnknownCauseError(), cause);
+  return void 0;
+}
+function getTRPCErrorFromUnknown(cause) {
+  if (cause instanceof TRPCError) return cause;
+  if (cause instanceof Error && cause.name === "TRPCError") return cause;
+  const trpcError = new TRPCError({
+    code: "INTERNAL_SERVER_ERROR",
+    cause
+  });
+  if (cause instanceof Error && cause.stack) trpcError.stack = cause.stack;
+  return trpcError;
+}
+var TRPCError = class extends Error {
+  constructor(opts) {
+    var _ref, _opts$message, _this$cause;
+    const cause = getCauseFromUnknown(opts.cause);
+    const message = (_ref = (_opts$message = opts.message) !== null && _opts$message !== void 0 ? _opts$message : cause === null || cause === void 0 ? void 0 : cause.message) !== null && _ref !== void 0 ? _ref : opts.code;
+    super(message, { cause });
+    (0, import_defineProperty.default)(this, "cause", void 0);
+    (0, import_defineProperty.default)(this, "code", void 0);
+    this.code = opts.code;
+    this.name = "TRPCError";
+    (_this$cause = this.cause) !== null && _this$cause !== void 0 || (this.cause = cause);
+  }
+};
+var import_objectSpread2$1 = __toESM2(require_objectSpread2(), 1);
+function getDataTransformer(transformer) {
+  if ("input" in transformer) return transformer;
+  return {
+    input: transformer,
+    output: transformer
+  };
+}
+var defaultTransformer = {
+  input: {
+    serialize: (obj) => obj,
+    deserialize: (obj) => obj
+  },
+  output: {
+    serialize: (obj) => obj,
+    deserialize: (obj) => obj
+  }
+};
+var import_objectSpread22 = __toESM2(require_objectSpread2(), 1);
+var lazyMarker = "lazyMarker";
+function once(fn) {
+  const uncalled = /* @__PURE__ */ Symbol();
+  let result = uncalled;
+  return () => {
+    if (result === uncalled) result = fn();
+    return result;
+  };
+}
+function isLazy(input) {
+  return typeof input === "function" && lazyMarker in input;
+}
+function isRouter(value) {
+  return isObject(value) && isObject(value["_def"]) && "router" in value["_def"];
+}
+var emptyRouter = {
+  _ctx: null,
+  _errorShape: null,
+  _meta: null,
+  queries: {},
+  mutations: {},
+  subscriptions: {},
+  errorFormatter: defaultFormatter,
+  transformer: defaultTransformer
+};
+var reservedWords = [
+  "then",
+  "call",
+  "apply"
+];
+function createRouterFactory(config) {
+  function createRouterInner(input) {
+    const reservedWordsUsed = new Set(Object.keys(input).filter((v) => reservedWords.includes(v)));
+    if (reservedWordsUsed.size > 0) throw new Error("Reserved words used in `router({})` call: " + Array.from(reservedWordsUsed).join(", "));
+    const procedures = emptyObject();
+    const lazy$1 = emptyObject();
+    function createLazyLoader(opts) {
+      return {
+        ref: opts.ref,
+        load: once(async () => {
+          const router$1 = await opts.ref();
+          const lazyPath = [...opts.path, opts.key];
+          const lazyKey = lazyPath.join(".");
+          opts.aggregate[opts.key] = step(router$1._def.record, lazyPath);
+          delete lazy$1[lazyKey];
+          for (const [nestedKey, nestedItem] of Object.entries(router$1._def.lazy)) {
+            const nestedRouterKey = [...lazyPath, nestedKey].join(".");
+            lazy$1[nestedRouterKey] = createLazyLoader({
+              ref: nestedItem.ref,
+              path: lazyPath,
+              key: nestedKey,
+              aggregate: opts.aggregate[opts.key]
+            });
+          }
+        })
+      };
+    }
+    function step(from, path = []) {
+      const aggregate = emptyObject();
+      for (const [key, item] of Object.entries(from !== null && from !== void 0 ? from : {})) {
+        if (isLazy(item)) {
+          lazy$1[[...path, key].join(".")] = createLazyLoader({
+            path,
+            ref: item,
+            key,
+            aggregate
+          });
+          continue;
+        }
+        if (isRouter(item)) {
+          aggregate[key] = step(item._def.record, [...path, key]);
+          continue;
+        }
+        if (!isProcedure(item)) {
+          aggregate[key] = step(item, [...path, key]);
+          continue;
+        }
+        const newPath = [...path, key].join(".");
+        if (procedures[newPath]) throw new Error(`Duplicate key: ${newPath}`);
+        procedures[newPath] = item;
+        aggregate[key] = item;
+      }
+      return aggregate;
+    }
+    const record = step(input);
+    const _def = (0, import_objectSpread22.default)((0, import_objectSpread22.default)({
+      _config: config,
+      router: true,
+      procedures,
+      lazy: lazy$1
+    }, emptyRouter), {}, { record });
+    const router2 = (0, import_objectSpread22.default)((0, import_objectSpread22.default)({}, record), {}, {
+      _def,
+      createCaller: createCallerFactory()({ _def })
+    });
+    return router2;
+  }
+  return createRouterInner;
+}
+function isProcedure(procedureOrRouter) {
+  return typeof procedureOrRouter === "function";
+}
+async function getProcedureAtPath(router2, path) {
+  const { _def } = router2;
+  let procedure = _def.procedures[path];
+  while (!procedure) {
+    const key = Object.keys(_def.lazy).find((key$1) => path.startsWith(key$1));
+    if (!key) return null;
+    const lazyRouter = _def.lazy[key];
+    await lazyRouter.load();
+    procedure = _def.procedures[path];
+  }
+  return procedure;
+}
+function createCallerFactory() {
+  return function createCallerInner(router2) {
+    const { _def } = router2;
+    return function createCaller(ctxOrCallback, opts) {
+      return createRecursiveProxy(async (innerOpts) => {
+        const { path, args } = innerOpts;
+        const fullPath = path.join(".");
+        if (path.length === 1 && path[0] === "_def") return _def;
+        const procedure = await getProcedureAtPath(router2, fullPath);
+        let ctx = void 0;
+        try {
+          if (!procedure) throw new TRPCError({
+            code: "NOT_FOUND",
+            message: `No procedure found on path "${path}"`
+          });
+          ctx = isFunction(ctxOrCallback) ? await Promise.resolve(ctxOrCallback()) : ctxOrCallback;
+          return await procedure({
+            path: fullPath,
+            getRawInput: async () => args[0],
+            ctx,
+            type: procedure._def.type,
+            signal: opts === null || opts === void 0 ? void 0 : opts.signal
+          });
+        } catch (cause) {
+          var _opts$onError, _procedure$_def$type;
+          opts === null || opts === void 0 || (_opts$onError = opts.onError) === null || _opts$onError === void 0 || _opts$onError.call(opts, {
+            ctx,
+            error: getTRPCErrorFromUnknown(cause),
+            input: args[0],
+            path: fullPath,
+            type: (_procedure$_def$type = procedure === null || procedure === void 0 ? void 0 : procedure._def.type) !== null && _procedure$_def$type !== void 0 ? _procedure$_def$type : "unknown"
+          });
+          throw cause;
+        }
+      });
+    };
+  };
+}
+function mergeRouters(...routerList) {
+  var _routerList$, _routerList$2;
+  const record = mergeWithoutOverrides({}, ...routerList.map((r) => r._def.record));
+  const errorFormatter = routerList.reduce((currentErrorFormatter, nextRouter) => {
+    if (nextRouter._def._config.errorFormatter && nextRouter._def._config.errorFormatter !== defaultFormatter) {
+      if (currentErrorFormatter !== defaultFormatter && currentErrorFormatter !== nextRouter._def._config.errorFormatter) throw new Error("You seem to have several error formatters");
+      return nextRouter._def._config.errorFormatter;
+    }
+    return currentErrorFormatter;
+  }, defaultFormatter);
+  const transformer = routerList.reduce((prev, current) => {
+    if (current._def._config.transformer && current._def._config.transformer !== defaultTransformer) {
+      if (prev !== defaultTransformer && prev !== current._def._config.transformer) throw new Error("You seem to have several transformers");
+      return current._def._config.transformer;
+    }
+    return prev;
+  }, defaultTransformer);
+  const router2 = createRouterFactory({
+    errorFormatter,
+    transformer,
+    isDev: routerList.every((r) => r._def._config.isDev),
+    allowOutsideOfServer: routerList.every((r) => r._def._config.allowOutsideOfServer),
+    isServer: routerList.every((r) => r._def._config.isServer),
+    $types: (_routerList$ = routerList[0]) === null || _routerList$ === void 0 ? void 0 : _routerList$._def._config.$types,
+    sse: (_routerList$2 = routerList[0]) === null || _routerList$2 === void 0 ? void 0 : _routerList$2._def._config.sse
+  })(record);
+  return router2;
+}
+
+// ../../node_modules/.pnpm/@trpc+server@11.8.1_typescript@5.9.3/node_modules/@trpc/server/dist/initTRPC-T5bbc89W.mjs
+var import_objectSpread2$2 = __toESM2(require_objectSpread2(), 1);
+var middlewareMarker = "middlewareMarker";
+function createMiddlewareFactory() {
+  function createMiddlewareInner(middlewares) {
+    return {
+      _middlewares: middlewares,
+      unstable_pipe(middlewareBuilderOrFn) {
+        const pipedMiddleware = "_middlewares" in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [middlewareBuilderOrFn];
+        return createMiddlewareInner([...middlewares, ...pipedMiddleware]);
+      }
+    };
+  }
+  function createMiddleware(fn) {
+    return createMiddlewareInner([fn]);
+  }
+  return createMiddleware;
+}
+function createInputMiddleware(parse) {
+  const inputMiddleware = async function inputValidatorMiddleware(opts) {
+    let parsedInput;
+    const rawInput = await opts.getRawInput();
+    try {
+      parsedInput = await parse(rawInput);
+    } catch (cause) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        cause
+      });
+    }
+    const combinedInput = isObject(opts.input) && isObject(parsedInput) ? (0, import_objectSpread2$2.default)((0, import_objectSpread2$2.default)({}, opts.input), parsedInput) : parsedInput;
+    return opts.next({ input: combinedInput });
+  };
+  inputMiddleware._type = "input";
+  return inputMiddleware;
+}
+function createOutputMiddleware(parse) {
+  const outputMiddleware = async function outputValidatorMiddleware({ next }) {
+    const result = await next();
+    if (!result.ok) return result;
+    try {
+      const data = await parse(result.data);
+      return (0, import_objectSpread2$2.default)((0, import_objectSpread2$2.default)({}, result), {}, { data });
+    } catch (cause) {
+      throw new TRPCError({
+        message: "Output validation failed",
+        code: "INTERNAL_SERVER_ERROR",
+        cause
+      });
+    }
+  };
+  outputMiddleware._type = "output";
+  return outputMiddleware;
+}
+var import_defineProperty2 = __toESM2(require_defineProperty(), 1);
+var StandardSchemaV1Error = class extends Error {
+  /**
+  * Creates a schema error with useful information.
+  *
+  * @param issues The schema issues.
+  */
+  constructor(issues) {
+    var _issues$;
+    super((_issues$ = issues[0]) === null || _issues$ === void 0 ? void 0 : _issues$.message);
+    (0, import_defineProperty2.default)(this, "issues", void 0);
+    this.name = "SchemaError";
+    this.issues = issues;
+  }
+};
+function getParseFn(procedureParser) {
+  const parser = procedureParser;
+  const isStandardSchema = "~standard" in parser;
+  if (typeof parser === "function" && typeof parser.assert === "function") return parser.assert.bind(parser);
+  if (typeof parser === "function" && !isStandardSchema) return parser;
+  if (typeof parser.parseAsync === "function") return parser.parseAsync.bind(parser);
+  if (typeof parser.parse === "function") return parser.parse.bind(parser);
+  if (typeof parser.validateSync === "function") return parser.validateSync.bind(parser);
+  if (typeof parser.create === "function") return parser.create.bind(parser);
+  if (typeof parser.assert === "function") return (value) => {
+    parser.assert(value);
+    return value;
+  };
+  if (isStandardSchema) return async (value) => {
+    const result = await parser["~standard"].validate(value);
+    if (result.issues) throw new StandardSchemaV1Error(result.issues);
+    return result.value;
+  };
+  throw new Error("Could not find a validator fn");
+}
+var require_objectWithoutPropertiesLoose = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutPropertiesLoose.js"(exports, module) {
+  function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t2 = {};
+    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+      if (e.includes(n)) continue;
+      t2[n] = r[n];
+    }
+    return t2;
+  }
+  module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var require_objectWithoutProperties = __commonJS2({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectWithoutProperties.js"(exports, module) {
+  var objectWithoutPropertiesLoose = require_objectWithoutPropertiesLoose();
+  function _objectWithoutProperties$1(e, t2) {
+    if (null == e) return {};
+    var o, r, i = objectWithoutPropertiesLoose(e, t2);
+    if (Object.getOwnPropertySymbols) {
+      var s = Object.getOwnPropertySymbols(e);
+      for (r = 0; r < s.length; r++) o = s[r], t2.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+    }
+    return i;
+  }
+  module.exports = _objectWithoutProperties$1, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+var import_objectWithoutProperties = __toESM2(require_objectWithoutProperties(), 1);
+var import_objectSpread2$12 = __toESM2(require_objectSpread2(), 1);
+var _excluded = [
+  "middlewares",
+  "inputs",
+  "meta"
+];
+function createNewBuilder(def1, def2) {
+  const { middlewares = [], inputs, meta } = def2, rest = (0, import_objectWithoutProperties.default)(def2, _excluded);
+  return createBuilder((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, mergeWithoutOverrides(def1, rest)), {}, {
+    inputs: [...def1.inputs, ...inputs !== null && inputs !== void 0 ? inputs : []],
+    middlewares: [...def1.middlewares, ...middlewares],
+    meta: def1.meta && meta ? (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, def1.meta), meta) : meta !== null && meta !== void 0 ? meta : def1.meta
+  }));
+}
+function createBuilder(initDef = {}) {
+  const _def = (0, import_objectSpread2$12.default)({
+    procedure: true,
+    inputs: [],
+    middlewares: []
+  }, initDef);
+  const builder = {
+    _def,
+    input(input) {
+      const parser = getParseFn(input);
+      return createNewBuilder(_def, {
+        inputs: [input],
+        middlewares: [createInputMiddleware(parser)]
+      });
+    },
+    output(output) {
+      const parser = getParseFn(output);
+      return createNewBuilder(_def, {
+        output,
+        middlewares: [createOutputMiddleware(parser)]
+      });
+    },
+    meta(meta) {
+      return createNewBuilder(_def, { meta });
+    },
+    use(middlewareBuilderOrFn) {
+      const middlewares = "_middlewares" in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [middlewareBuilderOrFn];
+      return createNewBuilder(_def, { middlewares });
+    },
+    unstable_concat(builder$1) {
+      return createNewBuilder(_def, builder$1._def);
+    },
+    concat(builder$1) {
+      return createNewBuilder(_def, builder$1._def);
+    },
+    query(resolver) {
+      return createResolver((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, _def), {}, { type: "query" }), resolver);
+    },
+    mutation(resolver) {
+      return createResolver((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, _def), {}, { type: "mutation" }), resolver);
+    },
+    subscription(resolver) {
+      return createResolver((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, _def), {}, { type: "subscription" }), resolver);
+    },
+    experimental_caller(caller) {
+      return createNewBuilder(_def, { caller });
+    }
+  };
+  return builder;
+}
+function createResolver(_defIn, resolver) {
+  const finalBuilder = createNewBuilder(_defIn, {
+    resolver,
+    middlewares: [async function resolveMiddleware(opts) {
+      const data = await resolver(opts);
+      return {
+        marker: middlewareMarker,
+        ok: true,
+        data,
+        ctx: opts.ctx
+      };
+    }]
+  });
+  const _def = (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, finalBuilder._def), {}, {
+    type: _defIn.type,
+    experimental_caller: Boolean(finalBuilder._def.caller),
+    meta: finalBuilder._def.meta,
+    $types: null
+  });
+  const invoke = createProcedureCaller(finalBuilder._def);
+  const callerOverride = finalBuilder._def.caller;
+  if (!callerOverride) return invoke;
+  const callerWrapper = async (...args) => {
+    return await callerOverride({
+      args,
+      invoke,
+      _def
+    });
+  };
+  callerWrapper._def = _def;
+  return callerWrapper;
+}
+var codeblock = `
+This is a client-only function.
+If you want to call this function on the server, see https://trpc.io/docs/v11/server/server-side-calls
+`.trim();
+async function callRecursive(index, _def, opts) {
+  try {
+    const middleware2 = _def.middlewares[index];
+    const result = await middleware2((0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, opts), {}, {
+      meta: _def.meta,
+      input: opts.input,
+      next(_nextOpts) {
+        var _nextOpts$getRawInput;
+        const nextOpts = _nextOpts;
+        return callRecursive(index + 1, _def, (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, opts), {}, {
+          ctx: (nextOpts === null || nextOpts === void 0 ? void 0 : nextOpts.ctx) ? (0, import_objectSpread2$12.default)((0, import_objectSpread2$12.default)({}, opts.ctx), nextOpts.ctx) : opts.ctx,
+          input: nextOpts && "input" in nextOpts ? nextOpts.input : opts.input,
+          getRawInput: (_nextOpts$getRawInput = nextOpts === null || nextOpts === void 0 ? void 0 : nextOpts.getRawInput) !== null && _nextOpts$getRawInput !== void 0 ? _nextOpts$getRawInput : opts.getRawInput
+        }));
+      }
+    }));
+    return result;
+  } catch (cause) {
+    return {
+      ok: false,
+      error: getTRPCErrorFromUnknown(cause),
+      marker: middlewareMarker
+    };
+  }
+}
+function createProcedureCaller(_def) {
+  async function procedure(opts) {
+    if (!opts || !("getRawInput" in opts)) throw new Error(codeblock);
+    const result = await callRecursive(0, _def, opts);
+    if (!result) throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "No result from middlewares - did you forget to `return next()`?"
+    });
+    if (!result.ok) throw result.error;
+    return result.data;
+  }
+  procedure._def = _def;
+  procedure.procedure = true;
+  procedure.meta = _def.meta;
+  return procedure;
+}
+var _globalThis$process;
+var _globalThis$process2;
+var _globalThis$process3;
+var isServerDefault = typeof window === "undefined" || "Deno" in window || ((_globalThis$process = globalThis.process) === null || _globalThis$process === void 0 || (_globalThis$process = _globalThis$process.env) === null || _globalThis$process === void 0 ? void 0 : _globalThis$process["NODE_ENV"]) === "test" || !!((_globalThis$process2 = globalThis.process) === null || _globalThis$process2 === void 0 || (_globalThis$process2 = _globalThis$process2.env) === null || _globalThis$process2 === void 0 ? void 0 : _globalThis$process2["JEST_WORKER_ID"]) || !!((_globalThis$process3 = globalThis.process) === null || _globalThis$process3 === void 0 || (_globalThis$process3 = _globalThis$process3.env) === null || _globalThis$process3 === void 0 ? void 0 : _globalThis$process3["VITEST_WORKER_ID"]);
+var import_objectSpread23 = __toESM2(require_objectSpread2(), 1);
+var TRPCBuilder = class TRPCBuilder2 {
+  /**
+  * Add a context shape as a generic to the root object
+  * @see https://trpc.io/docs/v11/server/context
+  */
+  context() {
+    return new TRPCBuilder2();
+  }
+  /**
+  * Add a meta shape as a generic to the root object
+  * @see https://trpc.io/docs/v11/quickstart
+  */
+  meta() {
+    return new TRPCBuilder2();
+  }
+  /**
+  * Create the root object
+  * @see https://trpc.io/docs/v11/server/routers#initialize-trpc
+  */
+  create(opts) {
+    var _opts$transformer, _opts$isDev, _globalThis$process$1, _opts$allowOutsideOfS, _opts$errorFormatter, _opts$isServer;
+    const config = (0, import_objectSpread23.default)((0, import_objectSpread23.default)({}, opts), {}, {
+      transformer: getDataTransformer((_opts$transformer = opts === null || opts === void 0 ? void 0 : opts.transformer) !== null && _opts$transformer !== void 0 ? _opts$transformer : defaultTransformer),
+      isDev: (_opts$isDev = opts === null || opts === void 0 ? void 0 : opts.isDev) !== null && _opts$isDev !== void 0 ? _opts$isDev : ((_globalThis$process$1 = globalThis.process) === null || _globalThis$process$1 === void 0 ? void 0 : _globalThis$process$1.env["NODE_ENV"]) !== "production",
+      allowOutsideOfServer: (_opts$allowOutsideOfS = opts === null || opts === void 0 ? void 0 : opts.allowOutsideOfServer) !== null && _opts$allowOutsideOfS !== void 0 ? _opts$allowOutsideOfS : false,
+      errorFormatter: (_opts$errorFormatter = opts === null || opts === void 0 ? void 0 : opts.errorFormatter) !== null && _opts$errorFormatter !== void 0 ? _opts$errorFormatter : defaultFormatter,
+      isServer: (_opts$isServer = opts === null || opts === void 0 ? void 0 : opts.isServer) !== null && _opts$isServer !== void 0 ? _opts$isServer : isServerDefault,
+      $types: null
+    });
+    {
+      var _opts$isServer2;
+      const isServer = (_opts$isServer2 = opts === null || opts === void 0 ? void 0 : opts.isServer) !== null && _opts$isServer2 !== void 0 ? _opts$isServer2 : isServerDefault;
+      if (!isServer && (opts === null || opts === void 0 ? void 0 : opts.allowOutsideOfServer) !== true) throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
+    }
+    return {
+      _config: config,
+      procedure: createBuilder({ meta: opts === null || opts === void 0 ? void 0 : opts.defaultMeta }),
+      middleware: createMiddlewareFactory(),
+      router: createRouterFactory(config),
+      mergeRouters,
+      createCallerFactory: createCallerFactory()
+    };
+  }
+};
+var initTRPC = new TRPCBuilder();
+
+// ../../packages/schema/dist/index.mjs
+var A2ATextPartSchema = z3.object({
+  type: z3.literal("text"),
+  text: z3.string()
+});
+var A2ADataPartSchema = z3.object({
+  type: z3.literal("data"),
+  data: z3.unknown()
+});
+var A2AFilePartSchema = z3.object({
+  type: z3.literal("file"),
+  uri: z3.string(),
+  mediaType: z3.string().optional(),
+  name: z3.string().optional()
+});
+var A2APartSchema = z3.object({ type: z3.enum([
+  "text",
+  "data",
+  "file"
+]) }).passthrough().superRefine((val, ctx) => {
+  if (val.type === "text") {
+    if (typeof val.text !== "string") ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "text part must have a string text field"
+    });
+  } else if (val.type === "data") {
+    if (!("data" in val)) ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "data part must have a data field"
+    });
+  } else if (val.type === "file") {
+    if (typeof val.uri !== "string") ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "file part must have a string uri field"
+    });
+  }
+});
+function isValidA2APart(part) {
+  if (!part || typeof part !== "object") return false;
+  const p = part;
+  const t$1 = p.type;
+  if (t$1 === "text") return typeof p.text === "string";
+  else if (t$1 === "data") return "data" in p;
+  else if (t$1 === "file") return typeof p.uri === "string";
+  return false;
+}
+function isValidA2AParts(parts) {
+  if (!Array.isArray(parts)) return false;
+  return parts.every(isValidA2APart);
+}
+var A2AMessageSchema = z3.object({
+  messageId: z3.string(),
+  role: z3.enum(["user", "agent"]),
+  contextId: z3.string().optional(),
+  taskId: z3.string().optional(),
+  referenceTaskIds: z3.array(z3.string()).optional(),
+  metadata: z3.record(z3.string(), z3.unknown()).optional(),
+  extensions: z3.array(z3.string()).optional()
+}).passthrough().refine((val) => {
+  const parts = val.parts;
+  return isValidA2AParts(parts);
+}, {
+  message: "Invalid parts array - each part must have valid type and required fields",
+  path: ["parts"]
+}).transform((val) => ({
+  ...val,
+  parts: val.parts
+}));
+var ConversationExportMetaSchema = z3.object({
+  exportId: z3.string(),
+  sourcePlatform: z3.string(),
+  sourceSessionId: z3.string(),
+  planId: z3.string(),
+  exportedAt: z3.number(),
+  messageCount: z3.number(),
+  compressedBytes: z3.number(),
+  uncompressedBytes: z3.number()
+});
+z3.object({
+  type: z3.literal("text"),
+  text: z3.string()
+});
+z3.object({
+  type: z3.literal("tool_use"),
+  id: z3.string(),
+  name: z3.string(),
+  input: z3.record(z3.string(), z3.unknown())
+});
+z3.object({
+  type: z3.literal("tool_result"),
+  tool_use_id: z3.string(),
+  content: z3.unknown(),
+  is_error: z3.boolean().optional()
+});
+var ClaudeCodeContentBlockSchema = z3.object({ type: z3.enum([
+  "text",
+  "tool_use",
+  "tool_result"
+]) }).passthrough().superRefine((val, ctx) => {
+  const typedVal = val;
+  if (val.type === "text") {
+    if (typeof typedVal.text !== "string") ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "text block must have a string text field"
+    });
+  } else if (val.type === "tool_use") {
+    if (typeof typedVal.id !== "string") ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "tool_use block must have a string id field"
+    });
+    if (typeof typedVal.name !== "string") ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "tool_use block must have a string name field"
+    });
+    if (typeof typedVal.input !== "object" || typedVal.input === null) ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "tool_use block must have an object input field"
+    });
+  } else if (val.type === "tool_result") {
+    if (typeof typedVal.tool_use_id !== "string") ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "tool_result block must have a string tool_use_id field"
+    });
+  }
+});
+var ClaudeCodeUsageSchema = z3.object({
+  input_tokens: z3.number(),
+  output_tokens: z3.number(),
+  cache_creation_input_tokens: z3.number().optional(),
+  cache_read_input_tokens: z3.number().optional()
+});
+var ClaudeCodeMessageInnerSchema = z3.object({
+  role: z3.string(),
+  content: z3.array(ClaudeCodeContentBlockSchema),
+  id: z3.string().optional(),
+  model: z3.string().optional(),
+  usage: ClaudeCodeUsageSchema.optional()
+});
+var ClaudeCodeMessageSchema = z3.object({
+  sessionId: z3.string(),
+  type: z3.enum([
+    "user",
+    "assistant",
+    "summary"
+  ]),
+  message: ClaudeCodeMessageInnerSchema,
+  uuid: z3.string(),
+  timestamp: z3.string(),
+  parentUuid: z3.string().optional(),
+  costUSD: z3.number().optional(),
+  durationMs: z3.number().optional()
+});
+var GitHubPRResponseSchema = z3.object({
+  number: z3.number(),
+  html_url: z3.string().url(),
+  title: z3.string(),
+  state: z3.enum(["open", "closed"]),
+  draft: z3.boolean(),
+  merged: z3.boolean(),
+  head: z3.object({ ref: z3.string() })
+});
+var InviteTokenSchema = z3.object({
+  id: z3.string(),
+  tokenHash: z3.string(),
+  planId: z3.string(),
+  createdBy: z3.string(),
+  createdAt: z3.number(),
+  expiresAt: z3.number(),
+  maxUses: z3.number().nullable(),
+  useCount: z3.number(),
+  revoked: z3.boolean(),
+  label: z3.string().optional()
+});
+var InviteRedemptionSchema = z3.object({
+  redeemedBy: z3.string(),
+  redeemedAt: z3.number(),
+  tokenId: z3.string()
+});
+var ConversationExportStartMetaSchema = z3.object({
+  exportId: z3.string(),
+  totalChunks: z3.number().int().positive(),
+  totalBytes: z3.number().int().nonnegative(),
+  compressedBytes: z3.number().int().nonnegative(),
+  sourcePlatform: z3.string(),
+  sourceSessionId: z3.string(),
+  planId: z3.string(),
+  exportedAt: z3.number().int().positive()
+});
+var ChunkMessageSchema = z3.object({
+  exportId: z3.string(),
+  chunkIndex: z3.number().int().nonnegative(),
+  data: z3.instanceof(Uint8Array)
+});
+var ConversationExportEndSchema = z3.object({
+  exportId: z3.string(),
+  checksum: z3.string()
+});
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var PlanIndexEntrySchema = z3.discriminatedUnion("deleted", [z3.object({
+  deleted: z3.literal(false),
+  id: z3.string(),
+  title: z3.string(),
+  status: z3.enum(PlanStatusValues),
+  createdAt: z3.number(),
+  updatedAt: z3.number(),
+  ownerId: z3.string(),
+  tags: z3.array(z3.string()).optional()
+}), z3.object({
+  deleted: z3.literal(true),
+  id: z3.string(),
+  title: z3.string(),
+  status: z3.enum(PlanStatusValues),
+  createdAt: z3.number(),
+  updatedAt: z3.number(),
+  ownerId: z3.string(),
+  tags: z3.array(z3.string()).optional(),
+  deletedAt: z3.number(),
+  deletedBy: z3.string()
+})]);
+function formatThreadsForLLM(threads, options = {}) {
+  const { includeResolved = false, selectedTextMaxLength = 100, resolveUser } = options;
+  const unresolvedThreads = threads.filter((t$1) => !t$1.resolved);
+  const resolvedCount = threads.length - unresolvedThreads.length;
+  const threadsToShow = includeResolved ? threads : unresolvedThreads;
+  if (threadsToShow.length === 0) {
+    if (resolvedCount > 0) return `All ${resolvedCount} comment(s) have been resolved.`;
+    return "";
+  }
+  let output = threadsToShow.map((thread, index) => {
+    const location = thread.selectedText ? `On: "${truncate(thread.selectedText, selectedTextMaxLength)}"` : `Comment ${index + 1}`;
+    const comments = thread.comments.map((c, idx) => {
+      const text = extractTextFromCommentBody(c.body);
+      const author = resolveUser ? resolveUser(c.userId) : c.userId.slice(0, 8);
+      if (idx === 0) return `${author}: ${text}`;
+      return `${author} (reply): ${text}`;
+    }).join("\n");
+    return `${location}${thread.resolved ? " [Resolved]" : ""}
+${comments}`;
+  }).join("\n\n");
+  if (!includeResolved && resolvedCount > 0) output += `
+
+---
+(${resolvedCount} resolved comment(s) not shown)`;
+  return output;
+}
+function truncate(text, maxLength) {
+  const cleaned = text.replace(/\n/g, " ").trim();
+  if (cleaned.length <= maxLength) return cleaned;
+  return `${cleaned.slice(0, maxLength)}...`;
+}
+var PlanIdSchema = z3.object({ planId: z3.string().min(1) });
+var PlanStatusResponseSchema = z3.object({ status: z3.string() });
+var HasConnectionsResponseSchema = z3.object({ hasConnections: z3.boolean() });
+var SubscriptionClientIdSchema = z3.object({
+  planId: z3.string().min(1),
+  clientId: z3.string().min(1)
+});
+var ChangeTypeSchema = z3.enum([
+  "status",
+  "comments",
+  "resolved",
+  "content",
+  "artifacts"
+]);
+var ChangeSchema = z3.object({
+  type: ChangeTypeSchema,
+  timestamp: z3.number(),
+  summary: z3.string(),
+  details: z3.record(z3.string(), z3.unknown()).optional()
+});
+var ChangesResponseSchema = z3.discriminatedUnion("ready", [z3.object({
+  ready: z3.literal(true),
+  changes: z3.string(),
+  details: z3.array(ChangeSchema)
+}), z3.object({
+  ready: z3.literal(false),
+  pending: z3.number(),
+  windowExpiresIn: z3.number()
+})]);
+var DeleteSubscriptionResponseSchema = z3.object({ success: z3.boolean() });
+var SetSessionTokenRequestSchema = z3.object({ sessionTokenHash: z3.string().min(1) });
+var GetDeliverableContextRequestSchema = z3.object({ sessionToken: z3.string().min(1) });
+var GetDeliverableContextResponseSchema = z3.object({ context: z3.string() });
+var SetSessionTokenResponseSchema = z3.object({ url: z3.string() });
+var ImportConversationRequestSchema = z3.object({
+  a2aMessages: z3.array(A2AMessageSchema),
+  meta: z3.object({
+    planId: z3.string().optional(),
+    sourcePlatform: z3.string().optional(),
+    sessionId: z3.string().optional()
+  }).optional()
+});
+var ImportConversationResponseSchema = z3.discriminatedUnion("success", [z3.object({
+  success: z3.literal(true),
+  sessionId: z3.string(),
+  transcriptPath: z3.string(),
+  messageCount: z3.number()
+}), z3.object({
+  success: z3.literal(false),
+  error: z3.string()
+})]);
+var t = initTRPC.context().create({ allowOutsideOfServer: true });
+var router = t.router;
+var publicProcedure = t.procedure;
+var middleware = t.middleware;
+var conversationRouter = router({ import: publicProcedure.input(ImportConversationRequestSchema).output(ImportConversationResponseSchema).mutation(async ({ input, ctx }) => {
+  return ctx.conversationHandlers.importConversation(input, ctx);
+}) });
+var hookRouter = router({
+  createSession: publicProcedure.input(CreateHookSessionRequestSchema).output(CreateHookSessionResponseSchema).mutation(async ({ input, ctx }) => {
+    return ctx.hookHandlers.createSession(input, ctx);
+  }),
+  updateContent: publicProcedure.input(PlanIdSchema.merge(UpdatePlanContentRequestSchema)).output(UpdatePlanContentResponseSchema).mutation(async ({ input, ctx }) => {
+    const { planId, ...contentInput } = input;
+    return ctx.hookHandlers.updateContent(planId, contentInput, ctx);
+  }),
+  getReviewStatus: publicProcedure.input(PlanIdSchema).output(GetReviewStatusResponseSchema).query(async ({ input, ctx }) => {
+    return ctx.hookHandlers.getReviewStatus(input.planId, ctx);
+  }),
+  updatePresence: publicProcedure.input(PlanIdSchema.merge(UpdatePresenceRequestSchema)).output(UpdatePresenceResponseSchema).mutation(async ({ input, ctx }) => {
+    const { planId, ...presenceInput } = input;
+    return ctx.hookHandlers.updatePresence(planId, presenceInput, ctx);
+  }),
+  setSessionToken: publicProcedure.input(PlanIdSchema.merge(SetSessionTokenRequestSchema)).output(SetSessionTokenResponseSchema).mutation(async ({ input, ctx }) => {
+    const { planId, sessionTokenHash } = input;
+    return ctx.hookHandlers.setSessionToken(planId, sessionTokenHash, ctx);
+  }),
+  waitForApproval: publicProcedure.input(z3.object({
+    planId: z3.string(),
+    reviewRequestId: z3.string()
+  })).output(z3.object({
+    approved: z3.boolean(),
+    feedback: z3.string().optional(),
+    deliverables: z3.array(z3.any()).optional(),
+    reviewComment: z3.string().optional(),
+    reviewedBy: z3.string().optional(),
+    status: z3.string().optional()
+  })).mutation(async ({ input, ctx }) => {
+    const { planId, reviewRequestId } = input;
+    return ctx.hookHandlers.waitForApproval(planId, reviewRequestId, ctx);
+  }),
+  getDeliverableContext: publicProcedure.input(PlanIdSchema.merge(GetDeliverableContextRequestSchema)).output(GetDeliverableContextResponseSchema).query(async ({ input, ctx }) => {
+    const { planId, sessionToken } = input;
+    return ctx.hookHandlers.getDeliverableContext(planId, sessionToken, ctx);
+  }),
+  getSessionContext: publicProcedure.input(z3.object({ sessionId: z3.string() })).output(z3.discriminatedUnion("found", [z3.object({
+    found: z3.literal(true),
+    planId: z3.string(),
+    sessionToken: z3.string(),
+    url: z3.string(),
+    deliverables: z3.array(z3.object({
+      id: z3.string(),
+      text: z3.string()
+    })),
+    reviewComment: z3.string().optional(),
+    reviewedBy: z3.string().optional(),
+    reviewStatus: z3.string().optional()
+  }), z3.object({ found: z3.literal(false) })])).query(async ({ input, ctx }) => {
+    return ctx.hookHandlers.getSessionContext(input.sessionId, ctx);
+  })
+});
+var planRouter = router({
+  getStatus: publicProcedure.input(PlanIdSchema).output(PlanStatusResponseSchema).query(async ({ input, ctx }) => {
+    const metadata = getPlanMetadata(await ctx.getOrCreateDoc(input.planId));
+    if (!metadata) throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Plan not found"
+    });
+    return { status: metadata.status };
+  }),
+  hasConnections: publicProcedure.input(PlanIdSchema).output(HasConnectionsResponseSchema).query(async ({ input, ctx }) => {
+    return { hasConnections: await ctx.getPlanStore().hasActiveConnections(input.planId) };
+  })
+});
+var subscriptionRouter = router({
+  create: publicProcedure.input(PlanIdSchema.merge(CreateSubscriptionRequestSchema)).output(CreateSubscriptionResponseSchema).mutation(async ({ input, ctx }) => {
+    const { planId, subscribe, windowMs, maxWindowMs, threshold } = input;
+    return { clientId: ctx.getPlanStore().createSubscription({
+      planId,
+      subscribe: subscribe || ["status"],
+      windowMs: windowMs ?? 5e3,
+      maxWindowMs: maxWindowMs ?? 3e4,
+      threshold: threshold ?? 1
+    }) };
+  }),
+  getChanges: publicProcedure.input(SubscriptionClientIdSchema).output(ChangesResponseSchema).query(async ({ input, ctx }) => {
+    const { planId, clientId } = input;
+    const result = ctx.getPlanStore().getChanges(planId, clientId);
+    if (!result) throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Subscription not found"
+    });
+    return result;
+  }),
+  delete: publicProcedure.input(SubscriptionClientIdSchema).output(DeleteSubscriptionResponseSchema).mutation(async ({ input, ctx }) => {
+    const { planId, clientId } = input;
+    return { success: ctx.getPlanStore().deleteSubscription(planId, clientId) };
+  })
+});
+var appRouter = router({
+  hook: hookRouter,
+  plan: planRouter,
+  subscription: subscriptionRouter,
+  conversation: conversationRouter
+});
+
+// src/adapters/claude-code.ts
+import { z as z6 } from "zod";
+
+// src/constants.ts
+var CLAUDE_TOOL_NAMES = {
+  WRITE: "Write",
+  EDIT: "Edit",
+  EXIT_PLAN_MODE: "ExitPlanMode",
+  ASK_USER_QUESTION: "AskUserQuestion"
+};
+var MCP_TOOL_NAMES = {
+  REQUEST_USER_INPUT: "request_user_input"
+};
+var CLAUDE_PERMISSION_MODES = {
+  PLAN: "plan",
+  DEFAULT: "default",
+  ACCEPT_EDITS: "acceptEdits",
+  DONT_ASK: "dontAsk",
+  BYPASS_PERMISSIONS: "bypassPermissions"
+};
+var CLAUDE_HOOK_EVENTS = {
+  PRE_TOOL_USE: "PreToolUse",
+  POST_TOOL_USE: "PostToolUse",
+  PERMISSION_REQUEST: "PermissionRequest"
+};
+var DEFAULT_AGENT_TYPE = "claude-code";
+
+// src/logger.ts
+import { homedir } from "os";
+import { join } from "path";
+import pino from "pino";
+
+// src/config/env/server.ts
+import { z as z5 } from "zod";
+
+// src/config/config.ts
+import { z as z4 } from "zod";
+function loadEnv(schema4) {
+  try {
+    return schema4.parse(process.env);
+  } catch (error) {
+    if (error instanceof z4.ZodError) {
+      const testResult = schema4.safeParse(void 0);
+      if (testResult.success) {
+        return testResult.data;
+      }
+      if (!error.issues || !Array.isArray(error.issues)) {
+        throw new Error("Environment variable validation failed (no error details available)");
+      }
+      const errorMessages = error.issues.map((err) => ` - ${err.path.join(".")}: ${err.message}`).join("\n");
+      throw new Error(`Environment variable validation failed: 
+${errorMessages}`);
+    }
+    throw error;
+  }
+}
+
+// src/config/env/server.ts
+var schema = z5.object({
+  LOG_LEVEL: z5.enum(["debug", "info", "warn", "error"]).default("info")
+});
+var serverConfig = loadEnv(schema);
+
+// src/logger.ts
+var LOG_FILE = join(homedir(), ".shipyard", "hook-debug.log");
+var logger = pino(
+  {
+    level: serverConfig.LOG_LEVEL,
+    timestamp: pino.stdTimeFunctions.isoTime
+  },
+  pino.multistream([{ stream: pino.destination(2) }, { stream: pino.destination(LOG_FILE) }])
+);
+
+// src/adapters/claude-code.ts
+var ClaudeCodeHookBaseSchema = z6.object({
+  session_id: z6.string(),
+  transcript_path: z6.string().optional(),
+  cwd: z6.string().optional(),
+  permission_mode: z6.enum([
+    CLAUDE_PERMISSION_MODES.DEFAULT,
+    CLAUDE_PERMISSION_MODES.PLAN,
+    CLAUDE_PERMISSION_MODES.ACCEPT_EDITS,
+    CLAUDE_PERMISSION_MODES.DONT_ASK,
+    CLAUDE_PERMISSION_MODES.BYPASS_PERMISSIONS
+  ]),
+  hook_event_name: z6.string(),
+  tool_name: z6.string().optional(),
+  tool_input: z6.record(z6.string(), z6.unknown()).optional()
+});
+function handlePreToolUse(input) {
+  const toolName = input.tool_name;
+  if (toolName === CLAUDE_TOOL_NAMES.ASK_USER_QUESTION) {
+    logger.info(
+      { toolName },
+      "Blocking AskUserQuestion - redirecting to request_user_input MCP tool"
+    );
+    return {
+      type: "tool_deny",
+      reason: `BLOCKED: Use the ${MCP_TOOL_NAMES.REQUEST_USER_INPUT} MCP tool instead for consistent browser UI. See the tool description for available parameters.`
+    };
+  }
+  return { type: "passthrough" };
+}
+var ExitPlanModeToolInputSchema = z6.object({
+  plan: z6.string()
+});
+function handlePermissionRequest(input) {
+  const sessionId = input.session_id;
+  const toolName = input.tool_name;
+  if (toolName === CLAUDE_TOOL_NAMES.EXIT_PLAN_MODE) {
+    logger.info(
+      {
+        toolInput: input.tool_input,
+        toolInputKeys: input.tool_input ? Object.keys(input.tool_input) : []
+      },
+      "ExitPlanMode tool_input received"
+    );
+    const parsed = ExitPlanModeToolInputSchema.safeParse(input.tool_input);
+    if (!parsed.success) {
+      logger.warn(
+        { parseError: parsed.error?.issues, toolInput: input.tool_input },
+        "ExitPlanMode tool_input parse failed - no plan content"
+      );
+      return { type: "plan_exit", sessionId };
+    }
+    return {
+      type: "plan_exit",
+      sessionId,
+      planContent: parsed.data.plan,
+      metadata: {
+        originSessionId: input.session_id,
+        originTranscriptPath: input.transcript_path,
+        originCwd: input.cwd
+      }
+    };
+  }
+  return { type: "passthrough" };
+}
+function handlePostToolUse(input) {
+  const sessionId = input.session_id;
+  const toolName = input.tool_name;
+  if (toolName === CLAUDE_TOOL_NAMES.EXIT_PLAN_MODE) {
+    return {
+      type: "post_exit",
+      sessionId,
+      toolName
+    };
+  }
+  return { type: "passthrough" };
+}
+var claudeCodeAdapter = {
+  name: "claude-code",
+  parseInput(stdin) {
+    let input;
+    try {
+      const parsed = JSON.parse(stdin);
+      input = ClaudeCodeHookBaseSchema.parse(parsed);
+    } catch {
+      return { type: "passthrough" };
+    }
+    if (input.hook_event_name === CLAUDE_HOOK_EVENTS.PRE_TOOL_USE) {
+      return handlePreToolUse(input);
+    }
+    if (input.permission_mode !== CLAUDE_PERMISSION_MODES.PLAN) {
+      return { type: "passthrough" };
+    }
+    if (input.hook_event_name === CLAUDE_HOOK_EVENTS.PERMISSION_REQUEST) {
+      return handlePermissionRequest(input);
+    }
+    if (input.hook_event_name === CLAUDE_HOOK_EVENTS.POST_TOOL_USE) {
+      return handlePostToolUse(input);
+    }
+    return { type: "passthrough" };
+  },
+  formatOutput(response) {
+    if (response.hookType === "tool_deny") {
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: CLAUDE_HOOK_EVENTS.PRE_TOOL_USE,
+          permissionDecision: "deny",
+          permissionDecisionReason: response.denyReason || "Tool call denied by hook"
+        }
+      });
+    }
+    if (response.hookType === "post_tool_use") {
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: CLAUDE_HOOK_EVENTS.POST_TOOL_USE,
+          additionalContext: response.additionalContext || ""
+        }
+      });
+    }
+    if (response.allow) {
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: CLAUDE_HOOK_EVENTS.PERMISSION_REQUEST,
+          decision: {
+            behavior: "allow",
+            message: response.message
+          }
+        }
+      });
+    }
+    const message = response.feedback?.length ? formatFeedback(response.feedback) : response.message || "Changes requested";
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: CLAUDE_HOOK_EVENTS.PERMISSION_REQUEST,
+        decision: {
+          behavior: "deny",
+          message
+        }
+      }
+    });
+  }
+};
+function formatFeedback(feedback) {
+  if (!feedback.length) {
+    return "Changes requested. Check the plan for reviewer comments.";
+  }
+  const threads = feedback.map((f) => ({
+    id: f.threadId,
+    comments: f.comments.map((c) => ({
+      id: c.author,
+      userId: c.author,
+      body: c.content,
+      createdAt: c.createdAt
+    })),
+    selectedText: f.blockId ? `Block ${f.blockId}` : void 0
+  }));
+  const feedbackText = formatThreadsForLLM(threads, {
+    includeResolved: false,
+    selectedTextMaxLength: 100
+  });
+  return `Changes requested:
+
+${feedbackText}`;
+}
+
+// ../../packages/shared/dist/registry-config.mjs
+var DEFAULT_REGISTRY_PORTS = [32191, 32192];
+
+// ../../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/config/env/registry.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { z as z7 } from "zod";
+var schema2 = z7.object({
+  REGISTRY_PORT: z7.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: z7.string().optional().default(() => join2(homedir2(), ".shipyard"))
+});
+var registryConfig = loadEnv(schema2);
+
+// src/trpc-client.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+var cachedClient = null;
+var cachedBaseUrl = null;
+function getTRPCClient(baseUrl, timeoutMs = DEFAULT_TRPC_TIMEOUT_MS) {
+  if (timeoutMs !== DEFAULT_TRPC_TIMEOUT_MS) {
+    return createTRPCClient({
+      links: [
+        httpBatchLink({
+          url: `${baseUrl}/trpc`,
+          fetch: (url, options) => {
+            return fetch(url, {
+              ...options,
+              signal: AbortSignal.timeout(timeoutMs)
+            });
+          }
+        })
+      ]
+    });
+  }
+  if (cachedClient && cachedBaseUrl === baseUrl) {
+    return cachedClient;
+  }
+  cachedClient = createTRPCClient({
+    links: [
+      httpBatchLink({
+        url: `${baseUrl}/trpc`,
+        fetch: (url, options) => {
+          return fetch(url, {
+            ...options,
+            signal: AbortSignal.timeout(timeoutMs)
+          });
+        }
+      })
+    ]
+  });
+  cachedBaseUrl = baseUrl;
+  return cachedClient;
+}
+
+// src/http-client.ts
+async function retryWithBackoff(fn, maxAttempts = 3, baseDelay = 1e3) {
+  let lastError = null;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxAttempts - 1) {
+        const delay = attempt === 0 ? 0 : baseDelay * 2 ** (attempt - 1);
+        logger.debug(
+          { attempt: attempt + 1, maxAttempts, delay },
+          "Registry health check failed, retrying..."
+        );
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+async function getRegistryUrl() {
+  const ports = registryConfig.REGISTRY_PORT;
+  for (const port of ports) {
+    try {
+      const url = `http://localhost:${port}`;
+      await retryWithBackoff(
+        async () => {
+          const res = await fetch(`${url}/registry`, {
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) {
+            throw new Error(`Registry responded with status ${res.status}`);
+          }
+        },
+        3,
+        1e3
+      );
+      logger.debug({ port }, "Found registry server (with retry)");
+      return url;
+    } catch (err) {
+      const error = err;
+      logger.debug(
+        { port, error: error.message },
+        "Failed to connect to registry port after retries"
+      );
+    }
+  }
+  logger.error(
+    {
+      ports,
+      attemptsPerPort: 3,
+      totalTimeout: "15s (5s per attempt * 3 attempts)"
+    },
+    "Registry server not reachable - check if `pnpm dev` is running"
+  );
+  return null;
+}
+async function createSession(request) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl);
+  return trpc.hook.createSession.mutate(request);
+}
+async function updatePlanContent(planId, request) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl);
+  return trpc.hook.updateContent.mutate({ planId, ...request });
+}
+async function getReviewStatus(planId) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl);
+  return trpc.hook.getReviewStatus.query({ planId });
+}
+async function updatePresence(planId, request) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl);
+  return trpc.hook.updatePresence.mutate({ planId, ...request });
+}
+async function setSessionToken(planId, sessionTokenHash) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl);
+  return trpc.hook.setSessionToken.mutate({ planId, sessionTokenHash });
+}
+async function waitForApproval(planId, reviewRequestId) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl, APPROVAL_LONG_POLL_TIMEOUT_MS);
+  return trpc.hook.waitForApproval.mutate({ planId, reviewRequestId });
+}
+async function getSessionContext(sessionId) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl);
+  return trpc.hook.getSessionContext.query({ sessionId });
+}
+async function getDeliverableContext(planId, sessionToken) {
+  const baseUrl = await getRegistryUrl();
+  if (!baseUrl) {
+    throw new Error("Registry server not available");
+  }
+  const trpc = getTRPCClient(baseUrl);
+  return trpc.hook.getDeliverableContext.query({ planId, sessionToken });
+}
+
+// src/core/plan-manager.ts
+var sessionToPlan = /* @__PURE__ */ new Map();
+async function createPlan(options) {
+  const { sessionId, agentType, metadata } = options;
+  logger.info({ sessionId, agentType }, "Creating plan for session");
+  const response = await createSession({
+    sessionId,
+    agentType,
+    metadata
+  });
+  sessionToPlan.set(sessionId, {
+    planId: response.planId
+  });
+  await updatePresence(response.planId, {
+    agentType,
+    sessionId
+  });
+  logger.info({ sessionId, planId: response.planId, url: response.url }, "Plan created by server");
+  return response;
+}
+async function updateContent(options) {
+  const { sessionId, filePath, content, agentType } = options;
+  let session = sessionToPlan.get(sessionId);
+  if (!session) {
+    try {
+      const serverSession = await getSessionContext(sessionId);
+      if (serverSession.found && serverSession.planId) {
+        logger.info(
+          { sessionId, planId: serverSession.planId },
+          "Found existing session on server"
+        );
+        session = { planId: serverSession.planId };
+        sessionToPlan.set(sessionId, session);
+      }
+    } catch (err) {
+      logger.debug({ sessionId, err }, "Could not fetch session from server");
+    }
+  }
+  if (!session) {
+    logger.info({ sessionId, filePath }, "First write detected, creating plan");
+    await createPlan({
+      sessionId,
+      agentType: agentType ?? DEFAULT_AGENT_TYPE,
+      metadata: { filePath }
+    });
+    session = sessionToPlan.get(sessionId);
+    if (!session) {
+      logger.error({ sessionId }, "Failed to track session after plan creation");
+      return false;
+    }
+  }
+  const contentHash = computeHash(content);
+  if (session.lastContentHash === contentHash) {
+    logger.debug({ sessionId }, "Content unchanged, skipping update");
+    return true;
+  }
+  logger.info({ sessionId, planId: session.planId, filePath }, "Updating plan content");
+  await updatePlanContent(session.planId, {
+    content,
+    filePath
+  });
+  sessionToPlan.set(sessionId, {
+    ...session,
+    filePath,
+    lastContentHash: contentHash
+  });
+  if (agentType) {
+    await updatePresence(session.planId, {
+      agentType,
+      sessionId
+    });
+  }
+  return true;
+}
+
+// src/config/env/web.ts
+import { z as z8 } from "zod";
+var schema3 = z8.object({
+  SHIPYARD_WEB_URL: z8.string().url().default("http://localhost:5173")
+});
+var webConfig = loadEnv(schema3);
+
+// src/core/review-status.ts
+async function waitForReviewDecision(planId, _wsUrl) {
+  logger.info({ planId }, "Waiting for approval via server endpoint");
+  const result = await waitForApproval(planId, planId);
+  logger.info({ planId, approved: result.approved }, "Received approval decision from server");
+  return {
+    approved: result.approved,
+    feedback: result.feedback,
+    deliverables: result.deliverables,
+    reviewComment: result.reviewComment,
+    reviewedBy: result.reviewedBy,
+    status: result.status
+  };
+}
+async function handleUpdatedPlanReview(sessionId, planId, planContent, _originMetadata) {
+  logger.info(
+    { planId, contentLength: planContent.length },
+    "Plan content changed, triggering re-review"
+  );
+  logger.info({ planId }, "Syncing updated plan content");
+  try {
+    await updatePlanContent(planId, {
+      content: planContent
+    });
+  } catch (err) {
+    const error = err;
+    if (error.message?.includes("404")) {
+      logger.warn(
+        { planId, sessionId },
+        "Plan not found (404), creating new plan with updated content"
+      );
+      return await checkReviewStatus(sessionId, planContent, _originMetadata);
+    }
+    throw err;
+  }
+  const baseUrl = webConfig.SHIPYARD_WEB_URL;
+  logger.info(
+    { planId, url: `${baseUrl}/plan/${planId}` },
+    "Content synced, browser already open. Waiting for server approval..."
+  );
+  const decision = await waitForReviewDecision(planId, "");
+  logger.info({ planId, approved: decision.approved }, "Decision received via Y.Doc");
+  if (decision.approved) {
+    const sessionToken = generateSessionToken();
+    const sessionTokenHash = hashSessionToken(sessionToken);
+    logger.info({ planId }, "Generating new session token for re-approved plan");
+    try {
+      const tokenResult = await setSessionToken(planId, sessionTokenHash);
+      const url = tokenResult.url;
+      const deliverableCount = (decision.deliverables ?? []).length;
+      logger.info(
+        { planId, url, deliverableCount },
+        "Session token set and stored by server with updated content hash"
+      );
+      const reviewFeedback = decision.reviewComment ? `
+
+Reviewer comment: ${decision.reviewComment}` : "";
+      return {
+        allow: true,
+        message: `Plan re-approved with updates! You have ${deliverableCount} deliverable${deliverableCount === 1 ? "" : "s"}. Use add_artifact(filePath, deliverableId) to upload proof-of-work.${reviewFeedback}`,
+        planId,
+        sessionToken,
+        url
+      };
+    } catch (err) {
+      logger.error({ err, planId }, "Failed to set session token, but plan was approved");
+      return {
+        allow: true,
+        message: "Updated plan approved (session token unavailable)",
+        planId
+      };
+    }
+  }
+  logger.debug({ planId }, "Changes requested - server will manage state cleanup");
+  return {
+    allow: false,
+    message: decision.reviewComment || "Changes requested",
+    planId
+  };
+}
+async function checkReviewStatus(sessionId, planContent, originMetadata) {
+  const state = await getSessionContext(sessionId);
+  let planId;
+  if (!state.found && planContent) {
+    logger.info(
+      { sessionId, contentLength: planContent.length, hasState: !!state },
+      "Creating plan from ExitPlanMode (blocking mode)"
+    );
+    const result = await createPlan({
+      sessionId,
+      agentType: DEFAULT_AGENT_TYPE,
+      metadata: {
+        source: "ExitPlanMode",
+        ...originMetadata
+      }
+    });
+    planId = result.planId;
+    logger.info({ planId }, "Syncing plan content");
+    await updatePlanContent(planId, {
+      content: planContent
+    });
+    logger.info(
+      { planId, url: result.url },
+      "Plan created and synced, browser opened. Waiting for server approval..."
+    );
+    const decision = await waitForReviewDecision(planId, "");
+    logger.info({ planId, approved: decision.approved }, "Decision received via Y.Doc");
+    if (decision.approved) {
+      const sessionToken = generateSessionToken();
+      const sessionTokenHash = hashSessionToken(sessionToken);
+      logger.info({ planId }, "Generating session token for approved plan");
+      try {
+        const tokenResult = await setSessionToken(planId, sessionTokenHash);
+        const url = tokenResult.url;
+        const deliverableCount = (decision.deliverables ?? []).length;
+        logger.info(
+          { planId, url, deliverableCount },
+          "Session token set and stored by server with deliverables"
+        );
+        const reviewFeedback = decision.reviewComment ? `
+
+Reviewer comment: ${decision.reviewComment}` : "";
+        return {
+          allow: true,
+          message: `Plan approved! You have ${deliverableCount} deliverable${deliverableCount === 1 ? "" : "s"}. Use add_artifact(filePath, deliverableId) to upload proof-of-work.${reviewFeedback}`,
+          planId,
+          sessionToken,
+          url
+        };
+      } catch (err) {
+        logger.error({ err, planId }, "Failed to set session token, approving without it");
+        return {
+          allow: true,
+          message: "Plan approved, but session token unavailable. You may need to refresh the plan in the browser. Check ~/.shipyard/server-debug.log for details.",
+          planId
+        };
+      }
+    }
+    logger.debug({ sessionId }, "Changes requested - server will manage state cleanup");
+    return {
+      allow: false,
+      message: decision.reviewComment || "Changes requested",
+      planId
+    };
+  }
+  if (!state.found) {
+    logger.info({ sessionId }, "No session state or plan content, allowing exit");
+    return { allow: true };
+  }
+  if ((!state || !state.planId) && planContent) {
+    logger.error(
+      { sessionId, hasPlanContent: !!planContent, hasState: !!state, statePlanId: state?.planId },
+      "Unreachable state: plan content exists but no session state"
+    );
+    return {
+      allow: false,
+      message: "Internal error: Plan content found but session state missing. Check ~/.shipyard/hook-debug.log and report this issue."
+    };
+  }
+  if (!state.planId) {
+    throw new Error("Unreachable: state.planId should exist at this point");
+  }
+  planId = state.planId;
+  if (planContent) {
+    logger.info({ planId }, "Plan content provided, triggering re-review");
+    return await handleUpdatedPlanReview(sessionId, planId, planContent, originMetadata);
+  }
+  logger.info({ sessionId, planId }, "Checking review status");
+  let status;
+  try {
+    status = await getReviewStatus(planId);
+  } catch (err) {
+    logger.warn({ err, planId }, "Failed to get review status, blocking exit");
+    return {
+      allow: false,
+      message: "Cannot verify plan approval status. Ensure the Shipyard MCP server is running. Check ~/.shipyard/server-debug.log for details.",
+      planId
+    };
+  }
+  logger.info({ sessionId, planId, status: status.status }, "Review status retrieved");
+  const baseUrl = webConfig.SHIPYARD_WEB_URL;
+  switch (status.status) {
+    case "changes_requested":
+      return {
+        allow: false,
+        message: formatFeedbackMessage(status.feedback),
+        feedback: status.feedback,
+        planId
+      };
+    case "pending_review":
+      return {
+        allow: false,
+        message: `Plan is pending review.
+
+Open: ${baseUrl}/plan/${planId}`,
+        planId
+      };
+    case "draft":
+      return {
+        allow: false,
+        message: `Plan is still in draft.
+
+Submit for review at: ${baseUrl}/plan/${planId}`,
+        planId
+      };
+    case "in_progress":
+      return {
+        allow: true,
+        message: "Plan approved. Work is in progress. Use add_artifact(filePath, deliverableId) to upload deliverable proofs.",
+        planId
+      };
+    case "completed":
+      return {
+        allow: true,
+        message: `Task completed by ${status.completedBy}`,
+        planId
+      };
+    default: {
+      assertNever(status);
+    }
+  }
+}
+function formatFeedbackMessage(feedback) {
+  if (!feedback?.length) {
+    return "Changes requested. Check the plan for reviewer comments.";
+  }
+  const lines = feedback.map((f) => {
+    const blockInfo = f.blockId ? `Block ${f.blockId}` : "General";
+    const comments = f.comments.map((c) => `  - ${c.author}: ${c.content}`).join("\n");
+    return `${blockInfo}:
+${comments}`;
+  });
+  return `Changes requested:
+
+${lines.join("\n\n")}`;
+}
+
+// src/index.ts
+function getAdapter() {
+  return claudeCodeAdapter;
+}
+async function handlePlanStart(event) {
+  try {
+    const result = await createPlan({
+      sessionId: event.sessionId,
+      agentType: DEFAULT_AGENT_TYPE,
+      metadata: event.metadata
+    });
+    return {
+      allow: true,
+      message: `Plan created at ${result.url}. Write your plan, mark deliverables with {#deliverable}, then exit plan mode to await approval.`,
+      planId: result.planId,
+      url: result.url
+    };
+  } catch (err) {
+    logger.error({ err }, "Failed to create plan");
+    return { allow: true };
+  }
+}
+async function handleContentUpdate(event) {
+  try {
+    await updateContent({
+      sessionId: event.sessionId,
+      filePath: event.filePath,
+      content: event.content,
+      agentType: DEFAULT_AGENT_TYPE
+    });
+    return { allow: true };
+  } catch (err) {
+    logger.error({ err }, "Failed to update content");
+    throw err;
+  }
+}
+async function handlePlanExit(event) {
+  try {
+    return await checkReviewStatus(event.sessionId, event.planContent, event.metadata);
+  } catch (err) {
+    const error = err;
+    logger.error(
+      { err: error, message: error.message, code: error.code },
+      "Failed to check review status"
+    );
+    const isConnectionError = error.code === "ECONNREFUSED" || error.code === "ECONNRESET" || error.code === "ETIMEDOUT" || error.code === "ENOTFOUND" || error.message?.includes("connect") || error.message?.includes("timeout") || error.message?.includes("WebSocket") || error.message?.includes("not available");
+    const message = isConnectionError ? "Cannot connect to Shipyard server. Ensure the Shipyard MCP server is running. Check ~/.shipyard/hook-debug.log for details." : `Review system error: ${error.message}. Check ~/.shipyard/hook-debug.log for details.`;
+    return {
+      allow: false,
+      message
+    };
+  }
+}
+async function handlePostExit(event) {
+  try {
+    const sessionContext = await getSessionContext(event.sessionId);
+    if (!sessionContext.found) {
+      logger.debug({ sessionId: event.sessionId }, "No session found in registry");
+      return {
+        allow: true,
+        hookType: "post_tool_use",
+        additionalContext: ""
+      };
+    }
+    const { planId, sessionToken, url } = sessionContext;
+    logger.info(
+      { planId, sessionId: event.sessionId },
+      "Injecting session context via PostToolUse"
+    );
+    const result = await getDeliverableContext(planId, sessionToken);
+    return {
+      allow: true,
+      hookType: "post_tool_use",
+      additionalContext: result.context,
+      planId,
+      sessionToken,
+      url
+    };
+  } catch (err) {
+    logger.error({ err, sessionId: event.sessionId }, "Failed to get session context from server");
+    return {
+      allow: true,
+      hookType: "post_tool_use",
+      additionalContext: ""
+    };
+  }
+}
+async function processEvent(_adapter, event) {
+  switch (event.type) {
+    case "plan_start":
+      return handlePlanStart(event);
+    case "content_update":
+      return handleContentUpdate(event);
+    case "plan_exit":
+      return handlePlanExit(event);
+    case "post_exit":
+      return handlePostExit(event);
+    case "disconnect":
+      return { allow: true };
+    case "tool_deny":
+      return {
+        allow: false,
+        hookType: "tool_deny",
+        denyReason: event.reason
+      };
+    case "passthrough":
+      return { allow: true };
+    default: {
+      const _exhaustive = event;
+      logger.warn({ event: _exhaustive }, "Unknown event type");
+      return { allow: true };
+    }
+  }
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function outputSessionStartContext() {
+  const context = `[SHIPYARD] Collaborative planning with human review & proof-of-work tracking.
+
+IMPORTANT: Use native plan mode (Shift+Tab) to create plans. The hook handles everything automatically.
+
+## What are Deliverables?
+
+Deliverables are measurable outcomes you can prove with artifacts (screenshots, videos, test results).
+
+Good deliverables (provable):
+\`\`\`
+- [ ] Screenshot of working login page {#deliverable}
+- [ ] Video showing feature in action {#deliverable}
+- [ ] Test results showing all tests pass {#deliverable}
+\`\`\`
+
+Bad deliverables (implementation details, not provable):
+\`\`\`
+- [ ] Implement getUserMedia API  \u2190 This is a task, not a deliverable
+- [ ] Add error handling          \u2190 Can't prove this with an artifact
+\`\`\`
+
+## Workflow
+
+1. Enter plan mode (Shift+Tab) \u2192 Browser opens with live plan
+2. Write plan with {#deliverable} markers for provable outcomes
+3. Exit plan mode \u2192 Hook BLOCKS until human approves
+4. On approval \u2192 You receive planId, sessionToken, and deliverable IDs
+5. Do work \u2192 Take screenshots/videos as you go
+6. \`add_artifact(filePath, deliverableId)\` for each deliverable
+7. When all deliverables fulfilled \u2192 Auto-completes with snapshot URL
+
+## After Approval
+
+You only need ONE tool: \`add_artifact\`
+
+When the last deliverable gets an artifact, the task auto-completes and returns a snapshot URL for your PR.`;
+  const hookOutput = {
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: context
+    }
+  };
+  console.log(JSON.stringify(hookOutput));
+}
+async function main() {
+  try {
+    if (process.argv.includes("--context")) {
+      outputSessionStartContext();
+      return;
+    }
+    const stdin = await readStdin();
+    if (!stdin.trim()) {
+      logger.debug("Empty stdin, passing through");
+      console.log(JSON.stringify({ continue: true }));
+      return;
+    }
+    const adapter = getAdapter();
+    const event = adapter.parseInput(stdin);
+    logger.debug({ event }, "Parsed event");
+    const response = await processEvent(adapter, event);
+    const output = adapter.formatOutput(response);
+    logger.debug({ output }, "Sending hook response");
+    console.log(output);
+    process.exit(0);
+  } catch (err) {
+    logger.error({ err }, "Hook error, failing closed");
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PermissionRequest",
+          decision: {
+            behavior: "deny",
+            message: `Hook error: ${err.message}. Check ~/.shipyard/hook-debug.log for details.`
+          }
+        }
+      })
+    );
+    process.exit(0);
+  }
+}
+main();