@fabiofiorita/porcelain 0.67.0 → 0.69.0

package/server/src/cli/main.mjs

@@ -2995,12 +2995,12 @@ import {
 } from "effect";
 
 // apps/server/src/config/environment-settings.ts
-import { Config as Config2, Context as Context68, Effect as Effect23, Layer as Layer20, Option as Option12, Schema as Schema182 } from "effect";
+import { Config as Config2, Context as Context68, Effect as Effect23, Layer as Layer20, Option as Option12, Schema as Schema183 } from "effect";
 
 // apps/server/src/config/server-settings.ts
 import { isIP } from "node:net";
 import { isAbsolute } from "node:path";
-import { Effect as Effect22, Result as Result4, Schema as Schema181 } from "effect";
+import { Effect as Effect22, Result as Result4, Schema as Schema182 } from "effect";
 
 // apps/server/src/config/errors/serve-configuration-error.ts
 var ServeConfigurationError = class extends Error {
@@ -7005,8 +7005,43 @@ var ReviewsApi = class extends porcelainApi.add(
 ) {
 };
 
+// packages/contracts/src/reviews/summary-api.ts
+import { HttpApiEndpoint as HttpApiEndpoint7, HttpApiGroup as HttpApiGroup7, HttpApiSchema as HttpApiSchema4 } from "effect/http-api";
+
+// packages/contracts/src/reviews/review-summary.ts
+import { Schema as Schema181 } from "effect";
+var readReviewSummaryParamsSchema = Schema181.Struct({
+  token: Schema181.String.check(Schema181.isUUID())
+});
+var readReviewSummaryQuerySchema = Schema181.Struct({
+  expires: isoDateTimeSchema,
+  signature: Schema181.String.check(Schema181.isPattern(/^[A-Za-z0-9_-]{43}$/))
+});
+var readReviewSummaryResponseSchema = Schema181.String;
+
+// packages/contracts/src/reviews/summary-api.ts
+var ReviewSummaryApi = class extends porcelainApi.add(
+  HttpApiGroup7.make("reviewSummary").add(
+    HttpApiEndpoint7.get("readReviewSummary", "/review-summaries/:token", {
+      disableCodecs: true,
+      params: readReviewSummaryParamsSchema,
+      query: readReviewSummaryQuerySchema.fields,
+      success: readReviewSummaryResponseSchema.pipe(
+        HttpApiSchema4.asText({ contentType: "text/html; charset=utf-8" })
+      ),
+      error: ReviewSummaryNotFoundError.pipe(
+        HttpApiSchema4.asNoContent({
+          decode: () => new ReviewSummaryNotFoundError()
+        }),
+        HttpApiSchema4.status("NotFound")
+      )
+    })
+  )
+) {
+};
+
 // packages/contracts/src/shared/client-api.ts
-var PorcelainClientApi = class extends porcelainApi.addHttpApi(AccessApi).addHttpApi(ProjectsApi).addHttpApi(FilesApi).addHttpApi(ChangesApi).addHttpApi(ReviewsApi).addHttpApi(GitActionsApi) {
+var PorcelainClientApi = class extends porcelainApi.addHttpApi(AccessApi).addHttpApi(ProjectsApi).addHttpApi(FilesApi).addHttpApi(ChangesApi).addHttpApi(ReviewsApi).addHttpApi(ReviewSummaryApi).addHttpApi(GitActionsApi) {
 };
 
 // apps/server/src/config/limits.ts
@@ -7271,35 +7306,35 @@ function isValidListenHost(host) {
     return false;
   return labels.every((label) => HOSTNAME_LABEL.test(label));
 }
-var absolutePathSchema2 = Schema181.String.check(
-  Schema181.makeFilter((path) => isAbsolute(path) && !path.includes("\0"), {
+var absolutePathSchema2 = Schema182.String.check(
+  Schema182.makeFilter((path) => isAbsolute(path) && !path.includes("\0"), {
     message: "Path must be absolute and contain no null bytes"
   })
 );
-var listenHostSchema = Schema181.String.check(
-  Schema181.makeFilter(isValidListenHost, {
+var listenHostSchema = Schema182.String.check(
+  Schema182.makeFilter(isValidListenHost, {
     message: "Host must be a valid IP address or hostname"
   })
 );
-var listenPortSchema = Schema181.Int.check(
-  Schema181.isBetween({ minimum: 0, maximum: LIMITS.network.maxPort })
+var listenPortSchema = Schema182.Int.check(
+  Schema182.isBetween({ minimum: 0, maximum: LIMITS.network.maxPort })
 );
-var serverSettingsSchema = Schema181.Struct({
+var serverSettingsSchema = Schema182.Struct({
   dataDirectory: absolutePathSchema2,
   projectHome: absolutePathSchema2,
   host: listenHostSchema.pipe(
-    Schema181.withDecodingDefault(Effect22.succeed(DEFAULT_LISTEN_HOST))
+    Schema182.withDecodingDefault(Effect22.succeed(DEFAULT_LISTEN_HOST))
   ),
   port: listenPortSchema.pipe(
-    Schema181.withDecodingDefault(Effect22.succeed(DEFAULT_LISTEN_PORT))
+    Schema182.withDecodingDefault(Effect22.succeed(DEFAULT_LISTEN_PORT))
   ),
-  webRoot: Schema181.optional(absolutePathSchema2),
-  allowedHosts: Schema181.Array(listenHostSchema).pipe(
-    Schema181.withDecodingDefault(Effect22.succeed([]))
+  webRoot: Schema182.optional(absolutePathSchema2),
+  allowedHosts: Schema182.Array(listenHostSchema).pipe(
+    Schema182.withDecodingDefault(Effect22.succeed([]))
   )
 });
 function readServerSettings(input) {
-  const parsed2 = Schema181.decodeUnknownResult(serverSettingsSchema)(input);
+  const parsed2 = Schema182.decodeUnknownResult(serverSettingsSchema)(input);
   if (Result4.isFailure(parsed2))
     throw new ServeConfigurationError(
       `Invalid server settings: ${parsed2.failure.message}`
@@ -7329,8 +7364,8 @@ var EnvironmentSettings = class extends Context68.Service()("@porcelain/server/E
   static layer = Layer20.succeed(this, {
     read: Effect23.gen(function* () {
       const settings = yield* configuration;
-      const allowedHosts = yield* Schema182.decodeUnknownEffect(
-        Schema182.Array(listenHostSchema)
+      const allowedHosts = yield* Schema183.decodeUnknownEffect(
+        Schema183.Array(listenHostSchema)
       )(settings.allowedHosts);
       return { ...settings, allowedHosts };
     })
@@ -7338,11 +7373,11 @@ var EnvironmentSettings = class extends Context68.Service()("@porcelain/server/E
 };
 
 // apps/server/src/cli/package-version.ts
-import { Effect as Effect26, Path as Path3, Schema as Schema189 } from "effect";
+import { Effect as Effect26, Path as Path3, Schema as Schema190 } from "effect";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // apps/server/src/installer/json-file.ts
-import { Effect as Effect24, FileSystem as FileSystem3, Path as Path2, Schema as Schema183, Result as Result5 } from "effect";
+import { Effect as Effect24, FileSystem as FileSystem3, Path as Path2, Schema as Schema184, Result as Result5 } from "effect";
 import { randomUUID as randomUUID2 } from "node:crypto";
 var exists = Effect24.fn("Installer.exists")(function* (path) {
   const fs = yield* FileSystem3.FileSystem;
@@ -7357,7 +7392,7 @@ var readJsonFile = Effect24.fn("Installer.readJsonFile")(function* (path, schema
     )
   );
   if (text.kind === "missing") return { kind: "missing" };
-  const result = Schema183.decodeUnknownResult(Schema183.fromJsonString(schema))(
+  const result = Schema184.decodeUnknownResult(Schema184.fromJsonString(schema))(
     text.text
   );
   return Result5.isSuccess(result) ? { kind: "value", value: result.success } : { kind: "invalid" };
@@ -7386,11 +7421,11 @@ var writeJsonFile = Effect24.fn("Installer.writeJsonFile")(function* (path, valu
 });
 
 // apps/server/src/installer/records.ts
-import { Effect as Effect25, Schema as Schema187 } from "effect";
+import { Effect as Effect25, Schema as Schema188 } from "effect";
 
 // apps/server/src/installer/errors/invalid-installed-record-error.ts
-import { Schema as Schema184 } from "effect";
-var InvalidInstalledRecordError = class extends Schema184.TaggedError()(
+import { Schema as Schema185 } from "effect";
+var InvalidInstalledRecordError = class extends Schema185.TaggedError()(
   "InvalidInstalledRecordError",
   {}
 ) {
@@ -7400,8 +7435,8 @@ var InvalidInstalledRecordError = class extends Schema184.TaggedError()(
 };
 
 // apps/server/src/installer/errors/invalid-service-configuration-error.ts
-import { Schema as Schema185 } from "effect";
-var InvalidServiceConfigurationError = class extends Schema185.TaggedError()(
+import { Schema as Schema186 } from "effect";
+var InvalidServiceConfigurationError = class extends Schema186.TaggedError()(
   "InvalidServiceConfigurationError",
   {}
 ) {
@@ -7411,11 +7446,11 @@ var InvalidServiceConfigurationError = class extends Schema185.TaggedError()(
 };
 
 // apps/server/src/installer/errors/invalid-update-journal-error.ts
-import { Schema as Schema186 } from "effect";
-var InvalidUpdateJournalError = class extends Schema186.TaggedError()(
+import { Schema as Schema187 } from "effect";
+var InvalidUpdateJournalError = class extends Schema187.TaggedError()(
   "InvalidUpdateJournalError",
   {
-    path: Schema186.String
+    path: Schema187.String
   }
 ) {
   get message() {
@@ -7424,34 +7459,34 @@ var InvalidUpdateJournalError = class extends Schema186.TaggedError()(
 };
 
 // apps/server/src/installer/records.ts
-var serviceConfigurationSchema = Schema187.Struct({
-  dataDirectory: Schema187.String,
-  port: Schema187.Finite.check(Schema187.isInt())
+var serviceConfigurationSchema = Schema188.Struct({
+  dataDirectory: Schema188.String,
+  port: Schema188.Finite.check(Schema188.isInt())
 });
-var installedRecordSchema = Schema187.Struct({
-  version: Schema187.String
+var installedRecordSchema = Schema188.Struct({
+  version: Schema188.String
 });
-var updateJournalSchema = Schema187.Struct({
+var updateJournalSchema = Schema188.Struct({
   installed: installedRecordSchema,
-  backup: Schema187.String,
-  target: Schema187.optional(Schema187.String),
-  healthy: Schema187.optional(Schema187.Boolean)
-});
-var updateRecordSchema = Schema187.Struct({
-  from: Schema187.String,
-  target: Schema187.String,
-  stage: Schema187.Literals([
+  backup: Schema188.String,
+  target: Schema188.optional(Schema188.String),
+  healthy: Schema188.optional(Schema188.Boolean)
+});
+var updateRecordSchema = Schema188.Struct({
+  from: Schema188.String,
+  target: Schema188.String,
+  stage: Schema188.Literals([
     "downloading",
     "installing",
     "restarting",
     "updated",
     "failed"
   ]),
-  reason: Schema187.optional(Schema187.String)
+  reason: Schema188.optional(Schema188.String)
 });
-var packageManifestSchema = Schema187.Struct({
-  name: Schema187.optional(Schema187.String),
-  version: Schema187.NonEmptyString
+var packageManifestSchema = Schema188.Struct({
+  name: Schema188.optional(Schema188.String),
+  version: Schema188.NonEmptyString
 });
 var readInstalledRecord = Effect25.fn("Installer.readInstalledRecord")(
   function* (path) {
@@ -7485,10 +7520,10 @@ var readUpdateJournal = Effect25.fn("Installer.readUpdateJournal")(
 );
 
 // apps/server/src/cli/errors/cli-package-version-error.ts
-import { Schema as Schema188 } from "effect";
-var CliPackageVersionError = class extends Schema188.TaggedError()(
+import { Schema as Schema189 } from "effect";
+var CliPackageVersionError = class extends Schema189.TaggedError()(
   "CliPackageVersionError",
-  { path: Schema188.String }
+  { path: Schema189.String }
 ) {
   get message() {
     return `Porcelain could not read a required package version from ${this.path}. Check the package build.`;
@@ -7504,7 +7539,7 @@ var cliPackageRoot = Effect26.fn("Cli.packageRoot")(function* (moduleUrl = impor
   );
   const identity3 = yield* readJsonFile(
     pathApi.join(serverRoot, "package.json"),
-    Schema189.Struct({ name: Schema189.String })
+    Schema190.Struct({ name: Schema190.String })
   );
   return identity3.kind === "value" && identity3.value.name === "@porcelain/server" ? serverRoot : pathApi.dirname(serverRoot);
 });
@@ -7513,7 +7548,7 @@ var readCliVersion = Effect26.fn("Cli.readVersion")(function* (packageRoot) {
   const manifestPath = pathApi.join(packageRoot, "package.json");
   const identity3 = yield* readJsonFile(
     manifestPath,
-    Schema189.Struct({ name: Schema189.String })
+    Schema190.Struct({ name: Schema190.String })
   );
   const versionPath = identity3.kind === "value" && identity3.value.name === "@porcelain/server" ? pathApi.resolve(packageRoot, "../../package.json") : manifestPath;
   const manifest = yield* readJsonFile(versionPath, packageManifestSchema);
@@ -7529,7 +7564,7 @@ import { Console, Effect as Effect57, Ref as Ref3, Result as Result6 } from "eff
 import { CliError, Command as Command2 } from "effect/cli";
 
 // apps/server/src/cli/command-tree.ts
-import { Context as Context74, Effect as Effect56, Option as Option14, Ref as Ref2, Schema as Schema229 } from "effect";
+import { Context as Context74, Effect as Effect56, Option as Option14, Ref as Ref2, Schema as Schema230 } from "effect";
 import { Argument, Command, Flag, GlobalFlag } from "effect/cli";
 
 // apps/server/src/cli/operations.ts
@@ -7697,8 +7732,8 @@ var commandRunner = Effect28.fn("commandRunner")(function* (limits) {
 });
 
 // apps/server/src/installer/errors/no-user-id-error.ts
-import { Schema as Schema190 } from "effect";
-var NoUserIdError = class extends Schema190.TaggedError()(
+import { Schema as Schema191 } from "effect";
+var NoUserIdError = class extends Schema191.TaggedError()(
   "NoUserIdError",
   {}
 ) {
@@ -7708,8 +7743,8 @@ var NoUserIdError = class extends Schema190.TaggedError()(
 };
 
 // apps/server/src/installer/errors/root-user-error.ts
-import { Schema as Schema191 } from "effect";
-var RootUserError = class extends Schema191.TaggedError()(
+import { Schema as Schema192 } from "effect";
+var RootUserError = class extends Schema192.TaggedError()(
   "RootUserError",
   {}
 ) {
@@ -7719,22 +7754,22 @@ var RootUserError = class extends Schema191.TaggedError()(
 };
 
 // apps/server/src/installer/errors/installer-operation-error.ts
-import { Schema as Schema192 } from "effect";
-var InstallerOperationError = class extends Schema192.TaggedError()(
+import { Schema as Schema193 } from "effect";
+var InstallerOperationError = class extends Schema193.TaggedError()(
   "InstallerOperationError",
   {
-    message: Schema192.String,
-    cause: Schema192.Defect()
+    message: Schema193.String,
+    cause: Schema193.Defect()
   }
 ) {
 };
 
 // apps/server/src/installer/errors/installer-error.ts
-import { Schema as Schema222 } from "effect";
+import { Schema as Schema223 } from "effect";
 
 // apps/server/src/installer/errors/already-installed-error.ts
-import { Schema as Schema193 } from "effect";
-var AlreadyInstalledError = class extends Schema193.TaggedError()(
+import { Schema as Schema194 } from "effect";
+var AlreadyInstalledError = class extends Schema194.TaggedError()(
   "AlreadyInstalledError",
   {}
 ) {
@@ -7744,8 +7779,8 @@ var AlreadyInstalledError = class extends Schema193.TaggedError()(
 };
 
 // apps/server/src/installer/errors/app-managed-update-error.ts
-import { Schema as Schema194 } from "effect";
-var AppManagedUpdateError = class extends Schema194.TaggedError()(
+import { Schema as Schema195 } from "effect";
+var AppManagedUpdateError = class extends Schema195.TaggedError()(
   "AppManagedUpdateError",
   {}
 ) {
@@ -7755,12 +7790,12 @@ var AppManagedUpdateError = class extends Schema194.TaggedError()(
 };
 
 // apps/server/src/installer/errors/data-directory-busy-error.ts
-import { Schema as Schema195 } from "effect";
-var DataDirectoryBusyError = class extends Schema195.TaggedError()(
+import { Schema as Schema196 } from "effect";
+var DataDirectoryBusyError = class extends Schema196.TaggedError()(
   "DataDirectoryBusyError",
   {
-    state: Schema195.Literals(["running", "unreadable"]),
-    phase: Schema195.Literals(["install", "update"])
+    state: Schema196.Literals(["running", "unreadable"]),
+    phase: Schema196.Literals(["install", "update"])
   }
 ) {
   get message() {
@@ -7769,12 +7804,12 @@ var DataDirectoryBusyError = class extends Schema195.TaggedError()(
 };
 
 // apps/server/src/installer/errors/handed-off-update-failed-error.ts
-import { Schema as Schema196 } from "effect";
-var HandedOffUpdateFailedError = class extends Schema196.TaggedError()(
+import { Schema as Schema197 } from "effect";
+var HandedOffUpdateFailedError = class extends Schema197.TaggedError()(
   "HandedOffUpdateFailedError",
   {
-    target: Schema196.String,
-    reason: Schema196.String
+    target: Schema197.String,
+    reason: Schema197.String
   }
 ) {
   get message() {
@@ -7783,11 +7818,11 @@ var HandedOffUpdateFailedError = class extends Schema196.TaggedError()(
 };
 
 // apps/server/src/installer/errors/install-cleanup-error.ts
-import { Schema as Schema197 } from "effect";
-var InstallCleanupError = class extends Schema197.TaggedError()(
+import { Schema as Schema198 } from "effect";
+var InstallCleanupError = class extends Schema198.TaggedError()(
   "InstallCleanupError",
   {
-    detail: Schema197.String
+    detail: Schema198.String
   }
 ) {
   get message() {
@@ -7796,8 +7831,8 @@ var InstallCleanupError = class extends Schema197.TaggedError()(
 };
 
 // apps/server/src/installer/errors/installed-service-unhealthy-error.ts
-import { Schema as Schema198 } from "effect";
-var InstalledServiceUnhealthyError = class extends Schema198.TaggedError()(
+import { Schema as Schema199 } from "effect";
+var InstalledServiceUnhealthyError = class extends Schema199.TaggedError()(
   "InstalledServiceUnhealthyError",
   {}
 ) {
@@ -7807,8 +7842,8 @@ var InstalledServiceUnhealthyError = class extends Schema198.TaggedError()(
 };
 
 // apps/server/src/installer/errors/interrupted-update-unrecoverable-error.ts
-import { Schema as Schema199 } from "effect";
-var InterruptedUpdateUnrecoverableError = class extends Schema199.TaggedError()(
+import { Schema as Schema200 } from "effect";
+var InterruptedUpdateUnrecoverableError = class extends Schema200.TaggedError()(
   "InterruptedUpdateUnrecoverableError",
   {}
 ) {
@@ -7818,11 +7853,11 @@ var InterruptedUpdateUnrecoverableError = class extends Schema199.TaggedError()(
 };
 
 // apps/server/src/installer/errors/invalid-package-version-error.ts
-import { Schema as Schema200 } from "effect";
-var InvalidPackageVersionError = class extends Schema200.TaggedError()(
+import { Schema as Schema201 } from "effect";
+var InvalidPackageVersionError = class extends Schema201.TaggedError()(
   "InvalidPackageVersionError",
   {
-    version: Schema200.String
+    version: Schema201.String
   }
 ) {
   get message() {
@@ -7831,8 +7866,8 @@ var InvalidPackageVersionError = class extends Schema200.TaggedError()(
 };
 
 // apps/server/src/installer/errors/management-lock-held-error.ts
-import { Schema as Schema201 } from "effect";
-var ManagementLockHeldError = class extends Schema201.TaggedError()(
+import { Schema as Schema202 } from "effect";
+var ManagementLockHeldError = class extends Schema202.TaggedError()(
   "ManagementLockHeldError",
   {}
 ) {
@@ -7842,8 +7877,8 @@ var ManagementLockHeldError = class extends Schema201.TaggedError()(
 };
 
 // apps/server/src/installer/errors/not-installed-error.ts
-import { Schema as Schema202 } from "effect";
-var NotInstalledError = class extends Schema202.TaggedError()(
+import { Schema as Schema203 } from "effect";
+var NotInstalledError = class extends Schema203.TaggedError()(
   "NotInstalledError",
   {}
 ) {
@@ -7853,8 +7888,8 @@ var NotInstalledError = class extends Schema202.TaggedError()(
 };
 
 // apps/server/src/installer/errors/not-packaged-cli-error.ts
-import { Schema as Schema203 } from "effect";
-var NotPackagedCliError = class extends Schema203.TaggedError()(
+import { Schema as Schema204 } from "effect";
+var NotPackagedCliError = class extends Schema204.TaggedError()(
   "NotPackagedCliError",
   {}
 ) {
@@ -7864,8 +7899,8 @@ var NotPackagedCliError = class extends Schema203.TaggedError()(
 };
 
 // apps/server/src/installer/errors/previous-service-unhealthy-error.ts
-import { Schema as Schema204 } from "effect";
-var PreviousServiceUnhealthyError = class extends Schema204.TaggedError()(
+import { Schema as Schema205 } from "effect";
+var PreviousServiceUnhealthyError = class extends Schema205.TaggedError()(
   "PreviousServiceUnhealthyError",
   {}
 ) {
@@ -7875,8 +7910,8 @@ var PreviousServiceUnhealthyError = class extends Schema204.TaggedError()(
 };
 
 // apps/server/src/installer/errors/published-version-unknown-error.ts
-import { Schema as Schema205 } from "effect";
-var PublishedVersionUnknownError = class extends Schema205.TaggedError()(
+import { Schema as Schema206 } from "effect";
+var PublishedVersionUnknownError = class extends Schema206.TaggedError()(
   "PublishedVersionUnknownError",
   {}
 ) {
@@ -7886,8 +7921,8 @@ var PublishedVersionUnknownError = class extends Schema205.TaggedError()(
 };
 
 // apps/server/src/installer/errors/restored-service-unhealthy-error.ts
-import { Schema as Schema206 } from "effect";
-var RestoredServiceUnhealthyError = class extends Schema206.TaggedError()(
+import { Schema as Schema207 } from "effect";
+var RestoredServiceUnhealthyError = class extends Schema207.TaggedError()(
   "RestoredServiceUnhealthyError",
   {}
 ) {
@@ -7897,11 +7932,11 @@ var RestoredServiceUnhealthyError = class extends Schema206.TaggedError()(
 };
 
 // apps/server/src/installer/errors/runtime-install-error.ts
-import { Schema as Schema207 } from "effect";
-var RuntimeInstallError = class extends Schema207.TaggedError()(
+import { Schema as Schema208 } from "effect";
+var RuntimeInstallError = class extends Schema208.TaggedError()(
   "RuntimeInstallError",
   {
-    detail: Schema207.String
+    detail: Schema208.String
   }
 ) {
   get message() {
@@ -7910,11 +7945,11 @@ var RuntimeInstallError = class extends Schema207.TaggedError()(
 };
 
 // apps/server/src/installer/errors/runtime-native-modules-error.ts
-import { Schema as Schema208 } from "effect";
-var RuntimeNativeModulesError = class extends Schema208.TaggedError()(
+import { Schema as Schema209 } from "effect";
+var RuntimeNativeModulesError = class extends Schema209.TaggedError()(
   "RuntimeNativeModulesError",
   {
-    detail: Schema208.String
+    detail: Schema209.String
   }
 ) {
   get message() {
@@ -7923,11 +7958,11 @@ var RuntimeNativeModulesError = class extends Schema208.TaggedError()(
 };
 
 // apps/server/src/installer/errors/runtime-split-effect-error.ts
-import { Schema as Schema209 } from "effect";
-var RuntimeSplitEffectError = class extends Schema209.TaggedError()(
+import { Schema as Schema210 } from "effect";
+var RuntimeSplitEffectError = class extends Schema210.TaggedError()(
   "RuntimeSplitEffectError",
   {
-    copies: Schema209.Array(Schema209.String)
+    copies: Schema210.Array(Schema210.String)
   }
 ) {
   get message() {
@@ -7936,12 +7971,12 @@ var RuntimeSplitEffectError = class extends Schema209.TaggedError()(
 };
 
 // apps/server/src/installer/errors/runtime-version-mismatch-error.ts
-import { Schema as Schema210 } from "effect";
-var RuntimeVersionMismatchError = class extends Schema210.TaggedError()(
+import { Schema as Schema211 } from "effect";
+var RuntimeVersionMismatchError = class extends Schema211.TaggedError()(
   "RuntimeVersionMismatchError",
   {
-    reported: Schema210.optional(Schema210.String),
-    expected: Schema210.String
+    reported: Schema211.optional(Schema211.String),
+    expected: Schema211.String
   }
 ) {
   get message() {
@@ -7950,12 +7985,12 @@ var RuntimeVersionMismatchError = class extends Schema210.TaggedError()(
 };
 
 // apps/server/src/installer/errors/service-command-failed-error.ts
-import { Schema as Schema211 } from "effect";
-var ServiceCommandFailedError = class extends Schema211.TaggedError()(
+import { Schema as Schema212 } from "effect";
+var ServiceCommandFailedError = class extends Schema212.TaggedError()(
   "ServiceCommandFailedError",
   {
-    description: Schema211.String,
-    detail: Schema211.String
+    description: Schema212.String,
+    detail: Schema212.String
   }
 ) {
   get message() {
@@ -7964,12 +7999,12 @@ var ServiceCommandFailedError = class extends Schema211.TaggedError()(
 };
 
 // apps/server/src/installer/errors/service-downgrade-error.ts
-import { Schema as Schema212 } from "effect";
-var ServiceDowngradeError = class extends Schema212.TaggedError()(
+import { Schema as Schema213 } from "effect";
+var ServiceDowngradeError = class extends Schema213.TaggedError()(
   "ServiceDowngradeError",
   {
-    installed: Schema212.String,
-    candidate: Schema212.String
+    installed: Schema213.String,
+    candidate: Schema213.String
   }
 ) {
   get message() {
@@ -7978,11 +8013,11 @@ var ServiceDowngradeError = class extends Schema212.TaggedError()(
 };
 
 // apps/server/src/installer/errors/service-still-active-error.ts
-import { Schema as Schema213 } from "effect";
-var ServiceStillActiveError = class extends Schema213.TaggedError()(
+import { Schema as Schema214 } from "effect";
+var ServiceStillActiveError = class extends Schema214.TaggedError()(
   "ServiceStillActiveError",
   {
-    after: Schema213.Literals(["stop", "disable"])
+    after: Schema214.Literals(["stop", "disable"])
   }
 ) {
   get message() {
@@ -7991,11 +8026,11 @@ var ServiceStillActiveError = class extends Schema213.TaggedError()(
 };
 
 // apps/server/src/installer/errors/unit-exists-error.ts
-import { Schema as Schema214 } from "effect";
-var UnitExistsError = class extends Schema214.TaggedError()(
+import { Schema as Schema215 } from "effect";
+var UnitExistsError = class extends Schema215.TaggedError()(
   "UnitExistsError",
   {
-    unitPath: Schema214.String
+    unitPath: Schema215.String
   }
 ) {
   get message() {
@@ -8004,11 +8039,11 @@ var UnitExistsError = class extends Schema214.TaggedError()(
 };
 
 // apps/server/src/installer/errors/unrecognized-unit-error.ts
-import { Schema as Schema215 } from "effect";
-var UnrecognizedUnitError = class extends Schema215.TaggedError()(
+import { Schema as Schema216 } from "effect";
+var UnrecognizedUnitError = class extends Schema216.TaggedError()(
   "UnrecognizedUnitError",
   {
-    unitPath: Schema215.String
+    unitPath: Schema216.String
   }
 ) {
   get message() {
@@ -8017,8 +8052,8 @@ var UnrecognizedUnitError = class extends Schema215.TaggedError()(
 };
 
 // apps/server/src/installer/errors/latest-update-downgrade-error.ts
-import { Schema as Schema216 } from "effect";
-var LatestUpdateDowngradeError = class extends Schema216.TaggedError()(
+import { Schema as Schema217 } from "effect";
+var LatestUpdateDowngradeError = class extends Schema217.TaggedError()(
   "LatestUpdateDowngradeError",
   {}
 ) {
@@ -8028,12 +8063,12 @@ var LatestUpdateDowngradeError = class extends Schema216.TaggedError()(
 };
 
 // apps/server/src/installer/errors/update-failed-error.ts
-import { Schema as Schema217 } from "effect";
-var UpdateFailedError = class extends Schema217.TaggedError()(
+import { Schema as Schema218 } from "effect";
+var UpdateFailedError = class extends Schema218.TaggedError()(
   "UpdateFailedError",
   {
-    recovery: Schema217.String,
-    detail: Schema217.String
+    recovery: Schema218.String,
+    detail: Schema218.String
   }
 ) {
   get message() {
@@ -8042,11 +8077,11 @@ var UpdateFailedError = class extends Schema217.TaggedError()(
 };
 
 // apps/server/src/installer/errors/update-hand-off-error.ts
-import { Schema as Schema218 } from "effect";
-var UpdateHandOffError = class extends Schema218.TaggedError()(
+import { Schema as Schema219 } from "effect";
+var UpdateHandOffError = class extends Schema219.TaggedError()(
   "UpdateHandOffError",
   {
-    detail: Schema218.String
+    detail: Schema219.String
   }
 ) {
   get message() {
@@ -8055,11 +8090,11 @@ var UpdateHandOffError = class extends Schema218.TaggedError()(
 };
 
 // apps/server/src/installer/errors/update-recovery-error.ts
-import { Schema as Schema219 } from "effect";
-var UpdateRecoveryError = class extends Schema219.TaggedError()(
+import { Schema as Schema220 } from "effect";
+var UpdateRecoveryError = class extends Schema220.TaggedError()(
   "UpdateRecoveryError",
   {
-    detail: Schema219.String
+    detail: Schema220.String
   }
 ) {
   get message() {
@@ -8068,11 +8103,11 @@ var UpdateRecoveryError = class extends Schema219.TaggedError()(
 };
 
 // apps/server/src/installer/errors/update-restart-error.ts
-import { Schema as Schema220 } from "effect";
-var UpdateRestartError = class extends Schema220.TaggedError()(
+import { Schema as Schema221 } from "effect";
+var UpdateRestartError = class extends Schema221.TaggedError()(
   "UpdateRestartError",
   {
-    detail: Schema220.String
+    detail: Schema221.String
   }
 ) {
   get message() {
@@ -8081,8 +8116,8 @@ var UpdateRestartError = class extends Schema220.TaggedError()(
 };
 
 // apps/server/src/installer/errors/updated-service-unhealthy-error.ts
-import { Schema as Schema221 } from "effect";
-var UpdatedServiceUnhealthyError = class extends Schema221.TaggedError()(
+import { Schema as Schema222 } from "effect";
+var UpdatedServiceUnhealthyError = class extends Schema222.TaggedError()(
   "UpdatedServiceUnhealthyError",
   {}
 ) {
@@ -8092,7 +8127,7 @@ var UpdatedServiceUnhealthyError = class extends Schema221.TaggedError()(
 };
 
 // apps/server/src/installer/errors/installer-error.ts
-var installerErrorSchema = Schema222.Union([
+var installerErrorSchema = Schema223.Union([
   InstallerOperationError,
   ServiceUpdateRunningError,
   AlreadyInstalledError,
@@ -8130,7 +8165,7 @@ var installerErrorSchema = Schema222.Union([
   UpdateRestartError,
   UpdatedServiceUnhealthyError
 ]);
-var isInstallerError = Schema222.is(installerErrorSchema);
+var isInstallerError = Schema223.is(installerErrorSchema);
 
 // apps/server/src/installer/failure-detail.ts
 function failureDetail(error) {
@@ -8587,14 +8622,14 @@ var install = Effect35.fn("Installer.install")(function* (context, settings) {
 });
 
 // apps/server/src/runtime/directory-lock.ts
-import { Clock as Clock3, DateTime as DateTime3, Effect as Effect36, FileSystem as FileSystem9, Path as Path6, Schema as Schema223 } from "effect";
+import { Clock as Clock3, DateTime as DateTime3, Effect as Effect36, FileSystem as FileSystem9, Path as Path6, Schema as Schema224 } from "effect";
 import * as PlatformError3 from "effect/PlatformError";
 import { randomUUID as randomUUID5 } from "node:crypto";
-var lockOwnerSchema = Schema223.Struct({
-  pid: Schema223.Int,
-  token: Schema223.String,
-  bootId: Schema223.optional(Schema223.String),
-  startTime: Schema223.optional(Schema223.String)
+var lockOwnerSchema = Schema224.Struct({
+  pid: Schema224.Int,
+  token: Schema224.String,
+  bootId: Schema224.optional(Schema224.String),
+  startTime: Schema224.optional(Schema224.String)
 });
 var OWNER_FILE = "owner.json";
 function processIsAlive(pid) {
@@ -8609,7 +8644,7 @@ var ownerOf = Effect36.fn("DirectoryLock.ownerOf")(
   (fs, pathApi, lock) => fs.readFileString(pathApi.join(lock, OWNER_FILE)).pipe(
     Effect36.map((text) => {
       try {
-        return Schema223.decodeUnknownSync(lockOwnerSchema)(JSON.parse(text));
+        return Schema224.decodeUnknownSync(lockOwnerSchema)(JSON.parse(text));
       } catch {
         return void 0;
       }
@@ -9733,37 +9768,37 @@ var openAppManagedUpdateRunner = Effect46.fn(
 import { Effect as Effect48 } from "effect";
 
 // packages/contracts/src/access/protocols.ts
-import { HttpApiEndpoint as HttpApiEndpoint7, HttpApiGroup as HttpApiGroup7, HttpApiSchema as HttpApiSchema4 } from "effect/http-api";
+import { HttpApiEndpoint as HttpApiEndpoint8, HttpApiGroup as HttpApiGroup8, HttpApiSchema as HttpApiSchema5 } from "effect/http-api";
 
 // packages/contracts/src/access/mcp-http.ts
-import { Schema as Schema224 } from "effect";
-var mcpPayloadSchema = Schema224.Unknown;
-var mcpAcceptedResponseSchema = Schema224.Undefined;
+import { Schema as Schema225 } from "effect";
+var mcpPayloadSchema = Schema225.Unknown;
+var mcpAcceptedResponseSchema = Schema225.Undefined;
 
 // packages/contracts/src/access/protocols.ts
 var LiveUpdatesApi = class extends porcelainApi.add(
-  HttpApiGroup7.make("live").add(
-    HttpApiEndpoint7.get("liveUpdates", "/api/live", {
+  HttpApiGroup8.make("live").add(
+    HttpApiEndpoint8.get("liveUpdates", "/api/live", {
       disableCodecs: true,
       query: liveUpdatesQuerySchema.fields,
       success: liveUpgradeResponseSchema.pipe(
-        HttpApiSchema4.asNoContent({ decode: () => void 0 }),
-        HttpApiSchema4.status("SwitchingProtocols")
+        HttpApiSchema5.asNoContent({ decode: () => void 0 }),
+        HttpApiSchema5.status("SwitchingProtocols")
       )
     })
   ).middleware(PairedRequest)
 ) {
 };
 var ReviewMcpApi = class extends porcelainApi.add(
-  HttpApiGroup7.make("reviewMcp").add(
-    HttpApiEndpoint7.post("reviewMcp", "/mcp", {
+  HttpApiGroup8.make("reviewMcp").add(
+    HttpApiEndpoint8.post("reviewMcp", "/mcp", {
       disableCodecs: true,
       payload: mcpPayloadSchema,
       success: [
         mcpPayloadSchema,
         mcpAcceptedResponseSchema.pipe(
-          HttpApiSchema4.asNoContent({ decode: () => void 0 }),
-          HttpApiSchema4.status("Accepted")
+          HttpApiSchema5.asNoContent({ decode: () => void 0 }),
+          HttpApiSchema5.status("Accepted")
         )
       ]
     })
@@ -9775,7 +9810,7 @@ var ReviewMcpApi = class extends porcelainApi.add(
 import qrcode from "qrcode-terminal";
 
 // apps/server/src/cli/owner-client.ts
-import { Effect as Effect47, Schema as Schema227 } from "effect";
+import { Effect as Effect47, Schema as Schema228 } from "effect";
 import {
   HttpClient,
   HttpClientRequest,
@@ -9787,21 +9822,21 @@ import { NodeHttpClient } from "@effect/platform-node";
 import { connect } from "node:net";
 
 // apps/server/src/cli/errors/owner-request-error.ts
-import { Schema as Schema225 } from "effect";
-var OwnerRequestError = class extends Schema225.TaggedError()(
+import { Schema as Schema226 } from "effect";
+var OwnerRequestError = class extends Schema226.TaggedError()(
   "OwnerRequestError",
   {
-    message: Schema225.String
+    message: Schema226.String
   }
 ) {
 };
 
 // apps/server/src/cli/errors/owner-socket-timeout-error.ts
-import { Schema as Schema226 } from "effect";
-var OwnerSocketTimeoutError = class extends Schema226.TaggedError()(
+import { Schema as Schema227 } from "effect";
+var OwnerSocketTimeoutError = class extends Schema227.TaggedError()(
   "OwnerSocketTimeoutError",
   {
-    message: Schema226.String
+    message: Schema227.String
   }
 ) {
 };
@@ -9879,7 +9914,7 @@ var ownerClient = Effect47.fn("ownerClient")(function* (dataDirectory2, timeoutM
     httpClient: ownerHttpClient(dataDirectory2, timeoutMs)
   });
 });
-var errorMessageSchema = Schema227.Struct({ message: Schema227.String });
+var errorMessageSchema = Schema228.Struct({ message: Schema228.String });
 var ownerRequest = (request2) => request2.pipe(
   Effect47.catch(
     (error) => Effect47.gen(function* () {
@@ -9898,7 +9933,7 @@ var ownerRequest = (request2) => request2.pipe(
         }
       }
       return yield* new OwnerRequestError({
-        message: Schema227.isSchemaError(error) ? "The server answered unrecognizably." : reasonOf(error)
+        message: Schema228.isSchemaError(error) ? "The server answered unrecognizably." : reasonOf(error)
       });
     })
   )
@@ -10664,7 +10699,7 @@ var CliOperations = class _CliOperations extends Context72.Service()("@porcelain
 // apps/server/src/cli/settings.ts
 import { dirname as dirname2, join as join2, parse, resolve } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { Context as Context73, Effect as Effect55, Option as Option13, Schema as Schema228 } from "effect";
+import { Context as Context73, Effect as Effect55, Option as Option13, Schema as Schema229 } from "effect";
 var CliInvocation = class extends Context73.Service()("@porcelain/server/CliInvocation") {
 };
 var defaultWebRoot = resolve(
@@ -10704,7 +10739,7 @@ var serverSettingsFor = Effect55.fn("Cli.serverSettings")(
       projectHome: environment.projectHome ?? homeDirectory,
       host,
       port: Option13.getOrElse(input.port, () => environment.port),
-      webRoot: Schema228.decodeUnknownSync(absolutePathSchema2)(
+      webRoot: Schema229.decodeUnknownSync(absolutePathSchema2)(
         environment.webRoot ?? webRoot
       ),
       allowedHosts: [
@@ -10746,8 +10781,8 @@ var serveFlags = {
   ),
   lan: Flag.Boolean("lan").pipe(Flag.withDefault(false))
 };
-var originSchema = Schema229.String.check(
-  Schema229.makeFilter(
+var originSchema = Schema230.String.check(
+  Schema230.makeFilter(
     (value2) => {
       try {
         const url = new URL(value2);
@@ -10832,7 +10867,7 @@ var pair = Command.make(
 var revoke = Command.make(
   "revoke",
   {
-    id: Argument.String("id").pipe(Argument.withSchema(Schema229.NonEmptyString))
+    id: Argument.String("id").pipe(Argument.withSchema(Schema230.NonEmptyString))
   },
   Effect56.fn("Cli.revokeCommand")(function* (input) {
     const operations2 = yield* CliOperations;
@@ -10848,7 +10883,7 @@ var trustCommand = (name, trusted) => Command.make(
   name,
   {
     id: Argument.String("id").pipe(
-      Argument.withSchema(Schema229.NonEmptyString)
+      Argument.withSchema(Schema230.NonEmptyString)
     )
   },
   Effect56.fn(`Cli.${name}Command`)(function* (input) {
@@ -10915,7 +10950,7 @@ var share = Command.make(
       "tailscale",
       {
         hostname: Argument.String("hostname").pipe(
-          Argument.withSchema(Schema229.NonEmptyString)
+          Argument.withSchema(Schema230.NonEmptyString)
         )
       },
       ({ hostname: hostname2 }) => shareHandler({
@@ -10927,7 +10962,7 @@ var share = Command.make(
       "cloudflare",
       {
         hostname: Argument.String("hostname").pipe(
-          Argument.withSchema(Schema229.NonEmptyString)
+          Argument.withSchema(Schema230.NonEmptyString)
         )
       },
       ({ hostname: hostname2 }) => shareHandler({
@@ -11334,7 +11369,7 @@ import {
   FileSystem as FileSystem18,
   Layer as Layer30,
   Path as Path13,
-  Schema as Schema234
+  Schema as Schema235
 } from "effect";
 import { ChildProcessSpawner as ChildProcessSpawner3 } from "effect/process";
 
@@ -11362,7 +11397,7 @@ var findExecutable = Effect63.fn("Provider.findExecutable")(function* (name) {
 });
 
 // packages/agents/src/commit-planning/commands/coding-model.ts
-import { Effect as Effect64, JsonSchema, Layer as Layer29, Schema as Schema230, Stream as Stream4 } from "effect";
+import { Effect as Effect64, JsonSchema, Layer as Layer29, Schema as Schema231, Stream as Stream4 } from "effect";
 import { AiError, LanguageModel, Model as Model16 } from "effect/ai";
 function codingModel(provider, model, answer2) {
   return Model16.make(
@@ -11386,7 +11421,7 @@ function codingModel(provider, model, answer2) {
               );
             const prompt = message.content.map((part) => part.type === "text" ? part.text : "").join("");
             const document = JsonSchema.toDocumentDraft07(
-              Schema230.toJsonSchemaDocument(options.responseFormat.schema, {
+              Schema231.toJsonSchemaDocument(options.responseFormat.schema, {
                 onExcessProperty: "error"
               })
             );
@@ -11400,7 +11435,7 @@ function codingModel(provider, model, answer2) {
                 (error) => AiError.make({
                   module: provider,
                   method: "generateObject",
-                  reason: error instanceof Schema230.SchemaError ? AiError.InvalidOutputError.fromSchemaError(error) : new AiError.InternalProviderError({
+                  reason: error instanceof Schema231.SchemaError ? AiError.InvalidOutputError.fromSchemaError(error) : new AiError.InternalProviderError({
                     description: error.message
                   })
                 })
@@ -11427,10 +11462,10 @@ function codingModel(provider, model, answer2) {
 import { Effect as Effect65 } from "effect";
 
 // packages/agents/src/commit-planning/errors/provider-process-failed-error.ts
-import { Schema as Schema231 } from "effect";
-var ProviderProcessFailedError = class extends Schema231.TaggedError()(
+import { Schema as Schema232 } from "effect";
+var ProviderProcessFailedError = class extends Schema232.TaggedError()(
   "ProviderProcessFailedError",
-  { cause: Schema231.optional(Schema231.Unknown) }
+  { cause: Schema232.optional(Schema232.Unknown) }
 ) {
   get message() {
     return "Commit generation failed. Check that the selected CLI is up to date and signed in.";
@@ -11467,8 +11502,8 @@ var readBoundedText = Effect66.fn("Provider.readBoundedText")(function* (file, m
 });
 
 // packages/agents/src/commit-planning/errors/provider-not-installed-error.ts
-import { Schema as Schema232 } from "effect";
-var ProviderNotInstalledError = class extends Schema232.TaggedError()(
+import { Schema as Schema233 } from "effect";
+var ProviderNotInstalledError = class extends Schema233.TaggedError()(
   "ProviderNotInstalledError",
   {}
 ) {
@@ -11478,25 +11513,25 @@ var ProviderNotInstalledError = class extends Schema232.TaggedError()(
 };
 
 // packages/agents/src/commit-planning/parsers/parse-provider-answer.ts
-import { Effect as Effect67, Schema as Schema233 } from "effect";
-var claudeEnvelopeSchema = Schema233.fromJsonString(
-  Schema233.Struct({ structured_output: Schema233.Json })
+import { Effect as Effect67, Schema as Schema234 } from "effect";
+var claudeEnvelopeSchema = Schema234.fromJsonString(
+  Schema234.Struct({ structured_output: Schema234.Json })
 );
-var codexAnswerSchema = Schema233.fromJsonString(Schema233.Json);
-var claudeAnswer = (output2) => Schema233.decodeUnknownEffect(claudeEnvelopeSchema)(output2).pipe(
+var codexAnswerSchema = Schema234.fromJsonString(Schema234.Json);
+var claudeAnswer = (output2) => Schema234.decodeUnknownEffect(claudeEnvelopeSchema)(output2).pipe(
   Effect67.map((reply) => reply.structured_output)
 );
-var codexAnswer = Schema233.decodeUnknownEffect(codexAnswerSchema);
+var codexAnswer = Schema234.decodeUnknownEffect(codexAnswerSchema);
 
 // packages/agents/src/commit-planning/codex-provider.ts
 var modelSlug = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
-var modelCacheSchema = Schema234.fromJsonString(
-  Schema234.Struct({
-    models: Schema234.Array(
-      Schema234.Struct({
-        slug: Schema234.String,
-        display_name: Schema234.String,
-        visibility: Schema234.optional(Schema234.String)
+var modelCacheSchema = Schema235.fromJsonString(
+  Schema235.Struct({
+    models: Schema235.Array(
+      Schema235.Struct({
+        slug: Schema235.String,
+        display_name: Schema235.String,
+        visibility: Schema235.optional(Schema235.String)
       })
     )
   })
@@ -11525,7 +11560,7 @@ var CodexProvider = class _CodexProvider extends Context87.Service()(
               path.join(home, "models_cache.json"),
               limits.codexCacheBytes
             ).pipe(Effect68.provideService(FileSystem18.FileSystem, fs));
-            const listed2 = yield* Schema234.decodeUnknownEffect(modelCacheSchema)(text);
+            const listed2 = yield* Schema235.decodeUnknownEffect(modelCacheSchema)(text);
             return listed2.models.filter(
               (model) => model.visibility === "list" && modelSlug.test(model.slug)
             ).map((model) => ({
@@ -11697,7 +11732,7 @@ var ClaudeProvider = class _ClaudeProvider extends Context88.Service()(
 };
 
 // packages/agents/src/commit-planning/commit-planner.ts
-import { Context as Context89, Effect as Effect70, Layer as Layer32, Schema as Schema238 } from "effect";
+import { Context as Context89, Effect as Effect70, Layer as Layer32, Schema as Schema239 } from "effect";
 import { AiError as AiError2, LanguageModel as LanguageModel2 } from "effect/ai";
 
 // packages/agents/src/commit-planning/commands/plan-commit.ts
@@ -11713,31 +11748,31 @@ function commitPlanPrompt(request2) {
 }
 
 // packages/agents/src/commit-planning/dtos/commit-plan-schema.ts
-import { Schema as Schema235 } from "effect";
+import { Schema as Schema236 } from "effect";
 function commitPlanSchema(limits) {
-  return Schema235.Struct({
-    groups: Schema235.Array(
-      Schema235.Struct({
-        message: Schema235.String.check(
-          Schema235.isMinLength(1),
-          Schema235.isMaxLength(limits.maxMessageLength)
+  return Schema236.Struct({
+    groups: Schema236.Array(
+      Schema236.Struct({
+        message: Schema236.String.check(
+          Schema236.isMinLength(1),
+          Schema236.isMaxLength(limits.maxMessageLength)
         ),
-        paths: Schema235.Array(
-          Schema235.String.check(
-            Schema235.isMinLength(1),
-            Schema235.isMaxLength(limits.maxPathLength)
+        paths: Schema236.Array(
+          Schema236.String.check(
+            Schema236.isMinLength(1),
+            Schema236.isMaxLength(limits.maxPathLength)
           )
-        ).check(Schema235.isMinLength(1), Schema235.isMaxLength(limits.maxPaths))
+        ).check(Schema236.isMinLength(1), Schema236.isMaxLength(limits.maxPaths))
       })
-    ).check(Schema235.isMinLength(1), Schema235.isMaxLength(limits.maxGroups))
+    ).check(Schema236.isMinLength(1), Schema236.isMaxLength(limits.maxGroups))
   });
 }
 
 // packages/agents/src/commit-planning/errors/commit-plan-failed-error.ts
-import { Schema as Schema236 } from "effect";
-var CommitPlanFailedError = class extends Schema236.TaggedError()(
+import { Schema as Schema237 } from "effect";
+var CommitPlanFailedError = class extends Schema237.TaggedError()(
   "CommitPlanFailedError",
-  { cause: Schema236.optional(Schema236.Unknown) }
+  { cause: Schema237.optional(Schema237.Unknown) }
 ) {
   get message() {
     return "Commit generation failed.";
@@ -11745,8 +11780,8 @@ var CommitPlanFailedError = class extends Schema236.TaggedError()(
 };
 
 // packages/agents/src/commit-planning/errors/unsupported-commit-model-error.ts
-import { Schema as Schema237 } from "effect";
-var UnsupportedCommitModelError2 = class extends Schema237.TaggedError()(
+import { Schema as Schema238 } from "effect";
+var UnsupportedCommitModelError2 = class extends Schema238.TaggedError()(
   "UnsupportedCommitModelError",
   {}
 ) {
@@ -11787,8 +11822,8 @@ var CommitPlanner = class _CommitPlanner extends Context89.Service()("@porcelain
                 (cause) => cause.reason instanceof AiError2.InvalidOutputError || cause.reason instanceof AiError2.StructuredOutputError || cause.reason instanceof AiError2.UnsupportedSchemaError ? new CommitPlanFailedError({ cause }) : new ProviderProcessFailedError({ cause })
               )
             );
-            const plan = yield* Schema238.decodeUnknownEffect(
-              Schema238.fromJsonString(schema),
+            const plan = yield* Schema239.decodeUnknownEffect(
+              Schema239.fromJsonString(schema),
               { onExcessProperty: "error" }
             )(response2.text).pipe(
               Effect70.mapError((cause) => new CommitPlanFailedError({ cause }))
@@ -11811,8 +11846,8 @@ import { Effect as Effect75, FileSystem as FileSystem21 } from "effect";
 import { Effect as Effect71 } from "effect";
 
 // packages/git/src/shared/errors/invalid-worktree-inventory-error.ts
-import { Schema as Schema239 } from "effect";
-var InvalidWorktreeInventoryError = class extends Schema239.TaggedError()(
+import { Schema as Schema240 } from "effect";
+var InvalidWorktreeInventoryError = class extends Schema240.TaggedError()(
   "InvalidWorktreeInventoryError",
   {}
 ) {
@@ -11937,8 +11972,8 @@ import { Effect as Effect74 } from "effect";
 import { devNull } from "node:os";
 
 // packages/git/src/shared/errors/git-output-limit-error.ts
-import { Schema as Schema240 } from "effect";
-var GitOutputLimitError = class extends Schema240.TaggedError()(
+import { Schema as Schema241 } from "effect";
+var GitOutputLimitError = class extends Schema241.TaggedError()(
   "GitOutputLimitError",
   {}
 ) {
@@ -13400,7 +13435,7 @@ var httpRouteListenerRunnerLayer = (target) => Layer60.effect(
 );
 
 // apps/server/src/adapters/access/http-tunnel-probe.ts
-import { Clock as Clock11, Effect as Effect108, Layer as Layer61, Result as Result7, Schema as Schema241 } from "effect";
+import { Clock as Clock11, Effect as Effect108, Layer as Layer61, Result as Result7, Schema as Schema242 } from "effect";
 import { HttpApiClient as HttpApiClient2 } from "effect/http-api";
 import { FetchHttpClient, HttpClient as HttpClient2 } from "effect/http";
 var httpTunnelProbeLayer = (options) => Layer61.effect(
@@ -13435,7 +13470,7 @@ var httpTunnelProbeLayer = (options) => Layer61.effect(
           ),
           Effect108.catch(() => Effect108.succeed(void 0))
         );
-        const health = Schema241.decodeUnknownResult(readHealthResponseSchema)(
+        const health = Schema242.decodeUnknownResult(readHealthResponseSchema)(
           body
         );
         return Result7.isSuccess(health) ? { kind: "answered", environmentId: health.success.environmentId } : { kind: "foreign" };
@@ -15849,7 +15884,7 @@ import { Effect as Effect152, Layer as Layer78 } from "effect";
 import { HttpRouter as HttpRouter3 } from "effect/http";
 
 // apps/server/src/http/request-context.ts
-import { Context as Context120, Effect as Effect151, Layer as Layer77, Schema as Schema242 } from "effect";
+import { Context as Context120, Effect as Effect151, Layer as Layer77, Schema as Schema243 } from "effect";
 var RequestContext = class extends Context120.Service()("@porcelain/server/RequestContext") {
 };
 var requestServices = Layer77.mergeAll(
@@ -15869,7 +15904,7 @@ var requestServices = Layer77.mergeAll(
     PairedRequest,
     (httpEffect) => Effect151.flatMap(
       Effect151.serviceOption(RequestContext),
-      (context) => context._tag === "Some" && Schema242.is(RequestCaller.schema)(context.value.principal) ? Effect151.provideService(
+      (context) => context._tag === "Some" && Schema243.is(RequestCaller.schema)(context.value.principal) ? Effect151.provideService(
         httpEffect,
         RequestCaller,
         context.value.principal
@@ -15948,17 +15983,6 @@ import { Effect as Effect228, Layer as Layer152 } from "effect";
 import { McpServer } from "effect/ai";
 import { HttpServerRequest as HttpServerRequest2 } from "effect/http";
 
-// packages/contracts/src/reviews/review-summary.ts
-import { Schema as Schema243 } from "effect";
-var readReviewSummaryParamsSchema = Schema243.Struct({
-  token: Schema243.String.check(Schema243.isUUID())
-});
-var readReviewSummaryQuerySchema = Schema243.Struct({
-  expires: isoDateTimeSchema,
-  signature: Schema243.String.check(Schema243.isPattern(/^[A-Za-z0-9_-]{43}$/))
-});
-var readReviewSummaryResponseSchema = Schema243.String;
-
 // packages/contracts/src/reviews/review-tools.ts
 import { Effect as Effect153, Schema as Schema244 } from "effect";
 var reviewToolScopeSchema = Schema244.Struct({
@@ -16007,28 +16031,6 @@ var resolveCommentToolRequestSchema = Schema244.Struct({
   }
 });
 
-// packages/contracts/src/reviews/summary-api.ts
-import { HttpApiEndpoint as HttpApiEndpoint8, HttpApiGroup as HttpApiGroup8, HttpApiSchema as HttpApiSchema5 } from "effect/http-api";
-var ReviewSummaryApi = class extends porcelainApi.add(
-  HttpApiGroup8.make("reviewSummary").add(
-    HttpApiEndpoint8.get("readReviewSummary", "/review-summaries/:token", {
-      disableCodecs: true,
-      params: readReviewSummaryParamsSchema,
-      query: readReviewSummaryQuerySchema.fields,
-      success: readReviewSummaryResponseSchema.pipe(
-        HttpApiSchema5.asText({ contentType: "text/html; charset=utf-8" })
-      ),
-      error: ReviewSummaryNotFoundError.pipe(
-        HttpApiSchema5.asNoContent({
-          decode: () => new ReviewSummaryNotFoundError()
-        }),
-        HttpApiSchema5.status("NotFound")
-      )
-    })
-  )
-) {
-};
-
 // packages/contracts/src/reviews/review-toolkit.ts
 import { Schema as Schema245 } from "effect";
 import { Tool, Toolkit } from "effect/ai";