@openspecui/core 4.1.0 → 6.0.0-beta.0

package/dist/opsx-workflows-BvnJqjfL.d.mts

@@ -0,0 +1,36 @@
+//#region src/opsx-workflows.d.ts
+/**
+ * Orthogonal intents (created 2026-07-16 Asia/Shanghai):
+ * 1. Define the complete OPSX workflow vocabulary once for Core, Server, CLI, and Web.
+ * 2. Define profile and input-shape groups without coupling them to one transport.
+ * 3. Define shared labels, command capability, and official skill-directory mappings.
+ *
+ * Original request (2026-07-15): "sync、update 的完整交付链。"
+ */
+declare const OPSX_ALL_WORKFLOWS: readonly ["propose", "explore", "new", "continue", "apply", "update", "ff", "sync", "archive", "bulk-archive", "verify", "onboard"];
+/** Complete supported OPSX workflow identifier union. */
+type OpsxWorkflowId = (typeof OPSX_ALL_WORKFLOWS)[number];
+/** Workflows delivered by the OpenSpec core profile. */
+declare const OPSX_CORE_PROFILE_WORKFLOWS: readonly ["propose", "explore", "apply", "update", "sync", "archive"];
+/** OPSX actions whose primary input is free text. */
+declare const OPSX_TEXT_INPUT_ACTIONS: readonly ["explore", "propose"];
+/** OPSX actions whose primary input is an artifact identity. */
+declare const OPSX_ARTIFACT_INPUT_ACTIONS: readonly ["continue", "ff"];
+/** OPSX actions whose primary input is an existing Change identity. */
+declare const OPSX_CHANGE_INPUT_ACTIONS: readonly ["apply", "update", "archive", "verify", "sync"];
+/** Workflows that can be delivered as explicit agent commands. */
+declare const OPSX_COMMAND_CAPABLE_WORKFLOWS: readonly ["propose", "apply", "update", "sync", "archive"];
+/** Text-input OPSX action union. */
+type OpsxTextInputAction = (typeof OPSX_TEXT_INPUT_ACTIONS)[number];
+/** Artifact-input OPSX action union. */
+type OpsxArtifactInputAction = (typeof OPSX_ARTIFACT_INPUT_ACTIONS)[number];
+/** Change-input OPSX action union. */
+type OpsxChangeInputAction = (typeof OPSX_CHANGE_INPUT_ACTIONS)[number];
+/** User-facing labels for every supported OPSX workflow. */
+declare const OPSX_WORKFLOW_LABELS: Record<OpsxWorkflowId, string>;
+/** First-party skill directory selected for each OPSX workflow. */
+declare const OPSX_WORKFLOW_TO_SKILL_DIR: Record<OpsxWorkflowId, string>;
+/** Return whether a workflow selection exactly represents the core profile. */
+declare function isOpsxCoreWorkflowSelection(workflows: readonly string[]): boolean;
+//#endregion
+export { OPSX_CORE_PROFILE_WORKFLOWS as a, OPSX_WORKFLOW_TO_SKILL_DIR as c, OpsxTextInputAction as d, OpsxWorkflowId as f, OPSX_COMMAND_CAPABLE_WORKFLOWS as i, OpsxArtifactInputAction as l, OPSX_ARTIFACT_INPUT_ACTIONS as n, OPSX_TEXT_INPUT_ACTIONS as o, isOpsxCoreWorkflowSelection as p, OPSX_CHANGE_INPUT_ACTIONS as r, OPSX_WORKFLOW_LABELS as s, OPSX_ALL_WORKFLOWS as t, OpsxChangeInputAction as u };

package/dist/opsx-workflows-Ccc6U7IR.mjs

@@ -0,0 +1,89 @@
+//#region src/opsx-workflows.ts
+/**
+* Orthogonal intents (created 2026-07-16 Asia/Shanghai):
+* 1. Define the complete OPSX workflow vocabulary once for Core, Server, CLI, and Web.
+* 2. Define profile and input-shape groups without coupling them to one transport.
+* 3. Define shared labels, command capability, and official skill-directory mappings.
+*
+* Original request (2026-07-15): "sync、update 的完整交付链。"
+*/
+const OPSX_ALL_WORKFLOWS = [
+	"propose",
+	"explore",
+	"new",
+	"continue",
+	"apply",
+	"update",
+	"ff",
+	"sync",
+	"archive",
+	"bulk-archive",
+	"verify",
+	"onboard"
+];
+/** Workflows delivered by the OpenSpec core profile. */
+const OPSX_CORE_PROFILE_WORKFLOWS = [
+	"propose",
+	"explore",
+	"apply",
+	"update",
+	"sync",
+	"archive"
+];
+/** OPSX actions whose primary input is free text. */
+const OPSX_TEXT_INPUT_ACTIONS = ["explore", "propose"];
+/** OPSX actions whose primary input is an artifact identity. */
+const OPSX_ARTIFACT_INPUT_ACTIONS = ["continue", "ff"];
+/** OPSX actions whose primary input is an existing Change identity. */
+const OPSX_CHANGE_INPUT_ACTIONS = [
+	"apply",
+	"update",
+	"archive",
+	"verify",
+	"sync"
+];
+/** Workflows that can be delivered as explicit agent commands. */
+const OPSX_COMMAND_CAPABLE_WORKFLOWS = [
+	"propose",
+	"apply",
+	"update",
+	"sync",
+	"archive"
+];
+/** User-facing labels for every supported OPSX workflow. */
+const OPSX_WORKFLOW_LABELS = {
+	propose: "Propose change",
+	explore: "Explore ideas",
+	new: "New change",
+	continue: "Continue change",
+	apply: "Apply tasks",
+	update: "Update change",
+	ff: "Fast-forward",
+	sync: "Sync specs",
+	archive: "Archive change",
+	"bulk-archive": "Bulk archive",
+	verify: "Verify change",
+	onboard: "Onboard"
+};
+/** First-party skill directory selected for each OPSX workflow. */
+const OPSX_WORKFLOW_TO_SKILL_DIR = {
+	propose: "openspec-propose",
+	explore: "openspec-explore",
+	new: "openspec-new-change",
+	continue: "openspec-continue-change",
+	apply: "openspec-apply-change",
+	update: "openspec-update-change",
+	ff: "openspec-ff-change",
+	sync: "openspec-sync-specs",
+	archive: "openspec-archive-change",
+	"bulk-archive": "openspec-bulk-archive-change",
+	verify: "openspec-verify-change",
+	onboard: "openspec-onboard"
+};
+/** Return whether a workflow selection exactly represents the core profile. */
+function isOpsxCoreWorkflowSelection(workflows) {
+	return workflows.length === OPSX_CORE_PROFILE_WORKFLOWS.length && OPSX_CORE_PROFILE_WORKFLOWS.every((workflow) => workflows.includes(workflow));
+}
+
+//#endregion
+export { OPSX_CORE_PROFILE_WORKFLOWS as a, OPSX_WORKFLOW_TO_SKILL_DIR as c, OPSX_COMMAND_CAPABLE_WORKFLOWS as i, isOpsxCoreWorkflowSelection as l, OPSX_ARTIFACT_INPUT_ACTIONS as n, OPSX_TEXT_INPUT_ACTIONS as o, OPSX_CHANGE_INPUT_ACTIONS as r, OPSX_WORKFLOW_LABELS as s, OPSX_ALL_WORKFLOWS as t };

package/dist/opsx-workflows.d.mts

@@ -0,0 +1,2 @@
+import { a as OPSX_CORE_PROFILE_WORKFLOWS, c as OPSX_WORKFLOW_TO_SKILL_DIR, d as OpsxTextInputAction, f as OpsxWorkflowId, i as OPSX_COMMAND_CAPABLE_WORKFLOWS, l as OpsxArtifactInputAction, n as OPSX_ARTIFACT_INPUT_ACTIONS, o as OPSX_TEXT_INPUT_ACTIONS, p as isOpsxCoreWorkflowSelection, r as OPSX_CHANGE_INPUT_ACTIONS, s as OPSX_WORKFLOW_LABELS, t as OPSX_ALL_WORKFLOWS, u as OpsxChangeInputAction } from "./opsx-workflows-BvnJqjfL.mjs";
+export { OPSX_ALL_WORKFLOWS, OPSX_ARTIFACT_INPUT_ACTIONS, OPSX_CHANGE_INPUT_ACTIONS, OPSX_COMMAND_CAPABLE_WORKFLOWS, OPSX_CORE_PROFILE_WORKFLOWS, OPSX_TEXT_INPUT_ACTIONS, OPSX_WORKFLOW_LABELS, OPSX_WORKFLOW_TO_SKILL_DIR, OpsxArtifactInputAction, OpsxChangeInputAction, OpsxTextInputAction, OpsxWorkflowId, isOpsxCoreWorkflowSelection };

package/dist/opsx-workflows.mjs

@@ -0,0 +1,3 @@
+import { a as OPSX_CORE_PROFILE_WORKFLOWS, c as OPSX_WORKFLOW_TO_SKILL_DIR, i as OPSX_COMMAND_CAPABLE_WORKFLOWS, l as isOpsxCoreWorkflowSelection, n as OPSX_ARTIFACT_INPUT_ACTIONS, o as OPSX_TEXT_INPUT_ACTIONS, r as OPSX_CHANGE_INPUT_ACTIONS, s as OPSX_WORKFLOW_LABELS, t as OPSX_ALL_WORKFLOWS } from "./opsx-workflows-Ccc6U7IR.mjs";
+
+export { OPSX_ALL_WORKFLOWS, OPSX_ARTIFACT_INPUT_ACTIONS, OPSX_CHANGE_INPUT_ACTIONS, OPSX_COMMAND_CAPABLE_WORKFLOWS, OPSX_CORE_PROFILE_WORKFLOWS, OPSX_TEXT_INPUT_ACTIONS, OPSX_WORKFLOW_LABELS, OPSX_WORKFLOW_TO_SKILL_DIR, isOpsxCoreWorkflowSelection };

package/dist/planning-cli-projection-DIRxeq2H.mjs

@@ -0,0 +1,421 @@
+import { t as createApplyInstructionProgress } from "./task-progress-B_IWVXjA.mjs";
+import { a as CliRootSchema, i as CliReferenceIndexEntrySchema, n as CliDiagnosticSchema } from "./common-D8YUK9dA.mjs";
+import { D as CliSchemaInfoSchema, E as CliPlanningHomeSchema, O as CliSchemaResolutionSchema, P as CliTemplateEntrySchema, a as SpecDocumentProjectionSchema, k as CliSchemaShadowSchema, o as SpecIdentitySchema, r as SpecCatalogSchema, v as CliActionContextSchema, w as CliArtifactPathSchema } from "./spec-catalog-ZGuiZ4CE.mjs";
+import { r as CliProjectionCommandEvidenceSchema, u as createCliProjectionStateSchema } from "./cli-projection-vO3-FJg5.mjs";
+import { z } from "zod";
+
+//#region src/opsx-types.ts
+/**
+* Orthogonal intents (updated 2026-07-27 Asia/Shanghai):
+* 1. Define reactive Change Status and Instructions projections.
+* 2. Preserve live CLI path/action/Reference provenance versus explicit static absence.
+* 3. Attribute Apply instruction progress without replacing tracked-task truth.
+* 4. Define schema, template, and dependency projections for OPSX surfaces.
+* 5. Publish runtime schemas for final Projection Work payloads, including transformed Apply progress.
+*
+* Original request (2026-07-15): "Preserve CLI-provided paths, action context, References, and diagnostics end to end."
+* Original request (2026-07-23): "OPSX Status 不应等待完整 Kernel warmup，且必须保留 CLI evidence。"
+* Original request (2026-07-26): "展开全面的接口升级和内核升级和测试升级。"
+*/
+/** Check if an outputPath contains glob pattern characters */
+function isGlobPattern(pattern) {
+	return pattern.includes("*") || pattern.includes("?") || pattern.includes("[");
+}
+/** Runtime schema for one JSON value retained from a CLI Status stdout document. */
+const OpsxCliJsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(OpsxCliJsonValueSchema),
+	z.record(z.string(), OpsxCliJsonValueSchema)
+]));
+/** Raw process and parser evidence retained beside one live CLI projection. */
+const OpsxCliEvidenceSchema = z.object({
+	command: z.enum([
+		"status",
+		"instructions",
+		"instructions apply"
+	]),
+	success: z.boolean(),
+	stdout: z.string(),
+	stderr: z.string(),
+	exitCode: z.number().int().nullable(),
+	payload: OpsxCliJsonValueSchema.nullable(),
+	diagnostics: z.array(CliDiagnosticSchema),
+	contractError: z.string().optional(),
+	selector: z.object({ store: z.string().optional() }).strict(),
+	root: CliRootSchema.optional()
+}).passthrough();
+/** Status-specific evidence kept as a narrow public contract for consumers. */
+const OpsxStatusEvidenceSchema = OpsxCliEvidenceSchema.extend({ command: z.literal("status") });
+const OpsxArtifactInstructionsEvidenceSchema = OpsxCliEvidenceSchema.extend({ command: z.literal("instructions") });
+const OpsxApplyInstructionsEvidenceSchema = OpsxCliEvidenceSchema.extend({ command: z.literal("instructions apply") });
+const ArtifactStatusSchema = z.object({
+	id: z.string(),
+	outputPath: z.string(),
+	status: z.enum([
+		"done",
+		"ready",
+		"blocked"
+	]),
+	missingDeps: z.array(z.string()).optional(),
+	relativePath: z.string().optional()
+});
+const ChangeStatusSchema = z.object({
+	changeName: z.string(),
+	schemaName: z.string(),
+	isComplete: z.boolean(),
+	applyRequires: z.array(z.string()),
+	artifacts: z.array(ArtifactStatusSchema),
+	provenance: z.discriminatedUnion("kind", [z.object({
+		kind: z.literal("cli"),
+		planningHome: CliPlanningHomeSchema,
+		changeRoot: z.string(),
+		artifactPaths: z.record(CliArtifactPathSchema),
+		nextSteps: z.array(z.string()),
+		actionContext: CliActionContextSchema,
+		root: CliRootSchema,
+		evidence: OpsxStatusEvidenceSchema
+	}), z.object({ kind: z.literal("static") })])
+});
+const DependencyInfoSchema = z.object({
+	id: z.string(),
+	done: z.boolean(),
+	path: z.string(),
+	description: z.string()
+});
+const ApplyTaskSchema = z.object({
+	id: z.string(),
+	description: z.string(),
+	done: z.boolean()
+});
+const ApplyInstructionsContextFilePathsSchema = z.union([z.string(), z.array(z.string())]).transform((paths) => Array.isArray(paths) ? paths : [paths]);
+const ApplyInstructionsContextFilesSchema = z.record(ApplyInstructionsContextFilePathsSchema);
+const ApplyInstructionsInputSchema = z.object({
+	changeName: z.string(),
+	changeDir: z.string(),
+	schemaName: z.string(),
+	contextFiles: ApplyInstructionsContextFilesSchema,
+	progress: z.object({
+		total: z.number(),
+		complete: z.number(),
+		remaining: z.number()
+	}),
+	tasks: z.array(ApplyTaskSchema),
+	state: z.enum([
+		"blocked",
+		"all_done",
+		"ready"
+	]),
+	missingArtifacts: z.array(z.string()).optional(),
+	instruction: z.string(),
+	references: z.array(CliReferenceIndexEntrySchema).optional(),
+	evidence: OpsxApplyInstructionsEvidenceSchema
+});
+const ApplyInstructionProgressSchema = z.object({
+	source: z.literal("openspec-instructions-apply"),
+	total: z.number(),
+	complete: z.number(),
+	remaining: z.number(),
+	state: z.enum([
+		"blocked",
+		"all_done",
+		"ready"
+	]),
+	divergence: z.object({
+		kind: z.literal("tracked-task-mismatch"),
+		message: z.string(),
+		apply: z.object({
+			total: z.number(),
+			complete: z.number(),
+			remaining: z.number()
+		}),
+		tracked: z.object({
+			total: z.number(),
+			completed: z.number(),
+			remaining: z.number(),
+			phase: z.enum([
+				"no-tasks",
+				"in-progress",
+				"complete"
+			])
+		})
+	}).nullable()
+});
+/** Runtime schema for the final transformed Apply projection returned to clients. */
+const ApplyInstructionsProjectionSchema = z.object({
+	changeName: z.string(),
+	changeDir: z.string(),
+	schemaName: z.string(),
+	contextFiles: ApplyInstructionsContextFilesSchema,
+	tasks: z.array(ApplyTaskSchema),
+	state: z.enum([
+		"blocked",
+		"all_done",
+		"ready"
+	]),
+	missingArtifacts: z.array(z.string()).optional(),
+	instruction: z.string(),
+	references: z.array(CliReferenceIndexEntrySchema).optional(),
+	evidence: OpsxApplyInstructionsEvidenceSchema,
+	applyInstructionProgress: ApplyInstructionProgressSchema
+});
+const ApplyInstructionsSchema = ApplyInstructionsInputSchema.transform(({ progress, ...instructions }) => ({
+	...instructions,
+	applyInstructionProgress: createApplyInstructionProgress({
+		...progress,
+		state: instructions.state
+	})
+})).pipe(ApplyInstructionsProjectionSchema);
+const NullableString = z.string().nullable().optional();
+const ArtifactInstructionsSchema = z.object({
+	changeName: z.string(),
+	artifactId: z.string(),
+	schemaName: z.string(),
+	changeDir: z.string(),
+	outputPath: z.string(),
+	description: z.string(),
+	instruction: NullableString,
+	context: NullableString,
+	rules: z.array(z.string()).optional().nullable(),
+	template: z.string(),
+	dependencies: z.array(DependencyInfoSchema),
+	unlocks: z.array(z.string()),
+	references: z.array(CliReferenceIndexEntrySchema).optional(),
+	evidence: OpsxArtifactInstructionsEvidenceSchema
+});
+/** CLI-owned Schema list item projected by OPSX. */
+const SchemaInfoSchema = CliSchemaInfoSchema;
+/** CLI-owned schema resolution enriched only with display-safe paths. */
+const SchemaResolutionSchema = CliSchemaResolutionSchema.extend({
+	displayPath: z.string().optional(),
+	shadows: z.array(CliSchemaShadowSchema.extend({ displayPath: z.string().optional() }))
+});
+/** CLI-owned template index enriched only with display-safe paths. */
+const TemplatesSchema = z.record(CliTemplateEntrySchema.extend({ displayPath: z.string().optional() }));
+const SchemaArtifactSchema = z.object({
+	id: z.string(),
+	outputPath: z.string(),
+	description: z.string().optional(),
+	template: z.string().optional(),
+	instruction: z.string().optional(),
+	requires: z.array(z.string())
+});
+const SchemaDetailSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	version: z.union([z.string(), z.number()]).optional(),
+	artifacts: z.array(SchemaArtifactSchema),
+	applyRequires: z.array(z.string()),
+	applyTracks: z.string().optional(),
+	applyInstruction: z.string().optional()
+});
+/** Runtime schema for the aggregate Schema workspace projection. */
+const OpsxConfigBundleSchema = z.object({
+	schemas: z.array(SchemaInfoSchema),
+	schemaDetails: z.record(z.string(), SchemaDetailSchema.nullable()),
+	schemaResolutions: z.record(z.string(), SchemaResolutionSchema.nullable())
+});
+/** Runtime schema for one resolved template body and its physical provenance. */
+const TemplateContentSchema = z.object({
+	content: z.string().nullable(),
+	path: z.string(),
+	displayPath: z.string().optional(),
+	source: z.enum([
+		"project",
+		"user",
+		"package"
+	])
+});
+/** Runtime schema for template bodies keyed by artifact id. */
+const TemplateContentMapSchema = z.record(z.string(), TemplateContentSchema);
+
+//#endregion
+//#region src/planning-cli-projection.ts
+/**
+* Orthogonal intents (updated 2026-07-27 Asia/Shanghai):
+* 1. Define selector-exact Planning-root CLI Projection Work contracts.
+* 2. Define the runtime-environment Environment Global projection contract.
+* 3. Publish browser-safe lifecycle Pull schemas without importing Node-owned Core modules.
+* 4. Keep projection data discriminated so one typed registry never mixes selector payloads.
+*
+* Original request (2026-07-26): "展开全面的接口升级和内核升级和测试升级。"
+*/
+/** Runtime selector for one Planning-root CLI-backed projection. */
+const PlanningCliProjectionSelectorSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("opsx-status"),
+		change: z.string().min(1),
+		schema: z.string().optional()
+	}),
+	z.object({ kind: z.literal("opsx-change-list") }),
+	z.object({ kind: z.literal("opsx-status-list") }),
+	z.object({
+		kind: z.literal("opsx-instructions"),
+		change: z.string().min(1),
+		artifact: z.string().min(1),
+		schema: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("opsx-apply-instructions"),
+		change: z.string().min(1),
+		schema: z.string().optional()
+	}),
+	z.object({ kind: z.literal("opsx-config-bundle") }),
+	z.object({
+		kind: z.literal("opsx-templates"),
+		schema: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("opsx-template-contents"),
+		schema: z.string().optional()
+	}),
+	z.object({ kind: z.literal("spec-catalog") }),
+	z.object({
+		kind: z.literal("spec-document"),
+		identity: SpecIdentitySchema
+	})
+]);
+/** Data payload retained by one Planning-root Projection Work registry. */
+const PlanningCliProjectionDataSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("opsx-status"),
+		value: ChangeStatusSchema
+	}),
+	z.object({
+		kind: z.literal("opsx-change-list"),
+		value: z.array(z.string()),
+		evidence: CliProjectionCommandEvidenceSchema
+	}),
+	z.object({
+		kind: z.literal("opsx-status-list"),
+		value: z.array(ChangeStatusSchema),
+		evidence: CliProjectionCommandEvidenceSchema
+	}),
+	z.object({
+		kind: z.literal("opsx-instructions"),
+		value: ArtifactInstructionsSchema
+	}),
+	z.object({
+		kind: z.literal("opsx-apply-instructions"),
+		value: ApplyInstructionsProjectionSchema
+	}),
+	z.object({
+		kind: z.literal("opsx-config-bundle"),
+		value: OpsxConfigBundleSchema,
+		evidence: z.object({
+			schemas: CliProjectionCommandEvidenceSchema,
+			schemaResolutions: z.record(z.string(), CliProjectionCommandEvidenceSchema)
+		})
+	}),
+	z.object({
+		kind: z.literal("opsx-templates"),
+		value: TemplatesSchema,
+		evidence: CliProjectionCommandEvidenceSchema
+	}),
+	z.object({
+		kind: z.literal("opsx-template-contents"),
+		value: TemplateContentMapSchema,
+		evidence: CliProjectionCommandEvidenceSchema
+	}),
+	z.object({
+		kind: z.literal("spec-catalog"),
+		value: SpecCatalogSchema
+	}),
+	z.object({
+		kind: z.literal("spec-document"),
+		value: SpecDocumentProjectionSchema
+	})
+]);
+/** Browser-safe lifecycle Pull schema for every selector-exact Planning-root projection. */
+const PlanningCliProjectionStateSchema = createCliProjectionStateSchema(PlanningCliProjectionDataSchema);
+const CliJsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(CliJsonValueSchema),
+	z.record(z.string(), CliJsonValueSchema)
+]));
+const CliResultSchema = z.object({
+	success: z.boolean(),
+	stdout: z.string(),
+	stderr: z.string(),
+	exitCode: z.number().int().nullable()
+});
+const EnvironmentConfigCommandResultSchema = CliResultSchema.extend({
+	data: z.record(z.string(), CliJsonValueSchema).nullable(),
+	payload: CliJsonValueSchema.nullable(),
+	diagnostics: z.array(CliDiagnosticSchema),
+	contractError: z.string().optional()
+});
+/** Browser-safe runtime schema for the CLI-owned Environment Global projection. */
+const EnvironmentGlobalProjectionDataSchema = z.object({
+	kind: z.literal("environment-global"),
+	owner: z.object({
+		kind: z.literal("runtime-environment"),
+		dataScope: z.object({
+			path: z.string(),
+			source: z.enum([
+				"xdg-data-home",
+				"local-app-data",
+				"user-home-default"
+			]),
+			environmentVariable: z.enum(["XDG_DATA_HOME", "LOCALAPPDATA"]).nullable()
+		})
+	}),
+	configPath: z.string().nullable(),
+	config: z.record(z.string(), CliJsonValueSchema).nullable(),
+	profileState: z.object({
+		available: z.boolean(),
+		profile: z.enum(["core", "custom"]).nullable(),
+		delivery: z.enum([
+			"both",
+			"skills",
+			"commands"
+		]).nullable(),
+		workflows: z.array(z.string()),
+		driftStatus: z.enum([
+			"in-sync",
+			"drift",
+			"unknown"
+		]),
+		warningText: z.string().nullable(),
+		error: z.string().optional()
+	}),
+	evidence: z.object({
+		path: CliResultSchema,
+		config: EnvironmentConfigCommandResultSchema,
+		drift: CliResultSchema
+	})
+});
+/** Browser-safe file-native projection for the CLI-selected editable config document. */
+const EnvironmentGlobalFileProjectionDataSchema = z.object({
+	kind: z.literal("environment-global-file"),
+	owner: z.object({
+		kind: z.literal("runtime-environment"),
+		dataScope: z.object({
+			path: z.string(),
+			source: z.enum([
+				"xdg-data-home",
+				"local-app-data",
+				"user-home-default"
+			]),
+			environmentVariable: z.enum(["XDG_DATA_HOME", "LOCALAPPDATA"]).nullable()
+		})
+	}),
+	file: z.object({
+		path: z.string().nullable(),
+		format: z.literal("json"),
+		exists: z.boolean(),
+		content: z.string().nullable()
+	})
+});
+/** Browser-safe lifecycle Pull schema for the file-native config owner. */
+const EnvironmentGlobalFileProjectionStateSchema = createCliProjectionStateSchema(EnvironmentGlobalFileProjectionDataSchema);
+/** Browser-safe lifecycle Pull schema for the runtime-environment config/profile projection. */
+const EnvironmentGlobalProjectionStateSchema = createCliProjectionStateSchema(EnvironmentGlobalProjectionDataSchema);
+
+//#endregion
+export { TemplateContentMapSchema as C, isGlobPattern as E, SchemaResolutionSchema as S, TemplatesSchema as T, OpsxConfigBundleSchema as _, PlanningCliProjectionDataSchema as a, SchemaDetailSchema as b, ApplyInstructionsContextFilesSchema as c, ApplyTaskSchema as d, ArtifactInstructionsSchema as f, OpsxCliEvidenceSchema as g, DependencyInfoSchema as h, EnvironmentGlobalProjectionStateSchema as i, ApplyInstructionsProjectionSchema as l, ChangeStatusSchema as m, EnvironmentGlobalFileProjectionStateSchema as n, PlanningCliProjectionSelectorSchema as o, ArtifactStatusSchema as p, EnvironmentGlobalProjectionDataSchema as r, PlanningCliProjectionStateSchema as s, EnvironmentGlobalFileProjectionDataSchema as t, ApplyInstructionsSchema as u, OpsxStatusEvidenceSchema as v, TemplateContentSchema as w, SchemaInfoSchema as x, SchemaArtifactSchema as y };

package/dist/planning-cli-projection.d.mts

@@ -0,0 +1,25 @@
+import "./command-result-fkH3Ekdz.mjs";
+import "./document-translation-D50BnvVh.mjs";
+import "./sounds-qhRgCy0F.mjs";
+import "./notifications-CgJlLgLO.mjs";
+import { u as CliProjectionNoticeSchema } from "./cli-projection-DxnVGm2B.mjs";
+import "./schemas-DS-JqAJ2.mjs";
+import "./opsx-types-BJ8AjhrS.mjs";
+import "./opsx-entity-D7kDQsze.mjs";
+import { Cr as PlanningCliProjectionStateSchema, Sr as PlanningCliProjectionState, _r as EnvironmentGlobalProjectionStateSchema, br as PlanningCliProjectionSelector, dr as EnvironmentGlobalFileProjectionDataSchema, fr as EnvironmentGlobalFileProjectionState, gr as EnvironmentGlobalProjectionState, hr as EnvironmentGlobalProjectionDataSchema, mr as EnvironmentGlobalProjectionData, pr as EnvironmentGlobalFileProjectionStateSchema, ur as EnvironmentGlobalFileProjectionData, vr as PlanningCliProjectionData, xr as PlanningCliProjectionSelectorSchema, yr as PlanningCliProjectionDataSchema } from "./dashboard-summary-transport-CQ4is5_e.mjs";
+import "./markdown-facts-CCw3QdbM.mjs";
+import "./markdown-reading-LUdqfbxH.mjs";
+import "./openspec-annotations-C58Aoi-V.mjs";
+import "./openspec-projection-RohNZI4p.mjs";
+import "./translator-NKv1wo3o.mjs";
+import "./terminal-audio-tXDm_EDe.mjs";
+import "./local-download-profiles-BL_rtlVM.mjs";
+import "./translation-language-pair-C18GPATW.mjs";
+import "./opsx-workflows-BvnJqjfL.mjs";
+import "./opsx-display-path-RXS5JTbV.mjs";
+import "./store-mutation-protocol-5tfs-RmD.mjs";
+import "./store-types-b554wAQJ.mjs";
+import "./terminal-invocation-BOvxThym.mjs";
+import "./terminal-theme-m3MSGJ7U.mjs";
+import "./opsx-schema-detail-BxDXEwDY.mjs";
+export { CliProjectionNoticeSchema, EnvironmentGlobalFileProjectionData, EnvironmentGlobalFileProjectionDataSchema, EnvironmentGlobalFileProjectionState, EnvironmentGlobalFileProjectionStateSchema, EnvironmentGlobalProjectionData, EnvironmentGlobalProjectionDataSchema, EnvironmentGlobalProjectionState, EnvironmentGlobalProjectionStateSchema, PlanningCliProjectionData, PlanningCliProjectionDataSchema, PlanningCliProjectionSelector, PlanningCliProjectionSelectorSchema, PlanningCliProjectionState, PlanningCliProjectionStateSchema };

package/dist/planning-cli-projection.mjs

@@ -0,0 +1,9 @@
+import "./schemas-BFroDdOC.mjs";
+import "./opsx-entity-Cn_Zu1J3.mjs";
+import "./task-progress-B_IWVXjA.mjs";
+import "./common-D8YUK9dA.mjs";
+import "./spec-catalog-ZGuiZ4CE.mjs";
+import { o as CliProjectionNoticeSchema } from "./cli-projection-vO3-FJg5.mjs";
+import { a as PlanningCliProjectionDataSchema, i as EnvironmentGlobalProjectionStateSchema, n as EnvironmentGlobalFileProjectionStateSchema, o as PlanningCliProjectionSelectorSchema, r as EnvironmentGlobalProjectionDataSchema, s as PlanningCliProjectionStateSchema, t as EnvironmentGlobalFileProjectionDataSchema } from "./planning-cli-projection-DIRxeq2H.mjs";
+
+export { CliProjectionNoticeSchema, EnvironmentGlobalFileProjectionDataSchema, EnvironmentGlobalFileProjectionStateSchema, EnvironmentGlobalProjectionDataSchema, EnvironmentGlobalProjectionStateSchema, PlanningCliProjectionDataSchema, PlanningCliProjectionSelectorSchema, PlanningCliProjectionStateSchema };