terminal-pilot 0.0.34 → 0.0.36

package/dist/testing/cli-repl.js

@@ -4,6 +4,10 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/testing/cli-repl.ts
+import path26 from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+
 // src/ansi.ts
 var ESC = 27;
 var BEL = 7;
@@ -79,7 +83,7 @@ function consumeTerminatedString(input, index, allowBellTerminator) {
 
 // src/cli.ts
 import { realpath as realpath3 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // ../toolcraft/src/cli.ts
@@ -2818,17 +2822,17 @@ function validate(schema, value) {
   }
   return { ok: true, value: result.present ? result.value : void 0 };
 }
-function walkSchema(schema, value, path25, state) {
+function walkSchema(schema, value, path27, state) {
   if (schema.kind === "optional") {
-    return walkOptional(schema, value, path25, state);
+    return walkOptional(schema, value, path27, state);
   }
   if (value === missingValue) {
     addIssue(
       state,
-      path25,
+      path27,
       expectedFor(schema),
       "missing",
-      `Expected ${expectedFor(schema)} at ${formatPath(path25)}`
+      `Expected ${expectedFor(schema)} at ${formatPath(path27)}`
     );
     return { present: false };
   }
@@ -2837,149 +2841,149 @@ function walkSchema(schema, value, path25, state) {
   }
   switch (schema.kind) {
     case "string":
-      return walkString(schema, value, path25, state);
+      return walkString(schema, value, path27, state);
     case "number":
-      return walkNumber(schema, value, path25, state);
+      return walkNumber(schema, value, path27, state);
     case "boolean":
-      return walkBoolean(value, path25, state);
+      return walkBoolean(value, path27, state);
     case "enum":
-      return walkEnum(schema, value, path25, state);
+      return walkEnum(schema, value, path27, state);
     case "array":
-      return walkArray(schema, value, path25, state);
+      return walkArray(schema, value, path27, state);
     case "object":
-      return walkObject(schema, value, path25, state);
+      return walkObject(schema, value, path27, state);
     case "oneOf":
-      return walkOneOf(schema, value, path25, state);
+      return walkOneOf(schema, value, path27, state);
     case "union":
-      return walkUnion(schema, value, path25, state);
+      return walkUnion(schema, value, path27, state);
     case "record":
-      return walkRecord(schema, value, path25, state);
+      return walkRecord(schema, value, path27, state);
     case "json":
-      return walkJson(value, path25, state);
+      return walkJson(value, path27, state);
   }
 }
-function walkOptional(schema, value, path25, state) {
+function walkOptional(schema, value, path27, state) {
   if (value === missingValue || value === void 0) {
     const defaultValue = getDefault(schema.inner);
     if (defaultValue.present) {
-      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path25, state);
+      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path27, state);
     }
     return { present: false };
   }
-  return walkSchema(schema.inner, value, path25, state);
+  return walkSchema(schema.inner, value, path27, state);
 }
-function walkString(schema, value, path25, state) {
+function walkString(schema, value, path27, state) {
   if (typeof value !== "string") {
-    addExpectedIssue(state, path25, "string", value);
+    addExpectedIssue(state, path27, "string", value);
     return { present: true, value };
   }
   if (schema.minLength !== void 0 && value.length < schema.minLength) {
     const expected = `string with length at least ${schema.minLength}`;
     addIssue(
       state,
-      path25,
+      path27,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path27)}`
     );
   }
   if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
     const expected = `string with length at most ${schema.maxLength}`;
     addIssue(
       state,
-      path25,
+      path27,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path27)}`
     );
   }
   if (schema.pattern !== void 0) {
     const pattern = compilePattern(schema.pattern);
     if (pattern === void 0 || !pattern.test(value)) {
       const expected = `string matching pattern ${schema.pattern}`;
-      addIssue(state, path25, expected, value, `Expected ${expected} at ${formatPath(path25)}`);
+      addIssue(state, path27, expected, value, `Expected ${expected} at ${formatPath(path27)}`);
     }
   }
   return { present: true, value };
 }
-function walkNumber(schema, value, path25, state) {
+function walkNumber(schema, value, path27, state) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    addExpectedIssue(state, path25, schema.jsonType === "integer" ? "integer" : "number", value);
+    addExpectedIssue(state, path27, schema.jsonType === "integer" ? "integer" : "number", value);
     return { present: true, value };
   }
   if (schema.jsonType === "integer" && !Number.isInteger(value)) {
-    addExpectedIssue(state, path25, "integer", value);
+    addExpectedIssue(state, path27, "integer", value);
   }
   if (schema.minimum !== void 0 && value < schema.minimum) {
     const expected = `number greater than or equal to ${schema.minimum}`;
-    addIssue(state, path25, expected, String(value), `Expected ${expected} at ${formatPath(path25)}`);
+    addIssue(state, path27, expected, String(value), `Expected ${expected} at ${formatPath(path27)}`);
   }
   if (schema.maximum !== void 0 && value > schema.maximum) {
     const expected = `number less than or equal to ${schema.maximum}`;
-    addIssue(state, path25, expected, String(value), `Expected ${expected} at ${formatPath(path25)}`);
+    addIssue(state, path27, expected, String(value), `Expected ${expected} at ${formatPath(path27)}`);
   }
   return { present: true, value };
 }
-function walkBoolean(value, path25, state) {
+function walkBoolean(value, path27, state) {
   if (typeof value !== "boolean") {
-    addExpectedIssue(state, path25, "boolean", value);
+    addExpectedIssue(state, path27, "boolean", value);
   }
   return { present: true, value };
 }
-function walkEnum(schema, value, path25, state) {
+function walkEnum(schema, value, path27, state) {
   if (!schema.values.includes(value)) {
     const expected = `one of ${schema.values.join(", ")}`;
     addIssue(
       state,
-      path25,
+      path27,
       expected,
       receivedValue(value),
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path27)}`
     );
   }
   return { present: true, value };
 }
-function walkArray(schema, value, path25, state) {
+function walkArray(schema, value, path27, state) {
   if (!Array.isArray(value)) {
-    addExpectedIssue(state, path25, "array", value);
+    addExpectedIssue(state, path27, "array", value);
     return { present: true, value };
   }
   if (schema.minItems !== void 0 && value.length < schema.minItems) {
     const expected = `array with at least ${schema.minItems} items`;
     addIssue(
       state,
-      path25,
+      path27,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path27)}`
     );
   }
   if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
     const expected = `array with at most ${schema.maxItems} items`;
     addIssue(
       state,
-      path25,
+      path27,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path27)}`
     );
   }
   const nextValue = value.map((item, index) => {
-    const result = walkSchema(schema.item, item, [...path25, String(index)], state);
+    const result = walkSchema(schema.item, item, [...path27, String(index)], state);
     return result.present ? result.value : item;
   });
   return { present: true, value: nextValue };
 }
-function walkObject(schema, value, path25, state, injectedProperties = {}) {
+function walkObject(schema, value, path27, state, injectedProperties = {}) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path25, "object", value);
+    addExpectedIssue(state, path27, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   const allowedKeys = /* @__PURE__ */ new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
   for (const [key2, propertySchema] of Object.entries(schema.shape)) {
     const propertyValue = Object.hasOwn(value, key2) ? value[key2] : missingValue;
-    const result = walkSchema(propertySchema, propertyValue, [...path25, key2], state);
+    const result = walkSchema(propertySchema, propertyValue, [...path27, key2], state);
     if (result.present) {
       setOwnValue(nextValue, key2, result.value);
     }
@@ -2998,18 +3002,18 @@ function walkObject(schema, value, path25, state, injectedProperties = {}) {
     if (schema.additionalProperties === true) {
       setOwnValue(nextValue, key2, propertyValue);
     } else {
-      addUnexpectedPropertyIssue(state, [...path25, key2]);
+      addUnexpectedPropertyIssue(state, [...path27, key2]);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkOneOf(schema, value, path25, state) {
+function walkOneOf(schema, value, path27, state) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path25, "object", value);
+    addExpectedIssue(state, path27, "object", value);
     return { present: true, value };
   }
   const discriminatorValue = value[schema.discriminator];
-  const discriminatorPath = [...path25, schema.discriminator];
+  const discriminatorPath = [...path27, schema.discriminator];
   const branchValues = Object.keys(schema.branches);
   const expected = `one of ${branchValues.join(", ")}`;
   if (!Object.hasOwn(value, schema.discriminator)) {
@@ -3018,7 +3022,7 @@ function walkOneOf(schema, value, path25, state) {
       discriminatorPath,
       expected,
       "missing",
-      `Missing discriminator "${schema.discriminator}" at ${formatPath(path25)}. Expected one of: ${branchValues.join(", ")}.`
+      `Missing discriminator "${schema.discriminator}" at ${formatPath(path27)}. Expected one of: ${branchValues.join(", ")}.`
     );
     return { present: true, value };
   }
@@ -3032,21 +3036,21 @@ function walkOneOf(schema, value, path25, state) {
     );
     return { present: true, value };
   }
-  return walkObject(schema.branches[discriminatorValue], value, path25, state, {
+  return walkObject(schema.branches[discriminatorValue], value, path27, state, {
     [schema.discriminator]: discriminatorValue
   });
 }
-function walkUnion(schema, value, path25, state) {
+function walkUnion(schema, value, path27, state) {
   if (isPlainRecord(value)) {
     const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
     if (candidateBranches.length === 1) {
-      return walkObject(candidateBranches[0], value, path25, state);
+      return walkObject(candidateBranches[0], value, path27, state);
     }
   }
   const matches = [];
   for (const branch of schema.branches) {
     const branchState = { issues: [] };
-    const result = walkObject(branch, value, path25, branchState);
+    const result = walkObject(branch, value, path27, branchState);
     if (branchState.issues.length === 0 && result.present) {
       matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
     }
@@ -3058,19 +3062,19 @@ function walkUnion(schema, value, path25, state) {
     const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
     addIssueWithMessage(
       state,
-      path25,
+      path27,
       "exactly one union branch",
       "0 matching branches",
-      `No union branch matched at ${formatPath(path25)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
+      `No union branch matched at ${formatPath(path27)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
     );
     return { present: true, value };
   }
   addIssueWithMessage(
     state,
-    path25,
+    path27,
     "exactly one union branch",
     `${matches.length} matching branches`,
-    `Expected exactly one union branch at ${formatPath(path25)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
+    `Expected exactly one union branch at ${formatPath(path27)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
   );
   return { present: true, value };
 }
@@ -3082,25 +3086,25 @@ function hasRequiredKeys(schema, value) {
   }
   return true;
 }
-function walkRecord(schema, value, path25, state) {
+function walkRecord(schema, value, path27, state) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path25, "object", value);
+    addExpectedIssue(state, path27, "object", value);
     return { present: true, value };
   }
   const nextValue = {};
   for (const [key2, propertyValue] of Object.entries(value)) {
-    const result = walkSchema(schema.value, propertyValue, [...path25, key2], state);
+    const result = walkSchema(schema.value, propertyValue, [...path27, key2], state);
     if (result.present) {
       setOwnValue(nextValue, key2, result.value);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkJson(value, path25, state) {
+function walkJson(value, path27, state) {
   if (isJsonValue(value)) {
     return { present: true, value };
   }
-  addExpectedIssue(state, path25, "JSON value", value);
+  addExpectedIssue(state, path27, "JSON value", value);
   return { present: true, value };
 }
 function getDefault(schema) {
@@ -3178,45 +3182,45 @@ function expectedFor(schema) {
       return expectedFor(schema.inner);
   }
 }
-function addExpectedIssue(state, path25, expected, value) {
+function addExpectedIssue(state, path27, expected, value) {
   addIssue(
     state,
-    path25,
+    path27,
     expected,
     receivedType(value),
-    `Expected ${expected} at ${formatPath(path25)}`
+    `Expected ${expected} at ${formatPath(path27)}`
   );
 }
-function addUnexpectedPropertyIssue(state, path25) {
+function addUnexpectedPropertyIssue(state, path27) {
   addIssue(
     state,
-    path25,
+    path27,
     "no additional properties",
     "unknown property",
-    `Unexpected property ${formatPath(path25)}`
+    `Unexpected property ${formatPath(path27)}`
   );
 }
-function addIssue(state, path25, expected, received, _message) {
+function addIssue(state, path27, expected, received, _message) {
   state.issues.push({
-    path: path25,
+    path: path27,
     expected,
     received,
-    message: formatIssueMessage(expected, path25, received)
+    message: formatIssueMessage(expected, path27, received)
   });
 }
-function addIssueWithMessage(state, path25, expected, received, message2) {
+function addIssueWithMessage(state, path27, expected, received, message2) {
   state.issues.push({
-    path: path25,
+    path: path27,
     expected,
     received,
     message: message2
   });
 }
-function formatIssueMessage(expected, path25, received) {
-  return `Expected ${expected} at ${formatPath(path25)}, got ${received}`;
+function formatIssueMessage(expected, path27, received) {
+  return `Expected ${expected} at ${formatPath(path27)}, got ${received}`;
 }
-function formatPath(path25) {
-  return path25.length === 0 ? "value" : path25.join(".");
+function formatPath(path27) {
+  return path27.length === 0 ? "value" : path27.join(".");
 }
 function compilePattern(pattern) {
   try {
@@ -7896,13 +7900,13 @@ function formatAvailableApprovalCommandPaths(root) {
 }
 function enumerateApprovalCommandPaths(root) {
   const paths = [];
-  const visit = (node, path25) => {
+  const visit = (node, path27) => {
     if (node.kind === "command") {
-      paths.push(path25.join("."));
+      paths.push(path27.join("."));
       return;
     }
     for (const child of getVisibleCliChildren(node)) {
-      visit(child, [...path25, child.name]);
+      visit(child, [...path27, child.name]);
     }
   };
   if (root.kind === "command") {
@@ -7939,21 +7943,21 @@ function createHandlerContext(command, params17) {
 }
 function createFs() {
   return {
-    readFile: async (path25, encoding = "utf8") => readFile3(path25, { encoding }),
-    writeFile: async (path25, contents, options) => {
-      await writeFile2(path25, contents, options);
+    readFile: async (path27, encoding = "utf8") => readFile3(path27, { encoding }),
+    writeFile: async (path27, contents, options) => {
+      await writeFile2(path27, contents, options);
     },
-    exists: async (path25) => {
+    exists: async (path27) => {
       try {
-        await access(path25);
+        await access(path27);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path25) => lstat(path25),
+    lstat: async (path27) => lstat(path27),
     rename: async (fromPath, toPath) => rename(fromPath, toPath),
-    unlink: async (path25) => unlink(path25)
+    unlink: async (path27) => unlink(path27)
   };
 }
 function createEnv(values = process.env) {
@@ -11948,13 +11952,13 @@ function convertJsonSchema(schema) {
   }
   return convertSchema(schema, schema, []);
 }
-function convertSchema(schema, root, path25) {
-  const resolvedSchema = resolveReferencedSchema(schema, root, path25);
+function convertSchema(schema, root, path27) {
+  const resolvedSchema = resolveReferencedSchema(schema, root, path27);
   const normalizedSchema = normalizeNullability(resolvedSchema);
   const composition = getComposition(normalizedSchema.schema);
   if (Array.isArray(normalizedSchema.schema.type)) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path25)}" has an unsupported type "${formatJsonSchemaType(
+      `JSON Schema "${formatJsonSchemaPath(path27)}" has an unsupported type "${formatJsonSchemaType(
         normalizedSchema.schema.type
       )}". Supported: string, number, integer, boolean, array, object.`
     );
@@ -11966,13 +11970,13 @@ function convertSchema(schema, root, path25) {
     return convertEnumSchema(resolvedSchema, normalizedSchema.nullable);
   }
   if (composition !== void 0) {
-    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path25);
+    return convertCompositionSchema(normalizedSchema.schema, root, normalizedSchema.nullable, path27);
   }
   if (isRecordSchema(normalizedSchema.schema)) {
     return applyMetadata(
       S.Record(
         convertSchema(normalizedSchema.schema.additionalProperties, root, [
-          ...path25,
+          ...path27,
           "additionalProperties"
         ])
       ),
@@ -12021,12 +12025,12 @@ function convertSchema(schema, root, path25) {
       if (normalizedSchema.schema.items === void 0) {
         throw new Error(
           `JSON Schema "${formatJsonSchemaPath(
-            path25
+            path27
           )}" is an array but is missing the "items" field. Add "items": { ... } to declare the element type.`
         );
       }
       return S.Array(
-        convertSchema(normalizedSchema.schema.items, root, [...path25, "items"]),
+        convertSchema(normalizedSchema.schema.items, root, [...path27, "items"]),
         createCommonOptions(
           normalizedSchema.schema,
           normalizedSchema.nullable,
@@ -12036,7 +12040,7 @@ function convertSchema(schema, root, path25) {
     case "object":
       return convertObjectSchema(normalizedSchema.schema, root, {
         nullable: normalizedSchema.nullable,
-        path: path25
+        path: path27
       });
     case "null":
       return applyMetadata(S.Json(), normalizedSchema.schema, {
@@ -12051,12 +12055,12 @@ function convertSchema(schema, root, path25) {
       }
       throw new Error(
         `JSON Schema "${formatJsonSchemaPath(
-          path25
+          path27
         )}" must declare one of: "type", "enum", "const", "oneOf", "anyOf", or "allOf".`
       );
   }
   throw new Error(
-    `JSON Schema "${formatJsonSchemaPath(path25)}" has an unsupported type "${formatJsonSchemaType(
+    `JSON Schema "${formatJsonSchemaPath(path27)}" has an unsupported type "${formatJsonSchemaType(
       normalizedSchema.schema.type
     )}". Supported: string, number, integer, boolean, array, object.`
   );
@@ -12100,21 +12104,21 @@ function convertEnumSchema(schema, nullable) {
     )
   });
 }
-function convertCompositionSchema(schema, root, nullable, path25) {
+function convertCompositionSchema(schema, root, nullable, path27) {
   const composition = getComposition(schema);
   const branchSchemas = composition?.branches ?? [];
   const keyword = composition?.keyword ?? "oneOf";
   const branches = branchSchemas.map(
-    (branch, index) => resolveReferencedSchema(branch, root, [...path25, keyword, String(index)])
+    (branch, index) => resolveReferencedSchema(branch, root, [...path27, keyword, String(index)])
   );
-  const discriminator = findDiscriminator(branches, root, path25);
+  const discriminator = findDiscriminator(branches, root, path27);
   if (discriminator !== void 0) {
     const convertedBranches = Object.fromEntries(
       branches.map((branch, index) => [
         getDiscriminatorLiteral(branch, discriminator, root),
         convertObjectSchema(branch, root, {
           omitProperty: discriminator,
-          path: [...path25, keyword, String(index)]
+          path: [...path27, keyword, String(index)]
         })
       ])
     );
@@ -12133,7 +12137,7 @@ function convertCompositionSchema(schema, root, nullable, path25) {
     S.Union(
       branches.map(
         (branch, index) => convertObjectSchema(branch, root, {
-          path: [...path25, keyword, String(index)]
+          path: [...path27, keyword, String(index)]
         })
       )
     ),
@@ -12247,11 +12251,11 @@ function getComposition(schema) {
   }
   return void 0;
 }
-function formatJsonSchemaPath(path25) {
-  if (path25.length === 0) {
+function formatJsonSchemaPath(path27) {
+  if (path27.length === 0) {
     return "#";
   }
-  return `#/${path25.map(escapeJsonPointerSegment).join("/")}`;
+  return `#/${path27.map(escapeJsonPointerSegment).join("/")}`;
 }
 function formatJsonSchemaType(type2) {
   return Array.isArray(type2) ? JSON.stringify(type2) : String(type2);
@@ -12267,11 +12271,11 @@ function isRecordSchema(schema) {
   const propertyKeys = Object.keys(schema.properties ?? {});
   return schema.type === "object" && propertyKeys.length === 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null;
 }
-function findDiscriminator(branches, root, path25) {
+function findDiscriminator(branches, root, path27) {
   const [firstBranch] = branches;
   if (firstBranch === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path25)}" uses oneOf/anyOf/allOf but has no branches.`
+      `JSON Schema "${formatJsonSchemaPath(path27)}" uses oneOf/anyOf/allOf but has no branches.`
     );
   }
   const candidateKeys = Object.keys(firstBranch.properties ?? {});
@@ -12311,19 +12315,19 @@ function getDiscriminatorLiteral(branch, key2, root) {
   }
   return void 0;
 }
-function resolveReferencedSchema(schema, root, path25) {
+function resolveReferencedSchema(schema, root, path27) {
   if (schema.$ref === void 0) {
     return schema;
   }
   const resolvedTarget = resolveLocalRef(root, schema.$ref);
   if (resolvedTarget === void 0) {
     throw new Error(
-      `JSON Schema "${formatJsonSchemaPath(path25)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
+      `JSON Schema "${formatJsonSchemaPath(path27)}" uses "$ref": ${schema.$ref}. toolcraft only supports internal refs like "#/components/schemas/Foo".`
     );
   }
   const { $ref: ignoredRef, ...siblingKeywords } = schema;
   void ignoredRef;
-  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path25);
+  const resolvedSchema = resolveReferencedSchema(resolvedTarget, root, path27);
   if (Object.keys(siblingKeywords).length === 0) {
     return resolvedSchema;
   }
@@ -12347,9 +12351,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema, root, path25 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema, root, path27 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path25);
+  nextActivePaths.add(path27);
   const localRefPath = getLocalRefPath(schema.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -12360,13 +12364,13 @@ function hasSelfReferencingRef(schema, root, path25 = "#", activePaths = /* @__P
       return true;
     }
   }
-  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path25}/items`, nextActivePaths)) {
+  if (schema.items !== void 0 && hasSelfReferencingRef(schema.items, root, `${path27}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && hasSelfReferencingRef(
     schema.additionalProperties,
     root,
-    `${path25}/additionalProperties`,
+    `${path27}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -12375,7 +12379,7 @@ function hasSelfReferencingRef(schema, root, path25 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path25}/properties/${escapeJsonPointerSegment(key2)}`,
+      `${path27}/properties/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
@@ -12385,24 +12389,24 @@ function hasSelfReferencingRef(schema, root, path25 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path25}/$defs/${escapeJsonPointerSegment(key2)}`,
+      `${path27}/$defs/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.oneOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path25}/oneOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path27}/oneOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.anyOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path25}/anyOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path27}/anyOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
   for (const [index, childSchema] of (schema.allOf ?? []).entries()) {
-    if (hasSelfReferencingRef(childSchema, root, `${path25}/allOf/${index}`, nextActivePaths)) {
+    if (hasSelfReferencingRef(childSchema, root, `${path27}/allOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -12418,14 +12422,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path25 = getLocalRefPath(ref);
-  if (path25 === void 0) {
+  const path27 = getLocalRefPath(ref);
+  if (path27 === void 0) {
     return void 0;
   }
-  if (path25 === "#") {
+  if (path27 === "#") {
     return root;
   }
-  const segments = path25.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path27.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -13566,23 +13570,23 @@ function extractFieldErrors(body) {
   const flattened = candidates.flatMap((candidate) => flattenFieldErrors(candidate, []));
   return flattened.length === 0 ? void 0 : flattened;
 }
-function flattenFieldErrors(value, path25) {
+function flattenFieldErrors(value, path27) {
   if (typeof value === "string") {
-    return [{ path: formatPath2(path25), message: value }];
+    return [{ path: formatPath2(path27), message: value }];
   }
   if (Array.isArray(value)) {
     if (value.every((entry) => typeof entry === "string")) {
-      return value.map((message2) => ({ path: formatPath2(path25), message: message2 }));
+      return value.map((message2) => ({ path: formatPath2(path27), message: message2 }));
     }
-    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path25, String(index)]));
+    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path27, String(index)]));
   }
   if (!isPlainObject4(value)) {
     return [];
   }
-  return Object.entries(value).flatMap(([key2, nested]) => flattenFieldErrors(nested, [...path25, key2]));
+  return Object.entries(value).flatMap(([key2, nested]) => flattenFieldErrors(nested, [...path27, key2]));
 }
-function formatPath2(path25) {
-  return path25.length === 0 ? "error" : path25.join(".");
+function formatPath2(path27) {
+  return path27.length === 0 ? "error" : path27.join(".");
 }
 function extractFirstString(body, fields) {
   if (!isPlainObject4(body)) {
@@ -14152,11 +14156,11 @@ function formatSegment(segment, casing) {
   const separator = casing === "snake" ? "_" : "-";
   return splitWords3(segment).join(separator);
 }
-function toOptionFlag(path25, casing) {
-  return `--${path25.map((segment) => formatSegment(segment, casing)).join(".")}`;
+function toOptionFlag(path27, casing) {
+  return `--${path27.map((segment) => formatSegment(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path25, casing) {
-  return path25.map((segment) => {
+function toOptionAttribute(path27, casing) {
+  return path27.map((segment) => {
     const formatted = formatSegment(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -14167,23 +14171,23 @@ function toOptionAttribute(path25, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path25) {
-  return path25.join(".");
+function toDisplayPath(path27) {
+  return path27.join(".");
 }
-function toUnionKindControlPath(path25) {
-  if (path25.length === 0) {
+function toUnionKindControlPath(path27) {
+  if (path27.length === 0) {
     return ["kind"];
   }
-  const head = path25.slice(0, -1);
-  const tail = path25[path25.length - 1] ?? "";
+  const head = path27.slice(0, -1);
+  const tail = path27[path27.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path25) {
-  if (path25.length === 0) {
+function toUnionKindDisplayPath(path27) {
+  if (path27.length === 0) {
     return "kind";
   }
-  const head = path25.slice(0, -1);
-  const tail = path25[path25.length - 1] ?? "";
+  const head = path27.slice(0, -1);
+  const tail = path27[path27.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -14199,14 +14203,14 @@ function getRequiredBranchFingerprint(branch, casing) {
   const requiredKeys = Object.entries(branch.shape).filter(([, schema]) => schema.kind !== "optional").map(([key2]) => formatSegment(key2, casing)).sort();
   return requiredKeys.join("+");
 }
-function collectFields(schema, casing, globalLongOptionFlags, path25 = [], inheritedOptional = false, variantContext) {
+function collectFields(schema, casing, globalLongOptionFlags, path27 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key2, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path25, key2];
+    const nextPath = [...path27, key2];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional2(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
@@ -14392,9 +14396,9 @@ function collectFields(schema, casing, globalLongOptionFlags, path25 = [], inher
   }
   return collected;
 }
-function toCommanderOptionAttribute(path25, casing, globalLongOptionFlags) {
-  const optionAttribute = toOptionAttribute(path25, casing);
-  const optionFlag = toOptionFlag(path25, casing);
+function toCommanderOptionAttribute(path27, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path27, casing);
+  const optionFlag = toOptionFlag(path27, casing);
   if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
@@ -15724,10 +15728,10 @@ function writeCLIDiagnosticEvent(event) {
   process.stderr.write(`${event.message}
 `);
 }
-function setNestedValue(target, path25, value) {
+function setNestedValue(target, path27, value) {
   let cursor2 = target;
-  for (let index = 0; index < path25.length - 1; index += 1) {
-    const segment = path25[index] ?? "";
+  for (let index = 0; index < path27.length - 1; index += 1) {
+    const segment = path27[index] ?? "";
     const existing = Object.prototype.hasOwnProperty.call(cursor2, segment) ? cursor2[segment] : void 0;
     if (typeof existing === "object" && existing !== null) {
       cursor2 = existing;
@@ -15742,7 +15746,7 @@ function setNestedValue(target, path25, value) {
     });
     cursor2 = next;
   }
-  const leaf = path25[path25.length - 1];
+  const leaf = path27[path27.length - 1];
   if (leaf !== void 0) {
     Object.defineProperty(cursor2, leaf, {
       value,
@@ -15890,21 +15894,21 @@ async function withOutputFormat2(output, fn) {
 }
 function createFs2() {
   return {
-    readFile: async (path25, encoding = "utf8") => readFile5(path25, { encoding }),
-    writeFile: async (path25, contents, options) => {
-      await writeFile5(path25, contents, options);
+    readFile: async (path27, encoding = "utf8") => readFile5(path27, { encoding }),
+    writeFile: async (path27, contents, options) => {
+      await writeFile5(path27, contents, options);
     },
-    exists: async (path25) => {
+    exists: async (path27) => {
       try {
-        await access2(path25);
+        await access2(path27);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path25) => lstat3(path25),
+    lstat: async (path27) => lstat3(path27),
     rename: async (fromPath, toPath) => rename3(fromPath, toPath),
-    unlink: async (path25) => unlink3(path25)
+    unlink: async (path27) => unlink3(path27)
   };
 }
 function createEnv2(values = process.env) {
@@ -15920,9 +15924,9 @@ function isPlainObject5(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path25) {
+function hasNestedField(fields, path27) {
   return fields.some(
-    (field) => path25.length < field.path.length && path25.every((segment, index) => field.path[index] === segment)
+    (field) => path27.length < field.path.length && path27.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -16051,9 +16055,9 @@ async function loadPresetValues(fields, presetPath) {
   }
   const fieldByPath = new Map(fields.map((field) => [field.displayPath, field]));
   const presetValues = {};
-  function visitObject(current, path25) {
+  function visitObject(current, path27) {
     for (const [key2, value] of Object.entries(current)) {
-      const nextPath = [...path25, key2];
+      const nextPath = [...path27, key2];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -16446,8 +16450,8 @@ function validateServices(services) {
     }
   }
 }
-function getNestedValue(target, path25) {
-  return path25.reduce(
+function getNestedValue(target, path27) {
+  return path27.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -19306,13 +19310,6 @@ function createTerminalPilotRuntime(options = {}) {
     }
   };
 }
-async function closeSharedTerminalPilotRuntime() {
-  if (sharedRuntime === void 0) {
-    return;
-  }
-  await sharedRuntime.close();
-  sharedRuntime = void 0;
-}
 
 // src/commands/close-session.ts
 var params = S.Object({
@@ -19902,22 +19899,22 @@ function prune(obj, shape) {
   }
   return { changed, result };
 }
-function modifyAtPath(content, path25, value) {
+function modifyAtPath(content, path27, value) {
   const indent = detectIndent(content);
   const formattingOptions = {
     tabSize: indent === "	" ? 1 : indent.length,
     insertSpaces: indent !== "	",
     eol: "\n"
   };
-  const edits = jsonc.modify(content, path25, value, { formattingOptions });
+  const edits = jsonc.modify(content, path27, value, { formattingOptions });
   let result = jsonc.applyEdits(content, edits);
   if (!result.endsWith("\n")) {
     result += "\n";
   }
   return result;
 }
-function removeAtPath(content, path25) {
-  return modifyAtPath(content, path25, void 0);
+function removeAtPath(content, path27) {
+  return modifyAtPath(content, path27, void 0);
 }
 function serializeUpdate(content, current, next) {
   let result = content || "{}";
@@ -19927,15 +19924,15 @@ function serializeUpdate(content, current, next) {
   }
   return result;
 }
-function applyObjectUpdate(content, path25, current, next) {
+function applyObjectUpdate(content, path27, current, next) {
   let result = content;
   for (const key2 of Object.keys(current)) {
     if (!hasConfigEntry(next, key2)) {
-      result = removeAtPath(result, [...path25, key2]);
+      result = removeAtPath(result, [...path27, key2]);
     }
   }
   for (const [key2, nextValue] of Object.entries(next)) {
-    const nextPath = [...path25, key2];
+    const nextPath = [...path27, key2];
     const hasCurrent = hasConfigEntry(current, key2);
     const currentValue = hasCurrent ? current[key2] : void 0;
     if (hasCurrent && isConfigObject(currentValue) && isConfigObject(nextValue)) {
@@ -20135,16 +20132,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path25) {
-  const ext = getExtension(path25);
+function detectFormat(path27) {
+  const ext = getExtension(path27);
   return extensionMap[ext];
 }
-function getExtension(path25) {
-  const lastDot = path25.lastIndexOf(".");
+function getExtension(path27) {
+  const lastDot = path27.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path25.slice(lastDot).toLowerCase();
+  return path27.slice(lastDot).toLowerCase();
 }
 
 // ../config-mutations/src/execution/path-utils.ts
@@ -22762,6 +22759,394 @@ function createTerminalPilotGroup() {
 }
 var terminalPilotGroup = Object.freeze(createTerminalPilotGroup());
 
+// src/commands/daemon-runtime.ts
+import { spawn as spawn7 } from "node:child_process";
+import { createHash as createHash5 } from "node:crypto";
+import { mkdir as mkdir3, unlink as unlink4 } from "node:fs/promises";
+import net from "node:net";
+import os4 from "node:os";
+import path24 from "node:path";
+var RUNTIME_DIR_ENV = "TERMINAL_PILOT_RUNTIME_DIR";
+var DAEMON_ARG = "__daemon";
+var START_TIMEOUT_MS = 5e3;
+var IDLE_SHUTDOWN_MS = 1e3;
+function isTerminalPilotDaemonArgv(argv) {
+  return argv[2] === DAEMON_ARG;
+}
+async function runTerminalPilotDaemon() {
+  const runtime = createTerminalPilotRuntime();
+  const socketPath = resolveSocketPath(process.env);
+  await mkdir3(path24.dirname(socketPath), { recursive: true });
+  if (process.platform !== "win32") {
+    await unlink4(socketPath).catch(() => void 0);
+  }
+  let idleTimer;
+  const server = net.createServer((socket) => {
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      while (true) {
+        const newlineIndex = buffer.indexOf("\n");
+        if (newlineIndex < 0) {
+          break;
+        }
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        void handleRequestLine(runtime, line).then((response) => {
+          socket.write(`${JSON.stringify(response)}
+`);
+          scheduleIdleShutdown();
+        });
+      }
+    });
+  });
+  async function shutdown() {
+    if (idleTimer !== void 0) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+    await runtime.close();
+    await new Promise((resolve) => {
+      server.close(() => resolve());
+    });
+    if (process.platform !== "win32") {
+      await unlink4(socketPath).catch(() => void 0);
+    }
+  }
+  async function scheduleIdleShutdown() {
+    if (idleTimer !== void 0) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+    const sessions = await runtime.listSessions();
+    if (sessions.length > 0) {
+      return;
+    }
+    idleTimer = setTimeout(() => {
+      void shutdown().then(() => {
+        process.exit(0);
+      });
+    }, IDLE_SHUTDOWN_MS);
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+}
+function createDaemonTerminalPilotRuntime() {
+  let nextId = 1;
+  async function request(method, params17) {
+    await ensureDaemon();
+    return sendRequest(method, params17, nextId++);
+  }
+  function proxySession(name, info2) {
+    return {
+      id: info2.id,
+      command: info2.command,
+      pid: info2.pid,
+      exitCode: info2.exitCode,
+      fill: async (text4) => {
+        await request("sessionAction", { name, action: "fill", args: [text4] });
+      },
+      type: async (text4) => {
+        await request("sessionAction", { name, action: "type", args: [text4] });
+      },
+      press: async (key2) => {
+        await request("sessionAction", { name, action: "press", args: [key2] });
+      },
+      signal: async (signal) => {
+        await request("sessionAction", { name, action: "signal", args: [signal] });
+      },
+      waitFor: async (pattern, options) => request("sessionAction", {
+        name,
+        action: "waitFor",
+        args: [serializePattern(pattern), options]
+      }),
+      waitForExit: async (options) => request("sessionAction", { name, action: "waitForExit", args: [options] }),
+      screen: async () => request("sessionAction", { name, action: "screen", args: [] }),
+      history: async (options) => request("sessionAction", { name, action: "history", args: [options] }),
+      resize: async (cols, rows) => {
+        await request("sessionAction", { name, action: "resize", args: [cols, rows] });
+      },
+      close: async () => {
+        const result = await request("closeSession", { name });
+        return result.exitCode;
+      }
+    };
+  }
+  return {
+    async createSession(params17, env) {
+      const result = await request("createSession", {
+        params: params17,
+        envSession: env?.get(SESSION_ENV_VAR)
+      });
+      return { name: result.name, session: proxySession(result.name, result.session) };
+    },
+    async resolveSession(name, env) {
+      const result = await request("resolveSession", {
+        name,
+        envSession: env?.get(SESSION_ENV_VAR)
+      });
+      return { name: result.name, session: proxySession(result.name, result.session) };
+    },
+    async closeSession(name, env) {
+      return request("closeSession", {
+        name,
+        envSession: env?.get(SESSION_ENV_VAR)
+      });
+    },
+    async listSessions() {
+      const sessions = await request("listSessions");
+      return sessions.map((entry) => ({
+        name: entry.name,
+        session: proxySession(entry.name, entry.session)
+      }));
+    },
+    async close() {
+      await request("shutdown").catch(() => void 0);
+    }
+  };
+}
+async function handleRequestLine(runtime, line) {
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch (error3) {
+    return {
+      id: 0,
+      ok: false,
+      error: { message: error3 instanceof Error ? error3.message : "Invalid request" }
+    };
+  }
+  try {
+    const result = await handleRequest(runtime, request);
+    return { id: request.id, ok: true, result };
+  } catch (error3) {
+    return {
+      id: request.id,
+      ok: false,
+      error: { message: error3 instanceof Error ? error3.message : String(error3) }
+    };
+  }
+}
+async function handleRequest(runtime, request) {
+  const params17 = isRecord6(request.params) ? request.params : {};
+  if (request.method === "ping") {
+    return { ok: true };
+  }
+  if (request.method === "createSession") {
+    const createParams = isRecord6(params17.params) ? params17.params : {};
+    const namedSession = await runtime.createSession(
+      createParams,
+      envFromValue(params17.envSession)
+    );
+    return formatNamedSession(namedSession);
+  }
+  if (request.method === "resolveSession") {
+    const namedSession = await runtime.resolveSession(
+      optionalString2(params17.name),
+      envFromValue(params17.envSession)
+    );
+    return formatNamedSession(namedSession);
+  }
+  if (request.method === "listSessions") {
+    const sessions = await runtime.listSessions();
+    return sessions.map(formatNamedSession);
+  }
+  if (request.method === "closeSession") {
+    return runtime.closeSession(optionalString2(params17.name), envFromValue(params17.envSession));
+  }
+  if (request.method === "sessionAction") {
+    return runSessionAction(runtime, params17);
+  }
+  if (request.method === "shutdown") {
+    await runtime.close();
+    process.exit(0);
+  }
+  throw new UserError(`Unknown terminal-pilot daemon method: ${request.method}`);
+}
+async function runSessionAction(runtime, params17) {
+  const name = optionalString2(params17.name);
+  const action = optionalString2(params17.action);
+  const args = Array.isArray(params17.args) ? params17.args : [];
+  const namedSession = await runtime.resolveSession(name);
+  const session = namedSession.session;
+  if (action === "fill") {
+    await session.fill(String(args[0] ?? ""));
+    return void 0;
+  }
+  if (action === "type") {
+    await session.type(String(args[0] ?? ""));
+    return void 0;
+  }
+  if (action === "press") {
+    await session.press(String(args[0] ?? ""));
+    return void 0;
+  }
+  if (action === "signal") {
+    await session.signal(String(args[0] ?? ""));
+    return void 0;
+  }
+  if (action === "waitFor") {
+    return session.waitFor(deserializePattern(args[0]), optionalRecord(args[1]));
+  }
+  if (action === "waitForExit") {
+    return session.waitForExit(optionalRecord(args[0]));
+  }
+  if (action === "screen") {
+    const screen = await session.screen();
+    return {
+      lines: [...screen.lines],
+      rawLines: [...screen.rawLines],
+      cursor: { ...screen.cursor },
+      size: { ...screen.size }
+    };
+  }
+  if (action === "history") {
+    return session.history(optionalRecord(args[0]));
+  }
+  if (action === "resize") {
+    await session.resize(Number(args[0]), Number(args[1]));
+    return void 0;
+  }
+  throw new UserError(`Unknown terminal-pilot session action: ${action ?? "<missing>"}`);
+}
+async function ensureDaemon() {
+  try {
+    await sendRequest("ping", void 0, 0, { start: false });
+    return;
+  } catch {
+  }
+  const socketPath = resolveSocketPath(process.env);
+  await mkdir3(path24.dirname(socketPath), { recursive: true });
+  if (process.platform !== "win32") {
+    await unlink4(socketPath).catch(() => void 0);
+  }
+  const entryPoint = process.argv[1];
+  if (typeof entryPoint !== "string" || entryPoint.length === 0) {
+    throw new UserError("Cannot start terminal-pilot daemon: entrypoint is unknown.");
+  }
+  const child = spawn7(process.execPath, [...process.execArgv, entryPoint, DAEMON_ARG], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+  const startedAt = Date.now();
+  while (Date.now() - startedAt <= START_TIMEOUT_MS) {
+    try {
+      await sendRequest("ping", void 0, 0, { start: false });
+      return;
+    } catch {
+      await sleep2(50);
+    }
+  }
+  throw new UserError("Timed out waiting for terminal-pilot daemon to start.");
+}
+function sendRequest(method, params17, id, options = {}) {
+  const socketPath = resolveSocketPath(process.env);
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(socketPath);
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      const request = { id, method, params: params17 };
+      socket.write(`${JSON.stringify(request)}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex < 0) {
+        return;
+      }
+      const line = buffer.slice(0, newlineIndex);
+      socket.end();
+      try {
+        const response = JSON.parse(line);
+        if (response.ok) {
+          resolve(response.result);
+        } else {
+          reject(new UserError(response.error.message));
+        }
+      } catch (error3) {
+        reject(error3);
+      }
+    });
+    socket.on("error", (error3) => {
+      if (options.start === false) {
+        reject(error3);
+        return;
+      }
+      reject(new UserError(error3.message));
+    });
+  });
+}
+function resolveSocketPath(env) {
+  const runtimeDir = env[RUNTIME_DIR_ENV] ?? path24.join(os4.tmpdir(), `terminal-pilot-${process.getuid?.() ?? "user"}`);
+  if (process.platform === "win32") {
+    const hash = createHash5("sha256").update(runtimeDir).digest("hex").slice(0, 16);
+    return `\\\\.\\pipe\\terminal-pilot-${hash}`;
+  }
+  return path24.join(runtimeDir, "daemon.sock");
+}
+function formatNamedSession(namedSession) {
+  return {
+    name: namedSession.name,
+    session: formatSession(namedSession.session)
+  };
+}
+function formatSession(session) {
+  return {
+    id: session.id,
+    command: session.command,
+    pid: session.pid,
+    exitCode: session.exitCode
+  };
+}
+function envFromValue(value) {
+  const sessionName = optionalString2(value);
+  if (sessionName === void 0) {
+    return void 0;
+  }
+  return {
+    get(key2) {
+      return key2 === SESSION_ENV_VAR ? sessionName : void 0;
+    }
+  };
+}
+function serializePattern(pattern) {
+  if (typeof pattern === "string") {
+    return { kind: "literal", value: pattern };
+  }
+  return { kind: "regex", source: pattern.source, flags: pattern.flags };
+}
+function deserializePattern(value) {
+  if (!isRecord6(value)) {
+    return String(value ?? "");
+  }
+  if (value.kind === "regex") {
+    return new RegExp(String(value.source ?? ""), String(value.flags ?? ""));
+  }
+  return String(value.value ?? "");
+}
+function optionalRecord(value) {
+  return isRecord6(value) ? value : void 0;
+}
+function optionalString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/cli.ts
 configureTheme({ brand: "green", label: "Terminal Pilot" });
 function normalizeArgv(argv) {
@@ -22770,11 +23155,18 @@ function normalizeArgv(argv) {
   }
   return argv;
 }
-async function main(argv = process.argv) {
+async function main(argv = process.argv, options = {}) {
+  if (isTerminalPilotDaemonArgv(argv)) {
+    await runTerminalPilotDaemon();
+    return;
+  }
   const originalArgv = process.argv;
   process.argv = normalizeArgv(argv);
   try {
     await runCLI(createTerminalPilotGroup(), {
+      services: {
+        terminalPilotRuntime: options.terminalPilotRuntime ?? createDaemonTerminalPilotRuntime()
+      },
       controls: {
         debug: true,
         output: true,
@@ -22794,7 +23186,7 @@ async function isDirectExecution(argv) {
   try {
     const modulePath = fileURLToPath5(import.meta.url);
     const [resolvedEntryPoint, resolvedModulePath] = await Promise.all([
-      realpath3(path24.resolve(entryPoint)),
+      realpath3(path25.resolve(entryPoint)),
       realpath3(modulePath)
     ]);
     return resolvedEntryPoint === resolvedModulePath;
@@ -22807,6 +23199,7 @@ if (await isDirectExecution(process.argv)) {
 }
 
 // src/testing/cli-repl.ts
+var cliPath = path26.join(path26.dirname(fileURLToPath6(import.meta.url)), "..", "cli.ts");
 function appendJsonOutputFlag(args) {
   if (args.includes("--json") || args.includes("--output") || args.some((arg) => arg.startsWith("--output="))) {
     return [...args];
@@ -22841,6 +23234,7 @@ function canParseJson(text4) {
   }
 }
 function createTerminalPilotCliRepl() {
+  const terminalPilotRuntime = createTerminalPilotRuntime();
   return {
     async run(args) {
       const stdoutChunks = [];
@@ -22862,7 +23256,7 @@ function createTerminalPilotCliRepl() {
         return true;
       });
       try {
-        await main(["node", "terminal-pilot", ...args]);
+        await main(["node", cliPath, ...args], { terminalPilotRuntime });
       } finally {
         process.stdout.write = originalStdoutWrite;
         process.stderr.write = originalStderrWrite;
@@ -22891,7 +23285,9 @@ function createTerminalPilotCliRepl() {
         };
       }
       if (result.stdout.length === 0) {
-        throw new Error(`Expected JSON output for terminal-pilot ${args.join(" ")}, but stdout was empty.`);
+        throw new Error(
+          `Expected JSON output for terminal-pilot ${args.join(" ")}, but stdout was empty.`
+        );
       }
       return {
         exitCode: result.exitCode,
@@ -22900,7 +23296,7 @@ function createTerminalPilotCliRepl() {
       };
     },
     async close() {
-      await closeSharedTerminalPilotRuntime();
+      await terminalPilotRuntime.close();
     }
   };
 }