@spotpatch/shared 1.12.0 → 1.14.0

package/dist/external-agent-node.cjs

@@ -33,6 +33,7 @@ __export(external_agent_node_exports, {
   EXTERNAL_HANDOFF_PROJECT_KEY_SALT: () => EXTERNAL_HANDOFF_PROJECT_KEY_SALT,
   SPOTPATCH_BRIDGE_PATHS: () => SPOTPATCH_BRIDGE_PATHS,
   SPOTPATCH_BRIDGE_TOKEN_HEADER: () => SPOTPATCH_BRIDGE_TOKEN_HEADER,
+  assertPrivateExternalHandoffPath: () => assertPrivateExternalHandoffPath,
   bridgeAckRequestSchema: () => bridgeAckRequestSchema,
   bridgeAckResultSchema: () => bridgeAckResultSchema,
   bridgeActiveClaimRequestSchema: () => bridgeActiveClaimRequestSchema,
@@ -52,20 +53,23 @@ __export(external_agent_node_exports, {
   bridgeWaitResultSchema: () => bridgeWaitResultSchema,
   computeExternalHandoffProjectKey: () => computeExternalHandoffProjectKey,
   externalHandoffDescriptorSchema: () => externalHandoffDescriptorSchema,
+  initializePrivateExternalHandoffFile: () => initializePrivateExternalHandoffFile,
   resolveExternalHandoffRuntimeDirectory: () => resolveExternalHandoffRuntimeDirectory
 });
 module.exports = __toCommonJS(external_agent_node_exports);
 var import_node_crypto = require("crypto");
+var import_node_child_process = require("child_process");
 var import_promises = require("fs/promises");
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var import_zod3 = require("zod");
+var import_node_util = require("util");
+var import_zod4 = require("zod");
 
 // src/protocol/external-handoff.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/protocol/requests.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 
 // src/model/annotation.ts
 var MAX_ANNOTATION_TARGETS = 20;
@@ -140,42 +144,15 @@ var AGENT_CHECK_STATUSES = Object.freeze([
   "timed-out"
 ]);
 
-// src/protocol/requests.ts
-var runtimeBootstrapRequestSchema = import_zod.z.strictObject({});
-var sourceCoordinatesSchema = import_zod.z.strictObject({
-  fileId: import_zod.z.string().min(1).max(128),
-  line: import_zod.z.number().int().positive(),
-  column: import_zod.z.number().int().positive()
-});
-var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: import_zod.z.number().int().positive()
-}).strict();
-var openEditorRequestSchema = sourceCoordinatesSchema.strict();
-var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
-  schemaVersion: import_zod.z.literal(1),
-  sourceVersion: import_zod.z.string().min(1).max(128).optional()
-}).strict();
-var dataFlowComponentIdentityRequestSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(1),
-  componentSourceId: import_zod.z.string().min(1).max(128),
-  sourceVersion: import_zod.z.string().min(1).max(128)
-});
-var dataFlowComponentReportRequestSchema = import_zod.z.union([
-  dataFlowSourceCoordinatesRequestSchema,
-  dataFlowComponentIdentityRequestSchema
-]);
-var dataFlowPageReportRequestSchema = import_zod.z.strictObject({
-  schemaVersion: import_zod.z.literal(1),
-  targets: import_zod.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
-});
-var profileIdSchema = import_zod.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+// src/model/context-schema.ts
+var import_zod = require("zod");
 var boundedString = (maximum) => import_zod.z.string().max(maximum);
 var sourceRefSchema = import_zod.z.strictObject({
   fileId: boundedString(128).optional(),
   relativePath: boundedString(1024).optional(),
   line: import_zod.z.number().int().positive().optional(),
   column: import_zod.z.number().int().positive().optional(),
-  origin: import_zod.z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  origin: import_zod.z.enum(["jsx-host", "astro-host", "react-fiber", "dom-ancestor", "none"]),
   confidence: import_zod.z.enum(["exact", "probable", "approximate", "unknown"])
 });
 var matchedStyleRuleSchema = import_zod.z.strictObject({
@@ -186,7 +163,7 @@ var matchedStyleRuleSchema = import_zod.z.strictObject({
 });
 var codeContextSchema = import_zod.z.strictObject({
   relativePath: boundedString(1024),
-  language: import_zod.z.enum(["tsx", "jsx"]),
+  language: import_zod.z.enum(["tsx", "jsx", "astro"]),
   startLine: import_zod.z.number().int().positive(),
   endLine: import_zod.z.number().int().positive(),
   excerpt: boundedString(16e3),
@@ -200,7 +177,7 @@ var pageContextSchema = import_zod.z.strictObject({
   viewportHeight: import_zod.z.number().nonnegative(),
   devicePixelRatio: import_zod.z.number().positive()
 });
-var spotTargetContextRequestSchema = import_zod.z.strictObject({
+var spotTargetContextSchema = import_zod.z.strictObject({
   instruction: import_zod.z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
   page: pageContextSchema.optional(),
   source: sourceRefSchema,
@@ -236,12 +213,12 @@ var spotTargetContextRequestSchema = import_zod.z.strictObject({
   code: codeContextSchema.optional(),
   warnings: import_zod.z.array(boundedString(1024)).max(64)
 });
-var spotAnnotationRequestSchema = import_zod.z.strictObject({
+var spotAnnotationSchema = import_zod.z.strictObject({
   schemaVersion: import_zod.z.literal(3),
   id: boundedString(128),
   locale: import_zod.z.enum(SPOTPATCH_LOCALES),
   page: pageContextSchema,
-  targets: import_zod.z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  targets: import_zod.z.array(spotTargetContextSchema).min(1).max(MAX_ANNOTATION_TARGETS),
   createdAt: import_zod.z.iso.datetime()
 }).superRefine((annotation, context) => {
   const total = annotation.targets.reduce(
@@ -256,21 +233,51 @@ var spotAnnotationRequestSchema = import_zod.z.strictObject({
     });
   }
 });
-var agentCapabilityRequestSchema = import_zod.z.strictObject({
+
+// src/protocol/requests.ts
+var runtimeBootstrapRequestSchema = import_zod2.z.strictObject({});
+var sourceCoordinatesSchema = import_zod2.z.strictObject({
+  fileId: import_zod2.z.string().min(1).max(128),
+  line: import_zod2.z.number().int().positive(),
+  column: import_zod2.z.number().int().positive()
+});
+var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
+  maxLines: import_zod2.z.number().int().positive()
+}).strict();
+var openEditorRequestSchema = sourceCoordinatesSchema.strict();
+var dataFlowSourceCoordinatesRequestSchema = sourceCoordinatesSchema.extend({
+  schemaVersion: import_zod2.z.literal(1),
+  sourceVersion: import_zod2.z.string().min(1).max(128).optional()
+}).strict();
+var dataFlowComponentIdentityRequestSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(1),
+  componentSourceId: import_zod2.z.string().min(1).max(128),
+  sourceVersion: import_zod2.z.string().min(1).max(128)
+});
+var dataFlowComponentReportRequestSchema = import_zod2.z.union([
+  dataFlowSourceCoordinatesRequestSchema,
+  dataFlowComponentIdentityRequestSchema
+]);
+var dataFlowPageReportRequestSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(1),
+  targets: import_zod2.z.array(dataFlowComponentReportRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS)
+});
+var profileIdSchema = import_zod2.z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var agentCapabilityRequestSchema = import_zod2.z.strictObject({
   providerProfileId: profileIdSchema,
   modelProfileId: profileIdSchema
 });
-var agentWorkspaceHealthRequestSchema = import_zod.z.strictObject({});
-var agentJobCreateRequestSchema = import_zod.z.strictObject({
-  annotation: spotAnnotationRequestSchema,
-  applyMode: import_zod.z.enum(AGENT_APPLY_MODES).optional(),
+var agentWorkspaceHealthRequestSchema = import_zod2.z.strictObject({});
+var agentJobCreateRequestSchema = import_zod2.z.strictObject({
+  annotation: spotAnnotationSchema,
+  applyMode: import_zod2.z.enum(AGENT_APPLY_MODES).optional(),
   providerProfileId: profileIdSchema,
   modelProfileId: profileIdSchema,
-  providerDataConsent: import_zod.z.literal(true),
-  trustedFastModeConsent: import_zod.z.literal(true).optional(),
-  workingTreeMode: import_zod.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+  providerDataConsent: import_zod2.z.literal(true),
+  trustedFastModeConsent: import_zod2.z.literal(true).optional(),
+  workingTreeMode: import_zod2.z.enum(["require-clean", "include-local-changes"]).default("require-clean")
 });
-var agentJobActionRequestSchema = import_zod.z.strictObject({});
+var agentJobActionRequestSchema = import_zod2.z.strictObject({});
 
 // src/protocol/external-handoff-constants.ts
 var EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION = 1;
@@ -280,7 +287,11 @@ var EXTERNAL_HANDOFF_STATES = Object.freeze([
   "expired",
   "superseded"
 ]);
-var EXTERNAL_HANDOFF_FRAMEWORKS = Object.freeze(["vite", "next"]);
+var EXTERNAL_HANDOFF_FRAMEWORKS = Object.freeze([
+  "vite",
+  "next",
+  "astro"
+]);
 var EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS = Object.freeze([
   "claude-channel",
   "codex-app-server"
@@ -336,44 +347,44 @@ var EXTERNAL_HANDOFF_LIMITS = Object.freeze({
 });
 
 // src/protocol/external-handoff.ts
-var opaqueIdSchema = import_zod2.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
-var isoTimestampSchema = import_zod2.z.iso.datetime();
-var externalHandoffReportableDispatchPhaseSchema = import_zod2.z.enum(
+var opaqueIdSchema = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var isoTimestampSchema = import_zod3.z.iso.datetime();
+var externalHandoffReportableDispatchPhaseSchema = import_zod3.z.enum(
   EXTERNAL_HANDOFF_REPORTABLE_DISPATCH_PHASES
 );
-var externalHandoffPageSummarySchema = import_zod2.z.strictObject({
-  origin: import_zod2.z.string().min(1).max(2048),
-  pathname: import_zod2.z.string().min(1).max(2048)
+var externalHandoffPageSummarySchema = import_zod3.z.strictObject({
+  origin: import_zod3.z.string().min(1).max(2048),
+  pathname: import_zod3.z.string().min(1).max(2048)
 });
-var externalHandoffSummarySchema = import_zod2.z.strictObject({
+var externalHandoffSummarySchema = import_zod3.z.strictObject({
   sessionId: opaqueIdSchema,
-  framework: import_zod2.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
-  revision: import_zod2.z.number().int().positive(),
+  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  revision: import_zod3.z.number().int().positive(),
   cursor: opaqueIdSchema,
-  targetCount: import_zod2.z.number().int().positive(),
+  targetCount: import_zod3.z.number().int().positive(),
   page: externalHandoffPageSummarySchema,
   publishedAt: isoTimestampSchema,
   expiresAt: isoTimestampSchema,
-  state: import_zod2.z.enum(EXTERNAL_HANDOFF_STATES),
-  pickupCount: import_zod2.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
+  state: import_zod3.z.enum(EXTERNAL_HANDOFF_STATES),
+  pickupCount: import_zod3.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumConnectorReceipts),
   pickedUpAt: isoTimestampSchema.optional()
 });
-var externalHandoffSnapshotSchema = import_zod2.z.strictObject({
-  schemaVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+var externalHandoffSnapshotSchema = import_zod3.z.strictObject({
+  schemaVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
   cursor: opaqueIdSchema,
-  session: import_zod2.z.strictObject({
+  session: import_zod3.z.strictObject({
     id: opaqueIdSchema,
-    framework: import_zod2.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
+    framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS)
   }),
-  revision: import_zod2.z.number().int().positive(),
+  revision: import_zod3.z.number().int().positive(),
   publishedAt: isoTimestampSchema,
   expiresAt: isoTimestampSchema,
-  annotation: spotAnnotationRequestSchema
+  annotation: spotAnnotationSchema
 });
-var activeAdapterSummarySchema = import_zod2.z.strictObject({
-  kind: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
-  state: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
-  canDispatch: import_zod2.z.boolean(),
+var activeAdapterSummarySchema = import_zod3.z.strictObject({
+  kind: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  state: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_STATES),
+  canDispatch: import_zod3.z.boolean(),
   connectedAt: isoTimestampSchema,
   updatedAt: isoTimestampSchema
 }).superRefine((value, context) => {
@@ -385,47 +396,47 @@ var activeAdapterSummarySchema = import_zod2.z.strictObject({
     });
   }
 });
-var dispatchSummarySchema = import_zod2.z.strictObject({
-  adapterKind: import_zod2.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
-  revision: import_zod2.z.number().int().positive(),
-  phase: import_zod2.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
+var dispatchSummarySchema = import_zod3.z.strictObject({
+  adapterKind: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+  revision: import_zod3.z.number().int().positive(),
+  phase: import_zod3.z.enum(EXTERNAL_HANDOFF_DISPATCH_PHASES),
   updatedAt: isoTimestampSchema
 });
-var externalHandoffCapabilityRequestSchema = import_zod2.z.strictObject({});
-var externalHandoffPublishRequestSchema = import_zod2.z.strictObject({
+var externalHandoffCapabilityRequestSchema = import_zod3.z.strictObject({});
+var externalHandoffPublishRequestSchema = import_zod3.z.strictObject({
   requestId: opaqueIdSchema,
-  annotation: spotAnnotationRequestSchema
+  annotation: spotAnnotationSchema
 });
-var externalHandoffStatusRequestSchema = import_zod2.z.strictObject({
+var externalHandoffStatusRequestSchema = import_zod3.z.strictObject({
   cursor: opaqueIdSchema.optional()
 });
-var externalHandoffResolveDeliveryRequestSchema = import_zod2.z.strictObject({
+var externalHandoffResolveDeliveryRequestSchema = import_zod3.z.strictObject({
   cursor: opaqueIdSchema,
-  confirmation: import_zod2.z.literal("workspace-reviewed")
-});
-var externalHandoffCapabilitySchema = import_zod2.z.strictObject({
-  enabled: import_zod2.z.literal(true),
-  brokerReady: import_zod2.z.boolean(),
-  activeWaitCount: import_zod2.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
-  snapshotSchemaVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
-  brokerProtocolVersion: import_zod2.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+  confirmation: import_zod3.z.literal("workspace-reviewed")
+});
+var externalHandoffCapabilitySchema = import_zod3.z.strictObject({
+  enabled: import_zod3.z.literal(true),
+  brokerReady: import_zod3.z.boolean(),
+  activeWaitCount: import_zod3.z.number().int().nonnegative().max(EXTERNAL_HANDOFF_LIMITS.maximumWaiters),
+  snapshotSchemaVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_SNAPSHOT_SCHEMA_VERSION),
+  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
 });
-var externalHandoffPublishDeliverySchema = import_zod2.z.discriminatedUnion("mode", [
-  import_zod2.z.strictObject({ mode: import_zod2.z.literal("inbox") }),
-  import_zod2.z.strictObject({
-    mode: import_zod2.z.literal("active"),
+var externalHandoffPublishDeliverySchema = import_zod3.z.discriminatedUnion("mode", [
+  import_zod3.z.strictObject({ mode: import_zod3.z.literal("inbox") }),
+  import_zod3.z.strictObject({
+    mode: import_zod3.z.literal("active"),
     adapter: activeAdapterSummarySchema,
     dispatch: dispatchSummarySchema
   })
 ]);
-var externalHandoffPublishResultSchema = import_zod2.z.strictObject({
+var externalHandoffPublishResultSchema = import_zod3.z.strictObject({
   handoff: externalHandoffSummarySchema,
   delivery: externalHandoffPublishDeliverySchema,
-  replayed: import_zod2.z.boolean()
+  replayed: import_zod3.z.boolean()
 });
-var externalHandoffStatusResultSchema = import_zod2.z.strictObject({
+var externalHandoffStatusResultSchema = import_zod3.z.strictObject({
   handoff: externalHandoffSummarySchema,
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
@@ -488,6 +499,24 @@ var ERROR_CODES = {
   APPLY_CONFLICT: "APPLY_CONFLICT",
   INTERNAL_ERROR: "INTERNAL_ERROR"
 };
+var CONTEXTUAL_ASK_ERROR_CODES = Object.freeze([
+  "ASK_DISABLED",
+  "ASK_SELECTION_REQUIRED",
+  "ASK_SELECTION_STALE",
+  "ASK_QUESTION_INVALID",
+  "ASK_EXECUTOR_UNAVAILABLE",
+  "ASK_TIMEOUT",
+  "ASK_CONSENT_REQUIRED",
+  "ASK_BUSY",
+  "ASK_IDEMPOTENCY_CONFLICT",
+  "ASK_SOURCE_SCOPE_DENIED",
+  "ASK_LIMIT_EXCEEDED",
+  "ASK_ANSWER_INVALID",
+  "ASK_WRITE_ATTEMPTED",
+  "ASK_CANCELLED",
+  "ASK_RESULT_EXPIRED",
+  "ASK_PROTOCOL_INCOMPATIBLE"
+]);
 var ERROR_CODE_VALUES = Object.freeze(Object.values(ERROR_CODES));
 
 // src/errors/spotpatch-error.ts
@@ -513,9 +542,78 @@ var SPOTPATCH_BRIDGE_PATHS = Object.freeze({
   activeRelease: "/bridge/v1/active/release"
 });
 var EXTERNAL_HANDOFF_PROJECT_KEY_SALT = "spotpatch-external-agent-project-v1";
-var opaqueIdSchema2 = import_zod3.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
-var projectKeySchema = import_zod3.z.string().length(64).regex(/^[a-f0-9]+$/u);
-var loopbackEndpointSchema = import_zod3.z.url().refine((value) => {
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var WINDOWS_ACL_SCRIPT = String.raw`
+$ErrorActionPreference = 'Stop'
+$target = $env:SPOTPATCH_ACL_TARGET
+$kind = $env:SPOTPATCH_ACL_KIND
+$operation = $env:SPOTPATCH_ACL_OPERATION
+$identity = [System.Security.Principal.WindowsIdentity]::GetCurrent().User
+$allowed = @($identity.Value, 'S-1-5-18', 'S-1-5-32-544')
+if ($kind -eq 'directory') {
+  $item = [System.IO.DirectoryInfo]::new($target)
+  if ($operation -eq 'initialize') {
+    $security = [System.Security.AccessControl.DirectorySecurity]::new()
+    $security.SetOwner($identity)
+    foreach ($sidValue in $allowed) {
+      $sid = [System.Security.Principal.SecurityIdentifier]::new($sidValue)
+      $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+        $sid,
+        [System.Security.AccessControl.FileSystemRights]::FullControl,
+        [System.Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit',
+        [System.Security.AccessControl.PropagationFlags]::None,
+        [System.Security.AccessControl.AccessControlType]::Allow
+      )
+      [void]$security.AddAccessRule($rule)
+    }
+    $security.SetAccessRuleProtection($true, $false)
+    $item.SetAccessControl($security)
+  }
+  $acl = $item.GetAccessControl(
+    [System.Security.AccessControl.AccessControlSections]'Access, Owner'
+  )
+} elseif ($kind -eq 'file') {
+  $item = [System.IO.FileInfo]::new($target)
+  if ($operation -eq 'initialize') {
+    $security = [System.Security.AccessControl.FileSecurity]::new()
+    $security.SetOwner($identity)
+    foreach ($sidValue in $allowed) {
+      $sid = [System.Security.Principal.SecurityIdentifier]::new($sidValue)
+      $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+        $sid,
+        [System.Security.AccessControl.FileSystemRights]::FullControl,
+        [System.Security.AccessControl.AccessControlType]::Allow
+      )
+      [void]$security.AddAccessRule($rule)
+    }
+    $security.SetAccessRuleProtection($true, $false)
+    $item.SetAccessControl($security)
+  }
+  $acl = $item.GetAccessControl(
+    [System.Security.AccessControl.AccessControlSections]'Access, Owner'
+  )
+} else {
+  exit 10
+}
+if ($acl.GetOwner([System.Security.Principal.SecurityIdentifier]).Value -ne $identity.Value) {
+  exit 11
+}
+foreach ($rule in $acl.GetAccessRules(
+  $true,
+  $true,
+  [System.Security.Principal.SecurityIdentifier]
+)) {
+  if (
+    $rule.AccessControlType -eq [System.Security.AccessControl.AccessControlType]::Allow -and
+    $allowed -notcontains $rule.IdentityReference.Value
+  ) {
+    exit 12
+  }
+}
+`;
+var opaqueIdSchema2 = import_zod4.z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u);
+var projectKeySchema = import_zod4.z.string().length(64).regex(/^[a-f0-9]+$/u);
+var loopbackEndpointSchema = import_zod4.z.url().refine((value) => {
   const match = /^http:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/u.exec(value);
   if (match?.[1] === void 0) {
     return false;
@@ -523,115 +621,190 @@ var loopbackEndpointSchema = import_zod3.z.url().refine((value) => {
   const port = Number(match[1]);
   return Number.isSafeInteger(port) && port <= 65535;
 });
-var externalHandoffDescriptorSchema = import_zod3.z.strictObject({
-  schemaVersion: import_zod3.z.literal(1),
-  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+var externalHandoffDescriptorSchema = import_zod4.z.strictObject({
+  schemaVersion: import_zod4.z.literal(1),
+  brokerProtocolVersion: import_zod4.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
   projectKey: projectKeySchema,
   sessionId: opaqueIdSchema2,
-  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
   endpoint: loopbackEndpointSchema,
-  bridgeToken: import_zod3.z.string().min(43).max(128).regex(/^[A-Za-z0-9_-]+$/u),
-  pid: import_zod3.z.number().int().positive(),
-  createdAt: import_zod3.z.iso.datetime()
+  bridgeToken: import_zod4.z.string().min(43).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  pid: import_zod4.z.number().int().positive(),
+  createdAt: import_zod4.z.iso.datetime()
 });
-var bridgeStatusRequestSchema = import_zod3.z.strictObject({});
-var bridgeCurrentRequestSchema = import_zod3.z.strictObject({
+var bridgeStatusRequestSchema = import_zod4.z.strictObject({});
+var bridgeCurrentRequestSchema = import_zod4.z.strictObject({
   cursor: opaqueIdSchema2.optional()
 });
-var bridgeWaitRequestSchema = import_zod3.z.strictObject({
+var bridgeWaitRequestSchema = import_zod4.z.strictObject({
   afterCursor: opaqueIdSchema2.optional(),
-  timeoutMs: import_zod3.z.number().int().positive().max(EXTERNAL_HANDOFF_LIMITS.maximumWaitMs).default(EXTERNAL_HANDOFF_LIMITS.defaultWaitMs)
+  timeoutMs: import_zod4.z.number().int().positive().max(EXTERNAL_HANDOFF_LIMITS.maximumWaitMs).default(EXTERNAL_HANDOFF_LIMITS.defaultWaitMs)
 });
-var bridgeAckRequestSchema = import_zod3.z.strictObject({
+var bridgeAckRequestSchema = import_zod4.z.strictObject({
   cursor: opaqueIdSchema2,
   connectorInstanceId: opaqueIdSchema2
 });
-var bridgeActiveClaimRequestSchema = import_zod3.z.strictObject({
-  adapterKind: import_zod3.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
+var bridgeActiveClaimRequestSchema = import_zod4.z.strictObject({
+  adapterKind: import_zod4.z.enum(EXTERNAL_HANDOFF_ACTIVE_ADAPTER_KINDS),
   connectorInstanceId: opaqueIdSchema2
 });
-var bridgeActiveHeartbeatRequestSchema = import_zod3.z.strictObject({
+var bridgeActiveHeartbeatRequestSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2
 });
-var bridgeActiveReportRequestSchema = import_zod3.z.strictObject({
+var bridgeActiveReportRequestSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2,
   cursor: opaqueIdSchema2,
   phase: externalHandoffReportableDispatchPhaseSchema
 });
-var bridgeActiveReleaseRequestSchema = import_zod3.z.strictObject({
+var bridgeActiveReleaseRequestSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2
 });
-var bridgeStatusSchema = import_zod3.z.strictObject({
-  brokerProtocolVersion: import_zod3.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
+var bridgeStatusSchema = import_zod4.z.strictObject({
+  brokerProtocolVersion: import_zod4.z.literal(EXTERNAL_HANDOFF_BROKER_PROTOCOL_VERSION),
   projectKey: projectKeySchema,
   sessionId: opaqueIdSchema2,
-  framework: import_zod3.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
+  framework: import_zod4.z.enum(EXTERNAL_HANDOFF_FRAMEWORKS),
   current: externalHandoffSummarySchema.nullable()
 });
-var bridgeCurrentResultSchema = import_zod3.z.strictObject({
-  outcome: import_zod3.z.literal("handoff"),
+var bridgeCurrentResultSchema = import_zod4.z.strictObject({
+  outcome: import_zod4.z.literal("handoff"),
   snapshot: externalHandoffSnapshotSchema
 });
-var bridgeWaitResultSchema = import_zod3.z.discriminatedUnion("outcome", [
+var bridgeWaitResultSchema = import_zod4.z.discriminatedUnion("outcome", [
   bridgeCurrentResultSchema,
-  import_zod3.z.strictObject({ outcome: import_zod3.z.literal("timeout") })
+  import_zod4.z.strictObject({ outcome: import_zod4.z.literal("timeout") })
 ]);
-var bridgeAckResultSchema = import_zod3.z.strictObject({
+var bridgeAckResultSchema = import_zod4.z.strictObject({
   summary: externalHandoffSummarySchema
 });
-var bridgeActiveClaimResultSchema = import_zod3.z.strictObject({
+var bridgeActiveClaimResultSchema = import_zod4.z.strictObject({
   leaseToken: opaqueIdSchema2,
-  heartbeatIntervalMs: import_zod3.z.literal(EXTERNAL_HANDOFF_LIMITS.activeHeartbeatIntervalMs),
+  heartbeatIntervalMs: import_zod4.z.literal(EXTERNAL_HANDOFF_LIMITS.activeHeartbeatIntervalMs),
   baselineCursor: opaqueIdSchema2.nullable(),
   activeAdapter: activeAdapterSummarySchema
 });
-var bridgeActiveStateResultSchema = import_zod3.z.strictObject({
+var bridgeActiveStateResultSchema = import_zod4.z.strictObject({
   activeAdapter: activeAdapterSummarySchema.nullable(),
   dispatch: dispatchSummarySchema.nullable()
 });
 var bridgeActiveHeartbeatResultSchema = bridgeActiveStateResultSchema;
 var bridgeActiveReportResultSchema = bridgeActiveStateResultSchema;
 var bridgeActiveReleaseResultSchema = bridgeActiveStateResultSchema;
-function currentUid() {
-  const uid = process.getuid?.();
-  if (uid === void 0) {
+function windowsPowerShellExecutable() {
+  const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
+  if (systemRoot === void 0 || !import_node_path.default.win32.isAbsolute(systemRoot)) {
     throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
   }
-  return uid;
+  return import_node_path.default.win32.join(
+    systemRoot,
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe"
+  );
 }
-async function assertPrivateDirectory(directory, uid) {
-  const status = await (0, import_promises.lstat)(directory);
-  if (!status.isDirectory() || status.isSymbolicLink() || status.uid !== uid || (status.mode & 63) !== 0) {
+async function verifyWindowsAcl(candidate, kind, initialize) {
+  try {
+    await execFileAsync(
+      windowsPowerShellExecutable(),
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", WINDOWS_ACL_SCRIPT],
+      {
+        encoding: "utf8",
+        env: {
+          ...process.env,
+          SPOTPATCH_ACL_KIND: kind,
+          SPOTPATCH_ACL_OPERATION: initialize ? "initialize" : "verify",
+          SPOTPATCH_ACL_TARGET: candidate
+        },
+        timeout: 1e4,
+        windowsHide: true
+      }
+    );
+  } catch (error) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED, void 0, {
+      cause: error
+    });
+  }
+}
+async function assertPrivateExternalHandoffPath(candidate, kind) {
+  const status = await (0, import_promises.lstat)(candidate);
+  const correctKind = kind === "directory" ? status.isDirectory() : status.isFile();
+  if (!correctKind || status.isSymbolicLink()) {
     throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
   }
+  if (process.platform === "win32") {
+    await verifyWindowsAcl(candidate, kind, false);
+    return status;
+  }
+  const uid = process.getuid?.();
+  if (uid === void 0 || status.uid !== uid || (status.mode & 63) !== 0) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
+  return status;
 }
-async function ensurePrivateSubdirectory(base, uid, create) {
+async function initializePrivateExternalHandoffFile(candidate) {
+  if (process.platform === "win32") {
+    await verifyWindowsAcl(candidate, "file", true);
+  }
+}
+async function initializeWindowsDirectory(directory) {
+  if (process.platform === "win32") {
+    await verifyWindowsAcl(directory, "directory", true);
+  }
+}
+async function ensurePrivateSubdirectory(base, create) {
   const directory = import_node_path.default.join(base, "spotpatch");
+  let created = false;
   if (create) {
     try {
       await (0, import_promises.mkdir)(directory, { mode: 448 });
+      created = true;
     } catch (error) {
       if (error.code !== "EEXIST") {
         throw error;
       }
     }
   }
-  await assertPrivateDirectory(directory, uid);
-  return directory;
+  if (created) await initializeWindowsDirectory(directory);
+  await assertPrivateExternalHandoffPath(directory, "directory");
+  return (0, import_promises.realpath)(directory);
 }
-async function resolveExternalHandoffRuntimeDirectory(create) {
-  if (process.platform === "win32") {
+async function resolveWindowsRuntimeDirectory(create) {
+  const configuredBase = process.env.LOCALAPPDATA;
+  if (configuredBase !== void 0 && !import_node_path.default.isAbsolute(configuredBase)) {
     throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
   }
-  const uid = currentUid();
+  const base = configuredBase ?? import_node_path.default.join(import_node_os.default.homedir(), "AppData", "Local");
+  const directory = import_node_path.default.join(base, "SpotPatch", "external-agent-runtime-v1");
+  let created = false;
+  if (create) {
+    created = await (0, import_promises.mkdir)(directory, { mode: 448, recursive: true }) !== void 0;
+  }
+  if (created) await initializeWindowsDirectory(directory);
+  await assertPrivateExternalHandoffPath(directory, "directory");
+  return (0, import_promises.realpath)(directory);
+}
+async function resolveExternalHandoffRuntimeDirectory(create) {
   const xdgRuntimeDirectory = process.env.XDG_RUNTIME_DIR;
   if (xdgRuntimeDirectory !== void 0 && !import_node_path.default.isAbsolute(xdgRuntimeDirectory)) {
     throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
   }
   if (xdgRuntimeDirectory !== void 0) {
     try {
-      await assertPrivateDirectory(xdgRuntimeDirectory, uid);
-      return await ensurePrivateSubdirectory(xdgRuntimeDirectory, uid, create);
+      if (process.platform !== "win32") {
+        await assertPrivateExternalHandoffPath(xdgRuntimeDirectory, "directory");
+      }
+      return await ensurePrivateSubdirectory(xdgRuntimeDirectory, create);
+    } catch (error) {
+      if (!create && error.code === "ENOENT") {
+        throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
+      }
+      throw error;
+    }
+  }
+  if (process.platform === "win32") {
+    try {
+      return await resolveWindowsRuntimeDirectory(create);
     } catch (error) {
       if (!create && error.code === "ENOENT") {
         throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
@@ -639,6 +812,10 @@ async function resolveExternalHandoffRuntimeDirectory(create) {
       throw error;
     }
   }
+  const uid = process.getuid?.();
+  if (uid === void 0) {
+    throw new SpotPatchError(ERROR_CODES.BRIDGE_UNAUTHORIZED);
+  }
   const fallback = import_node_path.default.join(import_node_os.default.tmpdir(), `spotpatch-${String(uid)}`);
   if (create) {
     try {
@@ -650,14 +827,14 @@ async function resolveExternalHandoffRuntimeDirectory(create) {
     }
   }
   try {
-    await assertPrivateDirectory(fallback, uid);
+    await assertPrivateExternalHandoffPath(fallback, "directory");
   } catch (error) {
     if (!create && error.code === "ENOENT") {
       throw new SpotPatchError(ERROR_CODES.SESSION_NOT_FOUND);
     }
     throw error;
   }
-  return fallback;
+  return (0, import_promises.realpath)(fallback);
 }
 async function computeExternalHandoffProjectKey(root) {
   const canonicalRoot = await (0, import_promises.realpath)(root);
@@ -668,6 +845,7 @@ async function computeExternalHandoffProjectKey(root) {
   EXTERNAL_HANDOFF_PROJECT_KEY_SALT,
   SPOTPATCH_BRIDGE_PATHS,
   SPOTPATCH_BRIDGE_TOKEN_HEADER,
+  assertPrivateExternalHandoffPath,
   bridgeAckRequestSchema,
   bridgeAckResultSchema,
   bridgeActiveClaimRequestSchema,
@@ -687,6 +865,7 @@ async function computeExternalHandoffProjectKey(root) {
   bridgeWaitResultSchema,
   computeExternalHandoffProjectKey,
   externalHandoffDescriptorSchema,
+  initializePrivateExternalHandoffFile,
   resolveExternalHandoffRuntimeDirectory
 });
 //# sourceMappingURL=external-agent-node.cjs.map