@openspecui/core 6.2.1 → 7.0.1

package/dist/active-root-config-L5QaMb3A.mjs

@@ -0,0 +1,333 @@
+import { isMap, isNode, isScalar, isSeq, parseDocument } from "yaml";
+import { z } from "zod";
+
+//#region src/active-root-config-contract.ts
+/**
+* Orthogonal intents (updated 2026-08-02 Asia/Shanghai):
+* 1. Define OpenSpec 1.7 Active Root official-field and diagnostic contracts.
+* 2. Define exact owner/file/revision mutation admission and typed recovery results.
+*
+* Original request (2026-08-01): structured fields align with official OpenSpec while raw YAML accepts team extensions.
+* Derived checkpoint (2026-08-02): stale Active Root saves return the latest physical source instead of overwriting it.
+*/
+/** OpenSpec 1.7 hard limit for project context encoded as UTF-8. */
+const MAX_ACTIVE_ROOT_CONTEXT_BYTES = 50 * 1024;
+const NonEmptyStringSchema = z.string().min(1);
+const NonEmptyStringListSchema = z.array(NonEmptyStringSchema);
+const ActiveRootRulesSchema = z.record(NonEmptyStringSchema, NonEmptyStringListSchema);
+const ActiveRootOperationSchema = z.object({ guidance: NonEmptyStringListSchema }).strict();
+const ActiveRootOperationsSchema = z.object({
+	apply: ActiveRootOperationSchema.optional(),
+	archive: ActiveRootOperationSchema.optional()
+}).strict();
+function withinContextByteLimit(value) {
+	return new TextEncoder().encode(value).byteLength <= MAX_ACTIVE_ROOT_CONTEXT_BYTES;
+}
+const ActiveRootContextSchema = z.string().refine(withinContextByteLimit, `Context must not exceed ${MAX_ACTIVE_ROOT_CONTEXT_BYTES} UTF-8 bytes.`);
+/** Runtime schema for the resilient official-field projection. */
+const ActiveRootOfficialConfigSchema = z.object({
+	schema: NonEmptyStringSchema.nullable(),
+	context: ActiveRootContextSchema.nullable(),
+	rules: ActiveRootRulesSchema.nullable(),
+	operations: ActiveRootOperationsSchema.nullable()
+}).strict();
+/** Runtime schema for one complete Structured-mode update. */
+const ActiveRootStructuredUpdateSchema = z.object({
+	schema: NonEmptyStringSchema,
+	context: ActiveRootContextSchema.nullable(),
+	rules: ActiveRootRulesSchema.nullable(),
+	operations: z.object({
+		apply: ActiveRootOperationSchema.nullable(),
+		archive: ActiveRootOperationSchema.nullable()
+	}).strict().nullable()
+}).strict();
+/** Opaque digest proving the exact Active Root owner, file, presence, and source bytes read by an editor. */
+const ActiveRootRevisionSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const ActiveRootMutationLocatorShape = {
+	ownerPath: z.string().min(1),
+	filePath: z.string().min(1),
+	revision: ActiveRootRevisionSchema
+};
+/** Runtime schema for Structured or Raw mutation admission at one exact physical revision. */
+const ActiveRootMutationSchema = z.discriminatedUnion("mode", [z.object({
+	...ActiveRootMutationLocatorShape,
+	mode: z.literal("structured"),
+	update: ActiveRootStructuredUpdateSchema
+}).strict(), z.object({
+	...ActiveRootMutationLocatorShape,
+	mode: z.literal("raw"),
+	content: z.string()
+}).strict()]);
+
+//#endregion
+//#region src/active-root-config-yaml.ts
+/**
+* Orthogonal intents (updated 2026-08-02 Asia/Shanghai):
+* 1. Inspect OpenSpec 1.7 official fields resiliently while ignoring team-key ownership.
+* 2. Validate Raw YAML syntax without imposing the official key set.
+* 3. Patch only Structured-owned YAML nodes while retaining representable presentation and extensions.
+*
+* Original request (2026-08-01): preserve complete raw YAML because teams may define their own configuration keys.
+* Derived checkpoint (2026-08-02): Structured mode owns schema, context, rules, and apply/archive guidance only.
+*/
+const EMPTY_OFFICIAL_CONFIG = {
+	schema: null,
+	context: null,
+	rules: null,
+	operations: null
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function contextByteLength(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+function yamlErrors(content) {
+	const document = parseDocument(content);
+	if (document.errors.length === 0) return [];
+	return [{
+		code: "config-unparseable",
+		severity: "error",
+		path: "$",
+		message: document.errors.map((error) => error.message).join("\n")
+	}];
+}
+function inspectRules(value, diagnostics) {
+	if (value === void 0) return null;
+	if (!isRecord(value)) {
+		diagnostics.push({
+			code: "rules-invalid",
+			severity: "error",
+			path: "rules",
+			message: "The rules field must be a mapping of artifact ids to string arrays."
+		});
+		return null;
+	}
+	const rules = {};
+	for (const [artifactId, candidate] of Object.entries(value)) {
+		if (!Array.isArray(candidate) || candidate.some((entry) => typeof entry !== "string")) {
+			diagnostics.push({
+				code: "rules-entry-invalid",
+				severity: "error",
+				path: `rules.${artifactId}`,
+				message: `Rules for '${artifactId}' must be an array of strings.`
+			});
+			continue;
+		}
+		const entries = candidate.filter((entry) => entry.length > 0);
+		if (entries.length < candidate.length) diagnostics.push({
+			code: "rules-entry-empty",
+			severity: "warning",
+			path: `rules.${artifactId}`,
+			message: `Empty rules for '${artifactId}' are ignored by OpenSpec.`
+		});
+		if (entries.length > 0) rules[artifactId] = entries;
+	}
+	return Object.keys(rules).length > 0 ? rules : null;
+}
+function inspectOperations(value, diagnostics) {
+	if (value === void 0) return null;
+	if (!isRecord(value)) {
+		diagnostics.push({
+			code: "operations-invalid",
+			severity: "error",
+			path: "operations",
+			message: "The operations field must be a mapping."
+		});
+		return null;
+	}
+	const operations = {};
+	for (const operationId of ["apply", "archive"]) {
+		const candidate = value[operationId];
+		if (candidate === void 0) continue;
+		if (!isRecord(candidate)) {
+			diagnostics.push({
+				code: "operation-invalid",
+				severity: "error",
+				path: `operations.${operationId}`,
+				message: `Operation '${operationId}' must be a mapping.`
+			});
+			continue;
+		}
+		if (candidate.guidance === void 0) continue;
+		if (!Array.isArray(candidate.guidance) || candidate.guidance.some((entry) => typeof entry !== "string")) {
+			diagnostics.push({
+				code: "operation-guidance-invalid",
+				severity: "error",
+				path: `operations.${operationId}.guidance`,
+				message: `Guidance for '${operationId}' must be an array of strings.`
+			});
+			continue;
+		}
+		const guidance = candidate.guidance.filter((entry) => entry.length > 0);
+		if (guidance.length < candidate.guidance.length) diagnostics.push({
+			code: "operation-guidance-empty",
+			severity: "warning",
+			path: `operations.${operationId}.guidance`,
+			message: `Empty '${operationId}' guidance entries are ignored by OpenSpec.`
+		});
+		if (guidance.length > 0) operations[operationId] = { guidance };
+	}
+	return Object.keys(operations).length > 0 ? operations : null;
+}
+/** Inspect official OpenSpec 1.7 Active Root fields independently and retain recoverable diagnostics. */
+function inspectActiveRootOfficialConfig(content) {
+	if (content === null || content.trim().length === 0) return {
+		official: { ...EMPTY_OFFICIAL_CONFIG },
+		diagnostics: [{
+			code: "schema-missing",
+			severity: "error",
+			path: "schema",
+			message: "The active OpenSpec config does not declare a schema."
+		}]
+	};
+	const document = parseDocument(content);
+	if (document.errors.length > 0) return {
+		official: { ...EMPTY_OFFICIAL_CONFIG },
+		diagnostics: yamlErrors(content)
+	};
+	const raw = document.toJS();
+	if (!isRecord(raw)) return {
+		official: { ...EMPTY_OFFICIAL_CONFIG },
+		diagnostics: [{
+			code: "config-not-mapping",
+			severity: "error",
+			path: "$",
+			message: "OpenSpec config must be a YAML mapping for Structured mode."
+		}]
+	};
+	const diagnostics = [];
+	let schema = null;
+	if (raw.schema === void 0) diagnostics.push({
+		code: "schema-missing",
+		severity: "error",
+		path: "schema",
+		message: "The active OpenSpec config does not declare a schema."
+	});
+	else if (typeof raw.schema !== "string" || raw.schema.length === 0) diagnostics.push({
+		code: "schema-invalid",
+		severity: "error",
+		path: "schema",
+		message: "The schema field must be a non-empty string."
+	});
+	else schema = raw.schema;
+	let context = null;
+	if (raw.context !== void 0) if (typeof raw.context !== "string") diagnostics.push({
+		code: "context-invalid",
+		severity: "error",
+		path: "context",
+		message: "The context field must be a string."
+	});
+	else if (contextByteLength(raw.context) > MAX_ACTIVE_ROOT_CONTEXT_BYTES) diagnostics.push({
+		code: "context-too-large",
+		severity: "error",
+		path: "context",
+		message: `The context field exceeds ${MAX_ACTIVE_ROOT_CONTEXT_BYTES} UTF-8 bytes.`
+	});
+	else context = raw.context;
+	return {
+		official: {
+			schema,
+			context,
+			rules: inspectRules(raw.rules, diagnostics),
+			operations: inspectOperations(raw.operations, diagnostics)
+		},
+		diagnostics
+	};
+}
+/** Validate Raw-mode YAML syntax while allowing any syntactically valid document shape and custom keys. */
+function validateActiveRootRawYaml(content) {
+	const diagnostics = yamlErrors(content);
+	return {
+		valid: diagnostics.length === 0,
+		diagnostics
+	};
+}
+function editableDocument(content) {
+	const document = parseDocument(content ?? "");
+	if (document.errors.length > 0) throw new Error(`Active Root cannot be edited in Structured mode: ${document.errors.map((error) => error.message).join("\n")}`);
+	if (document.contents !== null && !isMap(document.contents)) throw new Error("Active Root cannot be edited in Structured mode: config is not a YAML mapping.");
+	return document;
+}
+function copyPresentation(source, target) {
+	if (!isNode(source) || !isNode(target)) return;
+	target.comment = source.comment;
+	target.commentBefore = source.commentBefore;
+	target.spaceBefore = source.spaceBefore;
+	if (isScalar(source) && isScalar(target) && typeof target.value === "string") target.type = source.type;
+	if (isMap(source) && isMap(target) || isSeq(source) && isSeq(target)) target.flow = source.flow;
+	if (isSeq(source) && isSeq(target)) for (let index = 0; index < Math.min(source.items.length, target.items.length); index += 1) copyPresentation(source.items[index], target.items[index]);
+}
+function replaceNode(document, path, value) {
+	const previous = document.getIn(path, true);
+	const replacement = document.createNode(value);
+	copyPresentation(previous, replacement);
+	document.setIn(path, replacement);
+}
+function ensureMap(document, path) {
+	const current = document.getIn(path, true);
+	if (isMap(current)) return current;
+	replaceNode(document, path, {});
+	const replacement = document.getIn(path, true);
+	if (!isMap(replacement)) throw new Error(`Unable to create YAML mapping at ${path.join(".")}.`);
+	return replacement;
+}
+function mappingStringKeys(mapping) {
+	const keys = [];
+	for (const pair of mapping.items) if (isScalar(pair.key) && typeof pair.key.value === "string") keys.push(pair.key.value);
+	return keys;
+}
+function patchRules(document, rules) {
+	if (rules === null) {
+		document.delete("rules");
+		return;
+	}
+	const mapping = ensureMap(document, ["rules"]);
+	for (const artifactId of mappingStringKeys(mapping)) if (!Object.hasOwn(rules, artifactId)) mapping.delete(artifactId);
+	for (const [artifactId, entries] of Object.entries(rules)) replaceNode(document, ["rules", artifactId], entries);
+}
+function removeOperationGuidance(document, operationId) {
+	const operations = document.getIn(["operations"], true);
+	if (!isMap(operations)) return;
+	const operation = document.getIn(["operations", operationId], true);
+	if (isMap(operation)) {
+		operation.delete("guidance");
+		if (operation.items.length === 0) operations.delete(operationId);
+	} else if (operation !== void 0) operations.delete(operationId);
+	if (operations.items.length === 0) document.delete("operations");
+}
+function patchOperations(document, operations) {
+	if (operations === null) {
+		removeOperationGuidance(document, "apply");
+		removeOperationGuidance(document, "archive");
+		return;
+	}
+	ensureMap(document, ["operations"]);
+	for (const operationId of ["apply", "archive"]) {
+		const operation = operations[operationId];
+		if (operation === null) {
+			removeOperationGuidance(document, operationId);
+			continue;
+		}
+		ensureMap(document, ["operations", operationId]);
+		replaceNode(document, [
+			"operations",
+			operationId,
+			"guidance"
+		], operation.guidance);
+	}
+}
+/** Patch only Structured-owned official nodes and retain all representable unowned YAML evidence. */
+function patchActiveRootOfficialFields(content, update) {
+	const validated = ActiveRootStructuredUpdateSchema.parse(update);
+	const document = editableDocument(content);
+	replaceNode(document, ["schema"], validated.schema);
+	if (validated.context === null) document.delete("context");
+	else replaceNode(document, ["context"], validated.context);
+	patchRules(document, validated.rules);
+	patchOperations(document, validated.operations);
+	return document.toString({ lineWidth: 0 });
+}
+
+//#endregion
+export { ActiveRootOfficialConfigSchema as a, MAX_ACTIVE_ROOT_CONTEXT_BYTES as c, ActiveRootMutationSchema as i, patchActiveRootOfficialFields as n, ActiveRootRevisionSchema as o, validateActiveRootRawYaml as r, ActiveRootStructuredUpdateSchema as s, inspectActiveRootOfficialConfig as t };

package/dist/active-root-config.d.mts

@@ -0,0 +1,6 @@
+import "./document-translation-BNbM3fEj.mjs";
+import "./sounds-vwRCMSzL.mjs";
+import "./notifications-B43aFxw9.mjs";
+import "./index-CkwSp1WZ.mjs";
+import { _ as ActiveRootStructuredUpdateSchema, a as ActiveRootConfigDiagnostic, c as ActiveRootMutation, d as ActiveRootOfficialConfig, f as ActiveRootOfficialConfigSchema, g as ActiveRootStructuredUpdate, h as ActiveRootRevisionSchema, i as ActiveRootConfig, l as ActiveRootMutationResult, m as ActiveRootRevision, n as patchActiveRootOfficialFields, o as ActiveRootConfigFile, p as ActiveRootRawValidation, r as validateActiveRootRawYaml, s as ActiveRootConfigInspection, t as inspectActiveRootOfficialConfig, u as ActiveRootMutationSchema, v as MAX_ACTIVE_ROOT_CONTEXT_BYTES } from "./active-root-config-DxRGkvOp.mjs";
+export { ActiveRootConfig, ActiveRootConfigDiagnostic, ActiveRootConfigFile, ActiveRootConfigInspection, ActiveRootMutation, ActiveRootMutationResult, ActiveRootMutationSchema, ActiveRootOfficialConfig, ActiveRootOfficialConfigSchema, ActiveRootRawValidation, ActiveRootRevision, ActiveRootRevisionSchema, ActiveRootStructuredUpdate, ActiveRootStructuredUpdateSchema, MAX_ACTIVE_ROOT_CONTEXT_BYTES, inspectActiveRootOfficialConfig, patchActiveRootOfficialFields, validateActiveRootRawYaml };

package/dist/active-root-config.mjs

@@ -0,0 +1,3 @@
+import { a as ActiveRootOfficialConfigSchema, c as MAX_ACTIVE_ROOT_CONTEXT_BYTES, i as ActiveRootMutationSchema, n as patchActiveRootOfficialFields, o as ActiveRootRevisionSchema, r as validateActiveRootRawYaml, s as ActiveRootStructuredUpdateSchema, t as inspectActiveRootOfficialConfig } from "./active-root-config-L5QaMb3A.mjs";
+
+export { ActiveRootMutationSchema, ActiveRootOfficialConfigSchema, ActiveRootRevisionSchema, ActiveRootStructuredUpdateSchema, MAX_ACTIVE_ROOT_CONTEXT_BYTES, inspectActiveRootOfficialConfig, patchActiveRootOfficialFields, validateActiveRootRawYaml };

package/dist/app-daemon-control.d.mts

@@ -27,32 +27,32 @@ declare const AppDaemonWorkspaceBindingSchema: z.ZodObject<{
   }>>;
 }, "strip", z.ZodTypeAny, {
   id: string;
-  git: {
-    remoteUrl: string | null;
-    branch: string | null;
-    githubSlug: string | null;
-  } | null;
-  credential: string | null;
   backendUrl: string;
+  credential: string | null;
   projectDir: string;
   ownership: "daemon-managed" | "external";
   registeredAt: number;
   managedGeneration: number | null;
   shutdown: "managed" | "external-owner" | "close-only";
-}, {
-  id: string;
   git: {
     remoteUrl: string | null;
     branch: string | null;
     githubSlug: string | null;
   } | null;
-  credential: string | null;
+}, {
+  id: string;
   backendUrl: string;
+  credential: string | null;
   projectDir: string;
   ownership: "daemon-managed" | "external";
   registeredAt: number;
   managedGeneration: number | null;
   shutdown: "managed" | "external-owner" | "close-only";
+  git: {
+    remoteUrl: string | null;
+    branch: string | null;
+    githubSlug: string | null;
+  } | null;
 }>;
 type AppDaemonWorkspaceBinding = z.infer<typeof AppDaemonWorkspaceBindingSchema>;
 /** Complete current daemon ledger; clients replace by revision instead of applying event deltas. */
@@ -82,66 +82,66 @@ declare const AppDaemonWorkspaceSnapshotSchema: z.ZodObject<{
     }>>;
   }, "strip", z.ZodTypeAny, {
     id: string;
-    git: {
-      remoteUrl: string | null;
-      branch: string | null;
-      githubSlug: string | null;
-    } | null;
-    credential: string | null;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
-  }, {
-    id: string;
     git: {
       remoteUrl: string | null;
       branch: string | null;
       githubSlug: string | null;
     } | null;
-    credential: string | null;
+  }, {
+    id: string;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
-  }>, "many">;
-}, "strip", z.ZodTypeAny, {
-  revision: number;
-  workspaces: {
-    id: string;
     git: {
       remoteUrl: string | null;
       branch: string | null;
       githubSlug: string | null;
     } | null;
-    credential: string | null;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  revision: number;
+  workspaces: {
+    id: string;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
-  }[];
-}, {
-  revision: number;
-  workspaces: {
-    id: string;
     git: {
       remoteUrl: string | null;
       branch: string | null;
       githubSlug: string | null;
     } | null;
-    credential: string | null;
+  }[];
+}, {
+  revision: number;
+  workspaces: {
+    id: string;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
+    git: {
+      remoteUrl: string | null;
+      branch: string | null;
+      githubSlug: string | null;
+    } | null;
   }[];
 }>;
 type AppDaemonWorkspaceSnapshot = z.infer<typeof AppDaemonWorkspaceSnapshotSchema>;
@@ -232,68 +232,68 @@ declare const AppDaemonStartManagedProjectResponseSchema: z.ZodDiscriminatedUnio
     }>>;
   }, "strip", z.ZodTypeAny, {
     id: string;
-    git: {
-      remoteUrl: string | null;
-      branch: string | null;
-      githubSlug: string | null;
-    } | null;
-    credential: string | null;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
-  }, {
-    id: string;
     git: {
       remoteUrl: string | null;
       branch: string | null;
       githubSlug: string | null;
     } | null;
-    credential: string | null;
+  }, {
+    id: string;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
+    git: {
+      remoteUrl: string | null;
+      branch: string | null;
+      githubSlug: string | null;
+    } | null;
   }>;
   alreadyRunning: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
   ok: true;
   workspace: {
     id: string;
-    git: {
-      remoteUrl: string | null;
-      branch: string | null;
-      githubSlug: string | null;
-    } | null;
-    credential: string | null;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
+    git: {
+      remoteUrl: string | null;
+      branch: string | null;
+      githubSlug: string | null;
+    } | null;
   };
   alreadyRunning: boolean;
 }, {
   ok: true;
   workspace: {
     id: string;
-    git: {
-      remoteUrl: string | null;
-      branch: string | null;
-      githubSlug: string | null;
-    } | null;
-    credential: string | null;
     backendUrl: string;
+    credential: string | null;
     projectDir: string;
     ownership: "daemon-managed" | "external";
     registeredAt: number;
     managedGeneration: number | null;
     shutdown: "managed" | "external-owner" | "close-only";
+    git: {
+      remoteUrl: string | null;
+      branch: string | null;
+      githubSlug: string | null;
+    } | null;
   };
   alreadyRunning: boolean;
 }>, z.ZodObject<{
@@ -302,21 +302,21 @@ declare const AppDaemonStartManagedProjectResponseSchema: z.ZodDiscriminatedUnio
     code: z.ZodEnum<["UNSUPPORTED", "INVALID_DIRECTORY", "SPAWN_FAILED", "GENERATION_MISMATCH", "INVALID_REQUEST"]>;
     message: z.ZodString;
   }, "strip", z.ZodTypeAny, {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   }, {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   }>;
 }, "strip", z.ZodTypeAny, {
   error: {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   };
   ok: false;
 }, {
   error: {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   };
   ok: false;
@@ -338,21 +338,21 @@ declare const AppDaemonStopManagedProjectResponseSchema: z.ZodDiscriminatedUnion
     code: z.ZodEnum<["UNSUPPORTED", "INVALID_DIRECTORY", "SPAWN_FAILED", "GENERATION_MISMATCH", "INVALID_REQUEST"]>;
     message: z.ZodString;
   }, "strip", z.ZodTypeAny, {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   }, {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   }>;
 }, "strip", z.ZodTypeAny, {
   error: {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   };
   ok: false;
 }, {
   error: {
-    code: "INVALID_REQUEST" | "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH";
+    code: "UNSUPPORTED" | "INVALID_DIRECTORY" | "SPAWN_FAILED" | "GENERATION_MISMATCH" | "INVALID_REQUEST";
     message: string;
   };
   ok: false;