terminal-pilot 0.0.34 → 0.0.36

package/dist/cli.js

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 
 // 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
@@ -2746,17 +2746,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, path26, state) {
   if (schema.kind === "optional") {
-    return walkOptional(schema, value, path25, state);
+    return walkOptional(schema, value, path26, state);
   }
   if (value === missingValue) {
     addIssue(
       state,
-      path25,
+      path26,
       expectedFor(schema),
       "missing",
-      `Expected ${expectedFor(schema)} at ${formatPath(path25)}`
+      `Expected ${expectedFor(schema)} at ${formatPath(path26)}`
     );
     return { present: false };
   }
@@ -2765,149 +2765,149 @@ function walkSchema(schema, value, path25, state) {
   }
   switch (schema.kind) {
     case "string":
-      return walkString(schema, value, path25, state);
+      return walkString(schema, value, path26, state);
     case "number":
-      return walkNumber(schema, value, path25, state);
+      return walkNumber(schema, value, path26, state);
     case "boolean":
-      return walkBoolean(value, path25, state);
+      return walkBoolean(value, path26, state);
     case "enum":
-      return walkEnum(schema, value, path25, state);
+      return walkEnum(schema, value, path26, state);
     case "array":
-      return walkArray(schema, value, path25, state);
+      return walkArray(schema, value, path26, state);
     case "object":
-      return walkObject(schema, value, path25, state);
+      return walkObject(schema, value, path26, state);
     case "oneOf":
-      return walkOneOf(schema, value, path25, state);
+      return walkOneOf(schema, value, path26, state);
     case "union":
-      return walkUnion(schema, value, path25, state);
+      return walkUnion(schema, value, path26, state);
     case "record":
-      return walkRecord(schema, value, path25, state);
+      return walkRecord(schema, value, path26, state);
     case "json":
-      return walkJson(value, path25, state);
+      return walkJson(value, path26, state);
   }
 }
-function walkOptional(schema, value, path25, state) {
+function walkOptional(schema, value, path26, 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), path26, state);
     }
     return { present: false };
   }
-  return walkSchema(schema.inner, value, path25, state);
+  return walkSchema(schema.inner, value, path26, state);
 }
-function walkString(schema, value, path25, state) {
+function walkString(schema, value, path26, state) {
   if (typeof value !== "string") {
-    addExpectedIssue(state, path25, "string", value);
+    addExpectedIssue(state, path26, "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,
+      path26,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path26)}`
     );
   }
   if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
     const expected = `string with length at most ${schema.maxLength}`;
     addIssue(
       state,
-      path25,
+      path26,
       expected,
       `string with length ${value.length}`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path26)}`
     );
   }
   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, path26, expected, value, `Expected ${expected} at ${formatPath(path26)}`);
     }
   }
   return { present: true, value };
 }
-function walkNumber(schema, value, path25, state) {
+function walkNumber(schema, value, path26, state) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    addExpectedIssue(state, path25, schema.jsonType === "integer" ? "integer" : "number", value);
+    addExpectedIssue(state, path26, schema.jsonType === "integer" ? "integer" : "number", value);
     return { present: true, value };
   }
   if (schema.jsonType === "integer" && !Number.isInteger(value)) {
-    addExpectedIssue(state, path25, "integer", value);
+    addExpectedIssue(state, path26, "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, path26, expected, String(value), `Expected ${expected} at ${formatPath(path26)}`);
   }
   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, path26, expected, String(value), `Expected ${expected} at ${formatPath(path26)}`);
   }
   return { present: true, value };
 }
-function walkBoolean(value, path25, state) {
+function walkBoolean(value, path26, state) {
   if (typeof value !== "boolean") {
-    addExpectedIssue(state, path25, "boolean", value);
+    addExpectedIssue(state, path26, "boolean", value);
   }
   return { present: true, value };
 }
-function walkEnum(schema, value, path25, state) {
+function walkEnum(schema, value, path26, state) {
   if (!schema.values.includes(value)) {
     const expected = `one of ${schema.values.join(", ")}`;
     addIssue(
       state,
-      path25,
+      path26,
       expected,
       receivedValue(value),
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path26)}`
     );
   }
   return { present: true, value };
 }
-function walkArray(schema, value, path25, state) {
+function walkArray(schema, value, path26, state) {
   if (!Array.isArray(value)) {
-    addExpectedIssue(state, path25, "array", value);
+    addExpectedIssue(state, path26, "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,
+      path26,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path26)}`
     );
   }
   if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
     const expected = `array with at most ${schema.maxItems} items`;
     addIssue(
       state,
-      path25,
+      path26,
       expected,
       `array with ${value.length} items`,
-      `Expected ${expected} at ${formatPath(path25)}`
+      `Expected ${expected} at ${formatPath(path26)}`
     );
   }
   const nextValue = value.map((item, index) => {
-    const result = walkSchema(schema.item, item, [...path25, String(index)], state);
+    const result = walkSchema(schema.item, item, [...path26, 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, path26, state, injectedProperties = {}) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path25, "object", value);
+    addExpectedIssue(state, path26, "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, [...path26, key2], state);
     if (result.present) {
       setOwnValue(nextValue, key2, result.value);
     }
@@ -2926,18 +2926,18 @@ function walkObject(schema, value, path25, state, injectedProperties = {}) {
     if (schema.additionalProperties === true) {
       setOwnValue(nextValue, key2, propertyValue);
     } else {
-      addUnexpectedPropertyIssue(state, [...path25, key2]);
+      addUnexpectedPropertyIssue(state, [...path26, key2]);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkOneOf(schema, value, path25, state) {
+function walkOneOf(schema, value, path26, state) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path25, "object", value);
+    addExpectedIssue(state, path26, "object", value);
     return { present: true, value };
   }
   const discriminatorValue = value[schema.discriminator];
-  const discriminatorPath = [...path25, schema.discriminator];
+  const discriminatorPath = [...path26, schema.discriminator];
   const branchValues = Object.keys(schema.branches);
   const expected = `one of ${branchValues.join(", ")}`;
   if (!Object.hasOwn(value, schema.discriminator)) {
@@ -2946,7 +2946,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(path26)}. Expected one of: ${branchValues.join(", ")}.`
     );
     return { present: true, value };
   }
@@ -2960,21 +2960,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, path26, state, {
     [schema.discriminator]: discriminatorValue
   });
 }
-function walkUnion(schema, value, path25, state) {
+function walkUnion(schema, value, path26, 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, path26, state);
     }
   }
   const matches = [];
   for (const branch of schema.branches) {
     const branchState = { issues: [] };
-    const result = walkObject(branch, value, path25, branchState);
+    const result = walkObject(branch, value, path26, branchState);
     if (branchState.issues.length === 0 && result.present) {
       matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
     }
@@ -2986,19 +2986,19 @@ function walkUnion(schema, value, path25, state) {
     const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
     addIssueWithMessage(
       state,
-      path25,
+      path26,
       "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(path26)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
     );
     return { present: true, value };
   }
   addIssueWithMessage(
     state,
-    path25,
+    path26,
     "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(path26)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
   );
   return { present: true, value };
 }
@@ -3010,25 +3010,25 @@ function hasRequiredKeys(schema, value) {
   }
   return true;
 }
-function walkRecord(schema, value, path25, state) {
+function walkRecord(schema, value, path26, state) {
   if (!isPlainRecord(value)) {
-    addExpectedIssue(state, path25, "object", value);
+    addExpectedIssue(state, path26, "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, [...path26, key2], state);
     if (result.present) {
       setOwnValue(nextValue, key2, result.value);
     }
   }
   return { present: true, value: nextValue };
 }
-function walkJson(value, path25, state) {
+function walkJson(value, path26, state) {
   if (isJsonValue(value)) {
     return { present: true, value };
   }
-  addExpectedIssue(state, path25, "JSON value", value);
+  addExpectedIssue(state, path26, "JSON value", value);
   return { present: true, value };
 }
 function getDefault(schema) {
@@ -3106,45 +3106,45 @@ function expectedFor(schema) {
       return expectedFor(schema.inner);
   }
 }
-function addExpectedIssue(state, path25, expected, value) {
+function addExpectedIssue(state, path26, expected, value) {
   addIssue(
     state,
-    path25,
+    path26,
     expected,
     receivedType(value),
-    `Expected ${expected} at ${formatPath(path25)}`
+    `Expected ${expected} at ${formatPath(path26)}`
   );
 }
-function addUnexpectedPropertyIssue(state, path25) {
+function addUnexpectedPropertyIssue(state, path26) {
   addIssue(
     state,
-    path25,
+    path26,
     "no additional properties",
     "unknown property",
-    `Unexpected property ${formatPath(path25)}`
+    `Unexpected property ${formatPath(path26)}`
   );
 }
-function addIssue(state, path25, expected, received, _message) {
+function addIssue(state, path26, expected, received, _message) {
   state.issues.push({
-    path: path25,
+    path: path26,
     expected,
     received,
-    message: formatIssueMessage(expected, path25, received)
+    message: formatIssueMessage(expected, path26, received)
   });
 }
-function addIssueWithMessage(state, path25, expected, received, message2) {
+function addIssueWithMessage(state, path26, expected, received, message2) {
   state.issues.push({
-    path: path25,
+    path: path26,
     expected,
     received,
     message: message2
   });
 }
-function formatIssueMessage(expected, path25, received) {
-  return `Expected ${expected} at ${formatPath(path25)}, got ${received}`;
+function formatIssueMessage(expected, path26, received) {
+  return `Expected ${expected} at ${formatPath(path26)}, got ${received}`;
 }
-function formatPath(path25) {
-  return path25.length === 0 ? "value" : path25.join(".");
+function formatPath(path26) {
+  return path26.length === 0 ? "value" : path26.join(".");
 }
 function compilePattern(pattern) {
   try {
@@ -7824,13 +7824,13 @@ function formatAvailableApprovalCommandPaths(root) {
 }
 function enumerateApprovalCommandPaths(root) {
   const paths = [];
-  const visit = (node, path25) => {
+  const visit = (node, path26) => {
     if (node.kind === "command") {
-      paths.push(path25.join("."));
+      paths.push(path26.join("."));
       return;
     }
     for (const child of getVisibleCliChildren(node)) {
-      visit(child, [...path25, child.name]);
+      visit(child, [...path26, child.name]);
     }
   };
   if (root.kind === "command") {
@@ -7867,21 +7867,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 (path26, encoding = "utf8") => readFile3(path26, { encoding }),
+    writeFile: async (path26, contents, options) => {
+      await writeFile2(path26, contents, options);
     },
-    exists: async (path25) => {
+    exists: async (path26) => {
       try {
-        await access(path25);
+        await access(path26);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path25) => lstat(path25),
+    lstat: async (path26) => lstat(path26),
     rename: async (fromPath, toPath) => rename(fromPath, toPath),
-    unlink: async (path25) => unlink(path25)
+    unlink: async (path26) => unlink(path26)
   };
 }
 function createEnv(values = process.env) {
@@ -11876,13 +11876,13 @@ function convertJsonSchema(schema) {
   }
   return convertSchema(schema, schema, []);
 }
-function convertSchema(schema, root, path25) {
-  const resolvedSchema = resolveReferencedSchema(schema, root, path25);
+function convertSchema(schema, root, path26) {
+  const resolvedSchema = resolveReferencedSchema(schema, root, path26);
   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(path26)}" has an unsupported type "${formatJsonSchemaType(
         normalizedSchema.schema.type
       )}". Supported: string, number, integer, boolean, array, object.`
     );
@@ -11894,13 +11894,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, path26);
   }
   if (isRecordSchema(normalizedSchema.schema)) {
     return applyMetadata(
       S.Record(
         convertSchema(normalizedSchema.schema.additionalProperties, root, [
-          ...path25,
+          ...path26,
           "additionalProperties"
         ])
       ),
@@ -11949,12 +11949,12 @@ function convertSchema(schema, root, path25) {
       if (normalizedSchema.schema.items === void 0) {
         throw new Error(
           `JSON Schema "${formatJsonSchemaPath(
-            path25
+            path26
           )}" 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, [...path26, "items"]),
         createCommonOptions(
           normalizedSchema.schema,
           normalizedSchema.nullable,
@@ -11964,7 +11964,7 @@ function convertSchema(schema, root, path25) {
     case "object":
       return convertObjectSchema(normalizedSchema.schema, root, {
         nullable: normalizedSchema.nullable,
-        path: path25
+        path: path26
       });
     case "null":
       return applyMetadata(S.Json(), normalizedSchema.schema, {
@@ -11979,12 +11979,12 @@ function convertSchema(schema, root, path25) {
       }
       throw new Error(
         `JSON Schema "${formatJsonSchemaPath(
-          path25
+          path26
         )}" 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(path26)}" has an unsupported type "${formatJsonSchemaType(
       normalizedSchema.schema.type
     )}". Supported: string, number, integer, boolean, array, object.`
   );
@@ -12028,21 +12028,21 @@ function convertEnumSchema(schema, nullable) {
     )
   });
 }
-function convertCompositionSchema(schema, root, nullable, path25) {
+function convertCompositionSchema(schema, root, nullable, path26) {
   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, [...path26, keyword, String(index)])
   );
-  const discriminator = findDiscriminator(branches, root, path25);
+  const discriminator = findDiscriminator(branches, root, path26);
   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: [...path26, keyword, String(index)]
         })
       ])
     );
@@ -12061,7 +12061,7 @@ function convertCompositionSchema(schema, root, nullable, path25) {
     S.Union(
       branches.map(
         (branch, index) => convertObjectSchema(branch, root, {
-          path: [...path25, keyword, String(index)]
+          path: [...path26, keyword, String(index)]
         })
       )
     ),
@@ -12175,11 +12175,11 @@ function getComposition(schema) {
   }
   return void 0;
 }
-function formatJsonSchemaPath(path25) {
-  if (path25.length === 0) {
+function formatJsonSchemaPath(path26) {
+  if (path26.length === 0) {
     return "#";
   }
-  return `#/${path25.map(escapeJsonPointerSegment).join("/")}`;
+  return `#/${path26.map(escapeJsonPointerSegment).join("/")}`;
 }
 function formatJsonSchemaType(type2) {
   return Array.isArray(type2) ? JSON.stringify(type2) : String(type2);
@@ -12195,11 +12195,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, path26) {
   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(path26)}" uses oneOf/anyOf/allOf but has no branches.`
     );
   }
   const candidateKeys = Object.keys(firstBranch.properties ?? {});
@@ -12239,19 +12239,19 @@ function getDiscriminatorLiteral(branch, key2, root) {
   }
   return void 0;
 }
-function resolveReferencedSchema(schema, root, path25) {
+function resolveReferencedSchema(schema, root, path26) {
   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(path26)}" 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, path26);
   if (Object.keys(siblingKeywords).length === 0) {
     return resolvedSchema;
   }
@@ -12275,9 +12275,9 @@ function mergeJsonSchemas(base, overlay) {
     ...mergedRequired === void 0 ? {} : { required: mergedRequired }
   };
 }
-function hasSelfReferencingRef(schema, root, path25 = "#", activePaths = /* @__PURE__ */ new Set()) {
+function hasSelfReferencingRef(schema, root, path26 = "#", activePaths = /* @__PURE__ */ new Set()) {
   const nextActivePaths = new Set(activePaths);
-  nextActivePaths.add(path25);
+  nextActivePaths.add(path26);
   const localRefPath = getLocalRefPath(schema.$ref);
   if (localRefPath !== void 0) {
     if (nextActivePaths.has(localRefPath)) {
@@ -12288,13 +12288,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, `${path26}/items`, nextActivePaths)) {
     return true;
   }
   if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && hasSelfReferencingRef(
     schema.additionalProperties,
     root,
-    `${path25}/additionalProperties`,
+    `${path26}/additionalProperties`,
     nextActivePaths
   )) {
     return true;
@@ -12303,7 +12303,7 @@ function hasSelfReferencingRef(schema, root, path25 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path25}/properties/${escapeJsonPointerSegment(key2)}`,
+      `${path26}/properties/${escapeJsonPointerSegment(key2)}`,
       nextActivePaths
     )) {
       return true;
@@ -12313,24 +12313,24 @@ function hasSelfReferencingRef(schema, root, path25 = "#", activePaths = /* @__P
     if (hasSelfReferencingRef(
       childSchema,
       root,
-      `${path25}/$defs/${escapeJsonPointerSegment(key2)}`,
+      `${path26}/$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, `${path26}/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, `${path26}/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, `${path26}/allOf/${index}`, nextActivePaths)) {
       return true;
     }
   }
@@ -12346,14 +12346,14 @@ function getLocalRefPath(ref) {
   return ref.startsWith("#/") ? ref : void 0;
 }
 function resolveLocalRef(root, ref) {
-  const path25 = getLocalRefPath(ref);
-  if (path25 === void 0) {
+  const path26 = getLocalRefPath(ref);
+  if (path26 === void 0) {
     return void 0;
   }
-  if (path25 === "#") {
+  if (path26 === "#") {
     return root;
   }
-  const segments = path25.slice(2).split("/").map(unescapeJsonPointerSegment);
+  const segments = path26.slice(2).split("/").map(unescapeJsonPointerSegment);
   let current = root;
   for (const segment of segments) {
     if (Array.isArray(current)) {
@@ -13494,23 +13494,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, path26) {
   if (typeof value === "string") {
-    return [{ path: formatPath2(path25), message: value }];
+    return [{ path: formatPath2(path26), 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(path26), message: message2 }));
     }
-    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path25, String(index)]));
+    return value.flatMap((entry, index) => flattenFieldErrors(entry, [...path26, 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, [...path26, key2]));
 }
-function formatPath2(path25) {
-  return path25.length === 0 ? "error" : path25.join(".");
+function formatPath2(path26) {
+  return path26.length === 0 ? "error" : path26.join(".");
 }
 function extractFirstString(body, fields) {
   if (!isPlainObject4(body)) {
@@ -14080,11 +14080,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(path26, casing) {
+  return `--${path26.map((segment) => formatSegment(segment, casing)).join(".")}`;
 }
-function toOptionAttribute(path25, casing) {
-  return path25.map((segment) => {
+function toOptionAttribute(path26, casing) {
+  return path26.map((segment) => {
     const formatted = formatSegment(segment, casing);
     if (casing === "snake") {
       return formatted;
@@ -14095,23 +14095,23 @@ function toOptionAttribute(path25, casing) {
     ).join("");
   }).join(".");
 }
-function toDisplayPath(path25) {
-  return path25.join(".");
+function toDisplayPath(path26) {
+  return path26.join(".");
 }
-function toUnionKindControlPath(path25) {
-  if (path25.length === 0) {
+function toUnionKindControlPath(path26) {
+  if (path26.length === 0) {
     return ["kind"];
   }
-  const head = path25.slice(0, -1);
-  const tail = path25[path25.length - 1] ?? "";
+  const head = path26.slice(0, -1);
+  const tail = path26[path26.length - 1] ?? "";
   return [...head, `${tail}Kind`];
 }
-function toUnionKindDisplayPath(path25) {
-  if (path25.length === 0) {
+function toUnionKindDisplayPath(path26) {
+  if (path26.length === 0) {
     return "kind";
   }
-  const head = path25.slice(0, -1);
-  const tail = path25[path25.length - 1] ?? "";
+  const head = path26.slice(0, -1);
+  const tail = path26[path26.length - 1] ?? "";
   return [...head, `${tail}-kind`].join(".");
 }
 function createSyntheticEnumSchema(values) {
@@ -14127,14 +14127,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, path26 = [], inheritedOptional = false, variantContext) {
   const collected = {
     dynamicFields: [],
     fields: [],
     variants: []
   };
   for (const [key2, rawChildSchema] of Object.entries(schema.shape)) {
-    const nextPath = [...path25, key2];
+    const nextPath = [...path26, key2];
     const runtimeOptional = inheritedOptional || rawChildSchema.kind === "optional";
     const childSchema = unwrapOptional2(rawChildSchema);
     const requiredWhenActive = rawChildSchema.kind !== "optional" && childSchema.default === void 0;
@@ -14320,9 +14320,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(path26, casing, globalLongOptionFlags) {
+  const optionAttribute = toOptionAttribute(path26, casing);
+  const optionFlag = toOptionFlag(path26, casing);
   if (!globalLongOptionFlags.has(optionFlag)) {
     return optionAttribute;
   }
@@ -15652,10 +15652,10 @@ function writeCLIDiagnosticEvent(event) {
   process.stderr.write(`${event.message}
 `);
 }
-function setNestedValue(target, path25, value) {
+function setNestedValue(target, path26, value) {
   let cursor2 = target;
-  for (let index = 0; index < path25.length - 1; index += 1) {
-    const segment = path25[index] ?? "";
+  for (let index = 0; index < path26.length - 1; index += 1) {
+    const segment = path26[index] ?? "";
     const existing = Object.prototype.hasOwnProperty.call(cursor2, segment) ? cursor2[segment] : void 0;
     if (typeof existing === "object" && existing !== null) {
       cursor2 = existing;
@@ -15670,7 +15670,7 @@ function setNestedValue(target, path25, value) {
     });
     cursor2 = next;
   }
-  const leaf = path25[path25.length - 1];
+  const leaf = path26[path26.length - 1];
   if (leaf !== void 0) {
     Object.defineProperty(cursor2, leaf, {
       value,
@@ -15818,21 +15818,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 (path26, encoding = "utf8") => readFile5(path26, { encoding }),
+    writeFile: async (path26, contents, options) => {
+      await writeFile5(path26, contents, options);
     },
-    exists: async (path25) => {
+    exists: async (path26) => {
       try {
-        await access2(path25);
+        await access2(path26);
         return true;
       } catch {
         return false;
       }
     },
-    lstat: async (path25) => lstat3(path25),
+    lstat: async (path26) => lstat3(path26),
     rename: async (fromPath, toPath) => rename3(fromPath, toPath),
-    unlink: async (path25) => unlink3(path25)
+    unlink: async (path26) => unlink3(path26)
   };
 }
 function createEnv2(values = process.env) {
@@ -15848,9 +15848,9 @@ function isPlainObject5(value) {
 function hasFieldValue(value) {
   return value !== void 0;
 }
-function hasNestedField(fields, path25) {
+function hasNestedField(fields, path26) {
   return fields.some(
-    (field) => path25.length < field.path.length && path25.every((segment, index) => field.path[index] === segment)
+    (field) => path26.length < field.path.length && path26.every((segment, index) => field.path[index] === segment)
   );
 }
 function describeExpectedPresetValue(schema) {
@@ -15979,9 +15979,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, path26) {
     for (const [key2, value] of Object.entries(current)) {
-      const nextPath = [...path25, key2];
+      const nextPath = [...path26, key2];
       const displayPath = toDisplayPath(nextPath);
       const field = fieldByPath.get(displayPath);
       if (field !== void 0) {
@@ -16374,8 +16374,8 @@ function validateServices(services) {
     }
   }
 }
-function getNestedValue(target, path25) {
-  return path25.reduce(
+function getNestedValue(target, path26) {
+  return path26.reduce(
     (current, segment) => current !== null && typeof current === "object" ? current[segment] : void 0,
     target
   );
@@ -19896,22 +19896,22 @@ function prune(obj, shape) {
   }
   return { changed, result };
 }
-function modifyAtPath(content, path25, value) {
+function modifyAtPath(content, path26, 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, path26, 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, path26) {
+  return modifyAtPath(content, path26, void 0);
 }
 function serializeUpdate(content, current, next) {
   let result = content || "{}";
@@ -19921,15 +19921,15 @@ function serializeUpdate(content, current, next) {
   }
   return result;
 }
-function applyObjectUpdate(content, path25, current, next) {
+function applyObjectUpdate(content, path26, current, next) {
   let result = content;
   for (const key2 of Object.keys(current)) {
     if (!hasConfigEntry(next, key2)) {
-      result = removeAtPath(result, [...path25, key2]);
+      result = removeAtPath(result, [...path26, key2]);
     }
   }
   for (const [key2, nextValue] of Object.entries(next)) {
-    const nextPath = [...path25, key2];
+    const nextPath = [...path26, key2];
     const hasCurrent = hasConfigEntry(current, key2);
     const currentValue = hasCurrent ? current[key2] : void 0;
     if (hasCurrent && isConfigObject(currentValue) && isConfigObject(nextValue)) {
@@ -20129,16 +20129,16 @@ function getConfigFormat(pathOrFormat) {
   }
   return formatRegistry[formatName];
 }
-function detectFormat(path25) {
-  const ext = getExtension(path25);
+function detectFormat(path26) {
+  const ext = getExtension(path26);
   return extensionMap[ext];
 }
-function getExtension(path25) {
-  const lastDot = path25.lastIndexOf(".");
+function getExtension(path26) {
+  const lastDot = path26.lastIndexOf(".");
   if (lastDot === -1) {
     return "";
   }
-  return path25.slice(lastDot).toLowerCase();
+  return path26.slice(lastDot).toLowerCase();
 }
 
 // ../config-mutations/src/execution/path-utils.ts
@@ -22756,6 +22756,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) {
@@ -22764,11 +23152,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,
@@ -22788,7 +23183,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;