minutework 0.1.8 → 0.1.11

package/vendor/workspace-mcp/context.js

@@ -0,0 +1,1840 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { analyzeCompilerWorkspace, CompileGraphSchema, discoverCompilerWorkspaceRoot, HostedPreviewReleaseMetadataSchema, inspectCompilerWorkspace, loadWorkspaceConfig as loadSharedWorkspaceConfig, resolveGeneratedArtifactPaths, resolveWorkspaceCliConfig, } from "@minutework/schema-compiler";
+import { z } from "zod";
+import { createSha256Digest, readOptionalLocalRuntimeActivityFile, resolveLocalRuntimeStatePaths, } from "./runtime-state.js";
+import { CapabilityGapLayerSchema, CapabilityGapReportSchema, CapabilityGapReusabilitySchema, BindingPayloadSchema, PreviewDeployStateSchema, } from "./types.js";
+const StoredAuthProfileSchema = z.object({
+    createdAt: z.string(),
+    expiresAt: z.string(),
+    id: z.string(),
+    platformBaseUrl: z.string(),
+    scopeTemplate: z.string(),
+    scopes: z.array(z.string()),
+    tenantId: z.string(),
+    tenantName: z.string(),
+    tenantSlug: z.string(),
+    token: z.string(),
+    tokenKind: z.string(),
+    user: z.object({
+        email: z.string(),
+        id: z.string(),
+        username: z.string(),
+    }),
+});
+export class WorkspaceMcpError extends Error {
+}
+export const WORKSPACE_MCP_TOOL_SPECS = [
+    {
+        description: "Return MinuteWork workspace metadata, local binding/auth status, starter flags, and top-level diagnostics.",
+        id: "minutework_workspace_snapshot",
+    },
+    {
+        description: "Return MinuteWork schema entrypoint status, validate report, compiled schema graph when available, and artifact readiness for compile/codegen outputs.",
+        id: "minutework_schema_status",
+    },
+    {
+        description: "Return local sandbox topology, compile-graph readiness, planned dev/test steps, and persisted local runtime activity derived from workspace state.",
+        id: "minutework_local_runtime_status",
+    },
+    {
+        description: "Return current MinuteWork deploy target context plus preview/live placeholder status objects.",
+        id: "minutework_deploy_status",
+    },
+    {
+        description: "Return aggregated MinuteWork workspace diagnostics and recommended next actions.",
+        id: "minutework_workspace_doctor",
+    },
+    {
+        description: "Return a truthful MinuteWork capability inventory for the generated workspace, including local manifest surface, preview/publication posture, blind spots, and gap-report contract details.",
+        id: "minutework_capability_inventory",
+    },
+];
+export function getWorkspaceMcpToolDescription(id) {
+    return WORKSPACE_MCP_TOOL_SPECS.find((tool) => tool.id === id)?.description ?? id;
+}
+export function parseWorkspaceMcpCliArgs(args) {
+    let workspacePath;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h") {
+            return { help: true };
+        }
+        if (arg === "--workspace") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("--")) {
+                throw new WorkspaceMcpError('The "--workspace" option requires a path.');
+            }
+            workspacePath = next;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--workspace=")) {
+            workspacePath = arg.slice("--workspace=".length);
+            if (!workspacePath) {
+                throw new WorkspaceMcpError('The "--workspace" option requires a path.');
+            }
+            continue;
+        }
+        throw new WorkspaceMcpError(`Unknown mcp option: ${arg}`);
+    }
+    return {
+        help: false,
+        workspacePath,
+    };
+}
+export function renderWorkspaceMcpHelp() {
+    return `MinuteWork workspace MCP
+
+Usage:
+  minutework mcp [--workspace <path>]
+
+Starts a read-only local MCP server over stdio for MinuteWork-aware IDE tools.
+`;
+}
+export async function loadWorkspaceContext(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const workspaceRoot = await resolveWorkspaceRoot({
+        cwd,
+        workspacePath: options.workspacePath,
+    });
+    const configPath = path.join(workspaceRoot, "minutework.config.ts");
+    const config = await loadWorkspaceConfig(configPath);
+    const resolvedWorkspaceCliConfig = await resolveWorkspaceCliConfig({
+        env,
+        workspaceRoot,
+    });
+    const bindingPath = path.join(workspaceRoot, config.localState.directory, "binding.json");
+    const bindingState = await readOptionalWorkspaceBinding(bindingPath);
+    const statePaths = resolveCliStatePaths({ env, platform });
+    const authRecord = await loadCurrentAuthProfile(statePaths);
+    const cursorConfigPath = path.join(workspaceRoot, config.mcp.cursorConfigPath);
+    const claudeDesktopSamplePath = path.join(workspaceRoot, config.mcp.claudeDesktopSamplePath);
+    const schemaDirectoryPath = path.join(workspaceRoot, config.schema.directory);
+    const schemaEntrypointPath = path.join(workspaceRoot, config.schema.entrypoint);
+    const schemaMwPath = path.join(workspaceRoot, "schema.mw");
+    const tenantAppStarterPath = path.join(workspaceRoot, config.starters.tenantApp.path);
+    const sidecarStarterPath = path.join(workspaceRoot, config.starters.sidecar.path);
+    const artifactPaths = resolveGeneratedArtifactPaths(config.localState.directory);
+    const runtimeStatePaths = resolveLocalRuntimeStatePaths(workspaceRoot, config.localState.directory);
+    const previewDeployStatePath = path.join(workspaceRoot, config.localState.directory, "deploy", "preview", "status.json");
+    const capabilityGapReportPath = path.join(runtimeStatePaths.sandboxRoot, "capability-gap-report.json");
+    const compilerStaticAnalysis = await inspectCompilerWorkspace(workspaceRoot);
+    const compilerAnalysis = await analyzeCompilerWorkspace(workspaceRoot);
+    const [cursorConfigExists, claudeDesktopSampleExists, schemaDirectoryExists, schemaEntrypointExists, schemaMwExists, compileGraphArtifactExists, openapiArtifactExists, clientTypesArtifactExists, tenantAppStarterExists, sidecarStarterExists,] = await Promise.all([
+        exists(cursorConfigPath),
+        exists(claudeDesktopSamplePath),
+        exists(schemaDirectoryPath),
+        exists(schemaEntrypointPath),
+        exists(schemaMwPath),
+        exists(path.join(workspaceRoot, artifactPaths.compileGraphPath)),
+        exists(path.join(workspaceRoot, artifactPaths.openapiPath)),
+        exists(path.join(workspaceRoot, artifactPaths.clientTypesPath)),
+        exists(tenantAppStarterPath),
+        exists(sidecarStarterPath),
+    ]);
+    const persistedCompileGraphState = compileGraphArtifactExists
+        ? await readOptionalCompileGraph(path.join(workspaceRoot, artifactPaths.compileGraphPath))
+        : { corrupted: false, digest: null, graph: null };
+    const persistedCompileGraphCurrent = compilerAnalysis.compileGraph !== null &&
+        persistedCompileGraphState.graph !== null &&
+        JSON.stringify(persistedCompileGraphState.graph) === JSON.stringify(compilerAnalysis.compileGraph);
+    const [runtimeDevSessionState, runtimeTestRunState] = await Promise.all([
+        readOptionalLocalRuntimeActivityFile({
+            command: "dev",
+            filePath: runtimeStatePaths.devSessionPath,
+        }),
+        readOptionalLocalRuntimeActivityFile({
+            command: "test",
+            filePath: runtimeStatePaths.testRunPath,
+        }),
+    ]);
+    const previewDeployStateRecord = await readOptionalPreviewDeployState(previewDeployStatePath);
+    const capabilityGapReportRecord = await readOptionalCapabilityGapReport(capabilityGapReportPath);
+    const openapiArtifactState = await inspectGeneratedJsonArtifact(path.join(workspaceRoot, artifactPaths.openapiPath), compilerAnalysis.codegenArtifacts ? formatJson(compilerAnalysis.codegenArtifacts.openapi) : null);
+    const clientTypesArtifactState = await inspectGeneratedTextArtifact(path.join(workspaceRoot, artifactPaths.clientTypesPath), compilerAnalysis.codegenArtifacts?.clientTypes ?? null);
+    const authStatus = buildAuthStatus(authRecord, statePaths.authRoot);
+    const bindingStatus = buildBindingStatus(bindingPath, bindingState.binding, authStatus.profile);
+    const diagnostics = [
+        ...bindingState.diagnostics,
+        ...authRecord.diagnostics,
+        ...buildPlatformMismatchDiagnostics(authStatus.profile, resolvedWorkspaceCliConfig),
+        ...buildDiagnostics({
+            authStatus,
+            authStateMalformed: authRecord.diagnostics.length > 0,
+            bindingStatus,
+            bindingStateMalformed: bindingState.diagnostics.length > 0,
+            claudeDesktopSampleExists,
+            claudeDesktopSamplePath,
+            cursorConfigExists,
+            cursorConfigPath,
+            persistedCompileGraphCorrupted: persistedCompileGraphState.corrupted,
+            schemaDirectoryExists,
+            schemaDirectoryPath,
+            schemaEntrypointExists,
+            schemaEntrypointPath,
+            schemaMwExists,
+            schemaMwPath,
+        }),
+    ];
+    return {
+        authStatus,
+        bindingStatus,
+        capabilityGapReport: capabilityGapReportRecord.report,
+        capabilityGapReportCorrupted: capabilityGapReportRecord.corrupted,
+        capabilityGapReportPath,
+        claudeDesktopSampleExists,
+        claudeDesktopSamplePath,
+        clientTypesArtifactExists,
+        compileGraphArtifactExists,
+        compilerAnalysis,
+        compilerStaticAnalysis,
+        config,
+        configPath,
+        cursorConfigExists,
+        cursorConfigPath,
+        diagnostics,
+        openapiArtifactExists,
+        persistedCompileGraph: persistedCompileGraphState.graph,
+        persistedCompileGraphDigest: persistedCompileGraphCurrent ? persistedCompileGraphState.digest : null,
+        persistedCompileGraphCurrent,
+        persistedCompileGraphCorrupted: persistedCompileGraphState.corrupted,
+        persistedClientTypesCurrent: clientTypesArtifactState.current,
+        persistedOpenapiCorrupted: openapiArtifactState.corrupted,
+        persistedOpenapiCurrent: openapiArtifactState.current,
+        previewDeployState: previewDeployStateRecord.state,
+        previewDeployStateCorrupted: previewDeployStateRecord.corrupted,
+        previewDeployStatePath,
+        resolvedWorkspaceCliConfig,
+        runtimeDevSessionState,
+        runtimeStatePaths,
+        runtimeTestRunState,
+        schemaDirectoryExists,
+        schemaDirectoryPath,
+        schemaEntrypointExists,
+        schemaEntrypointPath,
+        schemaMwExists,
+        schemaMwPath,
+        sidecarStarterExists,
+        tenantAppStarterExists,
+        workspaceRoot,
+    };
+}
+export async function loadLocalRuntimeStatusContext(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const workspaceRoot = await resolveWorkspaceRoot({
+        cwd,
+        workspacePath: options.workspacePath,
+    });
+    const configPath = path.join(workspaceRoot, "minutework.config.ts");
+    const config = await loadWorkspaceConfig(configPath);
+    const compilerStaticAnalysis = await inspectCompilerWorkspace(workspaceRoot);
+    const artifactPaths = resolveGeneratedArtifactPaths(config.localState.directory);
+    const compileGraphPath = path.join(workspaceRoot, artifactPaths.compileGraphPath);
+    const runtimeStatePaths = resolveLocalRuntimeStatePaths(workspaceRoot, config.localState.directory);
+    const tenantAppStarterPath = path.join(workspaceRoot, config.starters.tenantApp.path);
+    const sidecarStarterPath = path.join(workspaceRoot, config.starters.sidecar.path);
+    const [compileGraphArtifactExists, tenantAppStarterExists, sidecarStarterExists] = await Promise.all([
+        exists(compileGraphPath),
+        exists(tenantAppStarterPath),
+        exists(sidecarStarterPath),
+    ]);
+    const persistedCompileGraphState = compileGraphArtifactExists
+        ? await readOptionalCompileGraph(compileGraphPath)
+        : { corrupted: false, digest: null, graph: null };
+    const persistedCompileGraphCurrent = isPersistedCompileGraphCurrent(persistedCompileGraphState.graph, compilerStaticAnalysis);
+    const [runtimeDevSessionState, runtimeTestRunState] = await Promise.all([
+        readOptionalLocalRuntimeActivityFile({
+            command: "dev",
+            filePath: runtimeStatePaths.devSessionPath,
+        }),
+        readOptionalLocalRuntimeActivityFile({
+            command: "test",
+            filePath: runtimeStatePaths.testRunPath,
+        }),
+    ]);
+    return {
+        compileGraphArtifactExists,
+        compilerStaticAnalysis,
+        config,
+        persistedCompileGraphDigest: persistedCompileGraphCurrent ? persistedCompileGraphState.digest : null,
+        persistedCompileGraphCorrupted: persistedCompileGraphState.corrupted,
+        persistedCompileGraphCurrent,
+        runtimeDevSessionState,
+        runtimeStatePaths,
+        runtimeTestRunState,
+        sidecarStarterExists,
+        tenantAppStarterExists,
+        workspaceRoot,
+    };
+}
+export function collectWorkspaceSnapshot(context) {
+    return {
+        authStatus: context.authStatus,
+        bindingStatus: context.bindingStatus,
+        config: buildNormalizedWorkspaceConfig(context),
+        configPath: context.configPath,
+        diagnostics: context.diagnostics,
+        ide: {
+            claudeDesktopSample: {
+                exists: context.claudeDesktopSampleExists,
+                path: context.claudeDesktopSamplePath,
+            },
+            cursorConfig: {
+                exists: context.cursorConfigExists,
+                path: context.cursorConfigPath,
+            },
+        },
+        resolvedPlatform: {
+            baseUrl: context.resolvedWorkspaceCliConfig.platformBaseUrl,
+            hasLegacyOverride: context.resolvedWorkspaceCliConfig.hasLegacyPlatformOverride,
+            source: context.resolvedWorkspaceCliConfig.platformBaseUrlSource,
+        },
+        schema: {
+            directory: context.config.schema.directory,
+            directoryExists: context.schemaDirectoryExists,
+            directoryPath: context.schemaDirectoryPath,
+            entrypoint: context.config.schema.entrypoint,
+            entrypointExists: context.schemaEntrypointExists,
+            entrypointPath: context.schemaEntrypointPath,
+        },
+        starters: [
+            buildStarter("tenant-app", context),
+            buildStarter("sidecar", context),
+        ],
+        workspaceName: context.config.workspace.name,
+        workspaceRoot: context.workspaceRoot,
+    };
+}
+function buildNormalizedWorkspaceConfig(context) {
+    return {
+        localState: {
+            directory: context.config.localState.directory,
+            directoryPath: path.join(context.workspaceRoot, context.config.localState.directory),
+        },
+        platform: context.config.platform
+            ? {
+                baseUrl: context.config.platform.baseUrl ?? null,
+                defaultEnvironment: context.config.platform.defaultEnvironment ?? null,
+            }
+            : null,
+        mcp: {
+            claudeDesktopSampleAbsolutePath: context.claudeDesktopSamplePath,
+            claudeDesktopSamplePath: context.config.mcp.claudeDesktopSamplePath,
+            cursorConfigAbsolutePath: context.cursorConfigPath,
+            cursorConfigPath: context.config.mcp.cursorConfigPath,
+        },
+        schema: {
+            directory: context.config.schema.directory,
+            directoryPath: context.schemaDirectoryPath,
+            entrypoint: context.config.schema.entrypoint,
+            entrypointPath: context.schemaEntrypointPath,
+        },
+        starters: {
+            sidecar: buildNormalizedStarterConfig("sidecar", context),
+            tenantApp: buildNormalizedStarterConfig("tenant-app", context),
+        },
+        workspace: {
+            name: context.config.workspace.name,
+        },
+    };
+}
+export function collectSchemaStatus(context) {
+    const prerequisiteCodes = collectSchemaPrerequisiteCodes(context);
+    const artifactPaths = resolveGeneratedArtifactPaths(context.config.localState.directory);
+    return {
+        artifacts: [
+            buildArtifactStatus(context, "compile_graph", artifactPaths.compileGraphPath, prerequisiteCodes),
+            buildArtifactStatus(context, "openapi", artifactPaths.openapiPath, prerequisiteCodes),
+            buildArtifactStatus(context, "client_types", artifactPaths.clientTypesPath, prerequisiteCodes),
+        ],
+        compileGraph: context.compilerAnalysis.compileGraph,
+        diagnostics: context.diagnostics,
+        directoryExists: context.schemaDirectoryExists,
+        entrypointExists: context.schemaEntrypointExists,
+        schemaDirectoryPath: context.schemaDirectoryPath,
+        schemaEntrypointPath: context.schemaEntrypointPath,
+        selectedInput: context.compilerAnalysis.validateReport.selectedInput,
+        validateReport: context.compilerAnalysis.validateReport,
+        workspaceRoot: context.workspaceRoot,
+    };
+}
+export function collectLocalRuntimeStatus(context) {
+    const artifactPaths = resolveGeneratedArtifactPaths(context.config.localState.directory);
+    const compileGraphPath = path.join(context.workspaceRoot, artifactPaths.compileGraphPath);
+    const hasSelectedInput = context.compilerStaticAnalysis.selectedInput !== null;
+    const hasCurrentCompileGraph = context.persistedCompileGraphCurrent;
+    const schemaPrerequisiteCodes = context.compilerStaticAnalysis.diagnostics
+        .filter((item) => item.severity !== "info")
+        .map((item) => item.code);
+    const compileGraphState = buildLocalRuntimeCompileGraphState(context, compileGraphPath);
+    const surfaces = [
+        buildSchemaCompileSurface(context, compileGraphPath),
+        buildStarterSurface(context, "tenant_app"),
+        buildStarterSurface(context, "sidecar"),
+    ];
+    const previewSurfaceIssueCodes = collectPreviewSurfaceIssueCodes(surfaces);
+    const hasMissingPreviewSurfacePath = previewSurfaceIssueCodes.some((code) => code === "workspace.runtime.tenant_app_missing" || code === "workspace.runtime.sidecar_missing");
+    const hasEnabledPreviewSurface = surfaces.some((surface) => (surface.id === "tenant_app" || surface.id === "sidecar") && surface.status === "ready");
+    const devActivity = buildLocalRuntimeActivitySummary("dev", context.runtimeDevSessionState, context.persistedCompileGraphDigest);
+    const testActivity = buildLocalRuntimeActivitySummary("test", context.runtimeTestRunState, context.persistedCompileGraphDigest);
+    return {
+        activity: {
+            dev: devActivity,
+            test: testActivity,
+        },
+        commands: [
+            {
+                canonicalPath: path.join(context.runtimeStatePaths.sandboxRoot, "dev"),
+                detail: hasSelectedInput
+                    ? hasCurrentCompileGraph
+                        ? hasEnabledPreviewSurface
+                            ? "The local sandbox can start the enabled preview surfaces from the current canonical compile graph."
+                            : hasMissingPreviewSurfacePath
+                                ? "The local sandbox cannot start preview surfaces until the enabled starter paths exist."
+                                : "The local sandbox does not have any enabled preview surfaces yet. Add a tenant-app or sidecar starter before running dev."
+                        : "The local sandbox needs a current canonical compile graph before preview surfaces can start. Run `minutework compile` first."
+                    : "The local sandbox cannot start until the workspace has exactly one supported schema input.",
+                name: "dev",
+                prerequisiteCodes: hasSelectedInput
+                    ? hasCurrentCompileGraph
+                        ? previewSurfaceIssueCodes
+                        : ["workspace.runtime.compile_graph_missing", ...previewSurfaceIssueCodes]
+                    : schemaPrerequisiteCodes,
+                status: hasCurrentCompileGraph && hasEnabledPreviewSurface ? "ready" : "blocked",
+                steps: [...buildSchemaPreflightSteps(context), ...buildLocalRuntimePreviewSteps(context)],
+            },
+            {
+                canonicalPath: path.join(context.runtimeStatePaths.sandboxRoot, "test"),
+                detail: hasCurrentCompileGraph
+                    ? hasEnabledPreviewSurface
+                        ? "The local sandbox can run schema smoke checks and starter-local tests from the current canonical compile graph."
+                        : "The local sandbox can run schema smoke checks from the current canonical compile graph even without enabled preview surfaces."
+                    : hasSelectedInput
+                        ? "The local sandbox test loop needs a current canonical compile graph. Run `minutework compile` first."
+                        : "The local sandbox test loop is blocked until the workspace has exactly one supported schema input.",
+                name: "test",
+                prerequisiteCodes: hasCurrentCompileGraph
+                    ? []
+                    : hasSelectedInput
+                        ? ["workspace.runtime.compile_graph_missing"]
+                        : schemaPrerequisiteCodes,
+                status: hasCurrentCompileGraph ? "ready" : "blocked",
+                steps: [...buildSchemaTestSteps(context), ...buildLocalRuntimeTestSteps(context)],
+            },
+        ],
+        compileGraph: compileGraphState,
+        prerequisites: {
+            hasCurrentCompileGraph,
+            hasEnabledPreviewSurface,
+            hasSelectedInput,
+        },
+        status: hasCurrentCompileGraph ? "ready" : "blocked",
+        surfaces,
+        topology: {
+            devSessionPath: context.runtimeStatePaths.devSessionPath,
+            localStateDirectoryPath: path.join(context.workspaceRoot, context.config.localState.directory),
+            sandboxRoot: context.runtimeStatePaths.sandboxRoot,
+            testRunPath: context.runtimeStatePaths.testRunPath,
+        },
+        workspaceRoot: context.workspaceRoot,
+    };
+}
+function buildLocalRuntimeActivitySummary(command, state, currentCompileGraphDigest) {
+    const emptyOutcome = {
+        errorCode: null,
+        exitCode: null,
+        failedStepId: null,
+        signal: null,
+    };
+    if (state.kind === "missing") {
+        return {
+            compileGraphDigest: null,
+            controllerPid: null,
+            detail: command === "dev"
+                ? "No local dev session has been recorded yet."
+                : "No local test run has been recorded yet.",
+            endedAt: null,
+            filePath: state.filePath,
+            graphStatus: "missing",
+            outcome: emptyOutcome,
+            startedAt: null,
+            status: "missing",
+            steps: [],
+            updatedAt: null,
+        };
+    }
+    if (state.kind === "corrupted" || !state.record) {
+        return {
+            compileGraphDigest: null,
+            controllerPid: null,
+            detail: command === "dev"
+                ? "The persisted local dev session file is malformed. The next `minutework dev` run will replace it."
+                : "The persisted local test run file is malformed. The next `minutework test` run will replace it.",
+            endedAt: null,
+            filePath: state.filePath,
+            graphStatus: "missing",
+            outcome: emptyOutcome,
+            startedAt: null,
+            status: "corrupted",
+            steps: [],
+            updatedAt: null,
+        };
+    }
+    const graphStatus = resolveLocalRuntimeActivityGraphStatus(state.record.compileGraphDigest, currentCompileGraphDigest);
+    const base = {
+        compileGraphDigest: state.record.compileGraphDigest,
+        controllerPid: state.record.controllerPid,
+        endedAt: state.record.endedAt,
+        filePath: state.filePath,
+        graphStatus,
+        outcome: state.record.outcome,
+        startedAt: state.record.startedAt,
+        steps: state.record.steps,
+        updatedAt: state.record.updatedAt,
+    };
+    if (state.stale) {
+        return {
+            ...base,
+            detail: command === "dev"
+                ? "The last local dev session still claimed to be running, but its recorded controller or child processes are no longer live."
+                : "The last local test run still claimed to be running, but its recorded controller or child processes are no longer live.",
+            status: "stale",
+        };
+    }
+    switch (state.record.status) {
+        case "running":
+            return {
+                ...base,
+                detail: command === "dev"
+                    ? "The local dev session is currently running."
+                    : "The local test run is currently running.",
+                status: "running",
+            };
+        case "exited":
+            return {
+                ...base,
+                detail: "The last local dev session exited cleanly.",
+                status: "exited",
+            };
+        case "passed":
+            return {
+                ...base,
+                detail: "The last local test run passed.",
+                status: "passed",
+            };
+        case "failed":
+            return {
+                ...base,
+                detail: command === "dev"
+                    ? "The last local dev session failed."
+                    : "The last local test run failed.",
+                status: "failed",
+            };
+        case "interrupted":
+            return {
+                ...base,
+                detail: command === "dev"
+                    ? "The last local dev session ended due to an interrupt signal."
+                    : "The last local test run ended due to an interrupt signal.",
+                status: "interrupted",
+            };
+    }
+}
+function resolveLocalRuntimeActivityGraphStatus(recordedDigest, currentCompileGraphDigest) {
+    if (!recordedDigest || !currentCompileGraphDigest) {
+        return "missing";
+    }
+    return recordedDigest === currentCompileGraphDigest ? "current" : "stale";
+}
+function buildLocalRuntimeCompileGraphState(context, compileGraphPath) {
+    if (context.persistedCompileGraphCorrupted) {
+        return {
+            detail: "The persisted compile graph is malformed. Regenerate it with `minutework compile` before depending on it.",
+            path: compileGraphPath,
+            status: "corrupted",
+        };
+    }
+    if (context.persistedCompileGraphCurrent) {
+        return {
+            detail: "The persisted compile graph matches the current selected-input and config digests.",
+            path: compileGraphPath,
+            status: "current",
+        };
+    }
+    if (context.compilerStaticAnalysis.selectedInput === null) {
+        return {
+            detail: "The compile graph is blocked until the workspace has exactly one supported schema input.",
+            path: compileGraphPath,
+            status: "blocked",
+        };
+    }
+    if (context.compileGraphArtifactExists) {
+        return {
+            detail: "A persisted compile graph exists on disk, but it is stale relative to the current config or selected-input digests. Refresh it with `minutework compile`.",
+            path: compileGraphPath,
+            status: "stale",
+        };
+    }
+    return {
+        detail: "No compile graph is persisted yet. Generate the canonical local sandbox artifact with `minutework compile`.",
+        path: compileGraphPath,
+        status: "missing",
+    };
+}
+function buildSchemaCompileSurface(context, compileGraphPath) {
+    if (context.persistedCompileGraphCurrent) {
+        return {
+            detail: "The canonical compile graph is current and ready for local sandbox commands.",
+            id: "schema_compile",
+            path: compileGraphPath,
+            status: "ready",
+        };
+    }
+    if (context.compilerStaticAnalysis.selectedInput === null) {
+        return {
+            detail: "The canonical compile graph is blocked until the workspace has exactly one supported schema input.",
+            id: "schema_compile",
+            path: compileGraphPath,
+            status: "blocked",
+        };
+    }
+    return {
+        detail: "The canonical compile graph must be refreshed from the current workspace source before sandbox commands can run.",
+        id: "schema_compile",
+        path: compileGraphPath,
+        status: "blocked",
+    };
+}
+function buildStarterSurface(context, id) {
+    const isTenantApp = id === "tenant_app";
+    const starter = isTenantApp ? context.config.starters.tenantApp : context.config.starters.sidecar;
+    const starterExists = isTenantApp ? context.tenantAppStarterExists : context.sidecarStarterExists;
+    const starterLabel = isTenantApp ? "tenant-app" : "sidecar";
+    const absolutePath = path.join(context.workspaceRoot, starter.path);
+    if (!starter.enabled) {
+        return {
+            detail: `The ${starterLabel} starter is not enabled for this workspace.`,
+            id,
+            path: absolutePath,
+            status: "disabled",
+        };
+    }
+    if (!starterExists) {
+        return {
+            detail: `The configured ${starterLabel} starter path is missing on disk. Restore it or materialize a new workspace before using this local sandbox surface.`,
+            id,
+            path: absolutePath,
+            status: "missing",
+        };
+    }
+    if (!context.persistedCompileGraphCurrent) {
+        return {
+            detail: `The ${starterLabel} surface is configured, but it waits on a current canonical compile graph before local sandbox commands run.`,
+            id,
+            path: absolutePath,
+            status: "blocked",
+        };
+    }
+    return {
+        detail: `The ${starterLabel} surface is configured and can participate in the local sandbox loop.`,
+        id,
+        path: absolutePath,
+        status: "ready",
+    };
+}
+function collectPreviewSurfaceIssueCodes(surfaces) {
+    const issueCodes = [];
+    const tenantAppSurface = surfaces.find((surface) => surface.id === "tenant_app");
+    const sidecarSurface = surfaces.find((surface) => surface.id === "sidecar");
+    if (tenantAppSurface?.status === "missing") {
+        issueCodes.push("workspace.runtime.tenant_app_missing");
+    }
+    if (sidecarSurface?.status === "missing") {
+        issueCodes.push("workspace.runtime.sidecar_missing");
+    }
+    if ((tenantAppSurface?.status ?? "disabled") === "disabled" && (sidecarSurface?.status ?? "disabled") === "disabled") {
+        issueCodes.push("workspace.runtime.preview_surface_missing");
+    }
+    return issueCodes;
+}
+function buildSchemaPreflightSteps(context) {
+    return [
+        {
+            args: ["validate"],
+            cwd: context.workspaceRoot,
+            detail: "Validate the selected schema input before starting local preview surfaces.",
+            id: "validate",
+            program: "minutework",
+        },
+        {
+            args: ["compile"],
+            cwd: context.workspaceRoot,
+            detail: "Refresh the canonical compile graph used by the local sandbox.",
+            id: "compile",
+            program: "minutework",
+        },
+    ];
+}
+function buildSchemaTestSteps(context) {
+    return [
+        ...buildSchemaPreflightSteps(context),
+        {
+            args: ["codegen"],
+            cwd: context.workspaceRoot,
+            detail: "Refresh deterministic OpenAPI and client-type outputs for local sandbox and test workflows.",
+            id: "codegen",
+            program: "minutework",
+        },
+    ];
+}
+function buildLocalRuntimePreviewSteps(context) {
+    const steps = [];
+    if (context.config.starters.tenantApp.enabled && context.tenantAppStarterExists) {
+        steps.push({
+            args: ["--dir", context.config.starters.tenantApp.path, "dev"],
+            cwd: context.workspaceRoot,
+            detail: "Start the tenant-app preview surface.",
+            id: "tenant_app_dev",
+            program: "pnpm",
+        });
+    }
+    if (context.config.starters.sidecar.enabled && context.sidecarStarterExists) {
+        steps.push({
+            args: ["run", "uvicorn", "fastapi_sidecar.main:app", "--reload"],
+            cwd: path.join(context.workspaceRoot, context.config.starters.sidecar.path),
+            detail: "Start the sidecar preview surface.",
+            id: "sidecar_dev",
+            program: "poetry",
+        });
+    }
+    return steps;
+}
+function buildLocalRuntimeTestSteps(context) {
+    const steps = [];
+    if (context.config.starters.tenantApp.enabled && context.tenantAppStarterExists) {
+        steps.push({
+            args: ["--dir", context.config.starters.tenantApp.path, "test"],
+            cwd: context.workspaceRoot,
+            detail: "Run the tenant-app local test suite.",
+            id: "tenant_app_test",
+            program: "pnpm",
+        });
+    }
+    if (context.config.starters.sidecar.enabled && context.sidecarStarterExists) {
+        steps.push({
+            args: ["run", "pytest"],
+            cwd: path.join(context.workspaceRoot, context.config.starters.sidecar.path),
+            detail: "Run the sidecar local test suite.",
+            id: "sidecar_test",
+            program: "poetry",
+        });
+    }
+    return steps;
+}
+export function collectDeployStatus(context) {
+    const binding = context.bindingStatus.binding;
+    const activeEnvironment = binding?.environment ?? null;
+    const compiledRelease = resolveCompiledPreviewReleaseMetadata(context.compilerAnalysis.compileGraph, binding?.propertyKey ?? null);
+    const previewState = resolvePreviewDeployStateForBinding(context.previewDeployState, binding);
+    const previewPrerequisiteCodes = collectDeployPrerequisiteCodes({
+        binding,
+        compiledRelease,
+        context,
+    });
+    const previewTarget = buildPreviewDeployTargetStatus({
+        binding,
+        compiledRelease,
+        context,
+        currentTarget: activeEnvironment === "preview",
+        previewState,
+        prerequisiteCodes: previewPrerequisiteCodes,
+    });
+    const liveTarget = buildLiveDeployTargetStatus(context, activeEnvironment === "live");
+    return {
+        status: previewTarget.status === "deployed"
+            ? "deployed"
+            : previewTarget.status === "failed"
+                ? "failed"
+                : previewTarget.status === "ready"
+                    ? "ready"
+                    : "blocked",
+        targetContext: {
+            activeEnvironment,
+            platformBaseUrl: binding?.platformBaseUrl ?? context.authStatus.profile?.platformBaseUrl ?? null,
+            propertyKey: binding?.propertyKey ?? null,
+            releaseClass: binding?.releaseClass ?? null,
+            tenantId: binding?.tenantId ?? context.authStatus.profile?.tenantId ?? null,
+            tenantSlug: binding?.tenantSlug ?? context.authStatus.profile?.tenantSlug ?? null,
+            workspaceName: binding?.workspaceName ?? context.authStatus.profile?.tenantName ?? null,
+        },
+        targets: [previewTarget, liveTarget],
+        workspaceRoot: context.workspaceRoot,
+    };
+}
+export function collectWorkspaceDoctor(context) {
+    const diagnostics = collectDoctorDiagnostics(context);
+    const recommendedActions = buildRecommendedActions(diagnostics);
+    return {
+        diagnostics,
+        recommendedActions,
+        summary: {
+            errorCount: diagnostics.filter((item) => item.severity === "error").length,
+            infoCount: diagnostics.filter((item) => item.severity === "info").length,
+            warningCount: diagnostics.filter((item) => item.severity === "warning").length,
+        },
+        workspaceRoot: context.workspaceRoot,
+    };
+}
+export function collectCapabilityInventory(context) {
+    const localRuntimeStatus = collectLocalRuntimeStatus(context);
+    const deployStatus = collectDeployStatus(context);
+    const previewTarget = deployStatus.targets.find((target) => target.environment === "preview") ??
+        buildPreviewDeployTargetStatus({
+            binding: null,
+            compiledRelease: null,
+            context,
+            currentTarget: false,
+            previewState: null,
+            prerequisiteCodes: [],
+        });
+    const liveTarget = deployStatus.targets.find((target) => target.environment === "live") ??
+        buildLiveDeployTargetStatus(context, false);
+    const enabledStarters = [
+        context.config.starters.tenantApp.enabled ? "tenant-app" : null,
+        context.config.starters.sidecar.enabled ? "sidecar" : null,
+    ].filter((starter) => starter !== null);
+    const compileGraph = context.compilerAnalysis.compileGraph;
+    const compileGraphDocumentCounts = {
+        actionManifests: compileGraph?.documents.actionManifests.length ?? 0,
+        appManifests: compileGraph?.documents.appManifests.length ?? 0,
+        flowManifests: compileGraph?.documents.flowManifests.length ?? 0,
+        ontologyMappingManifests: compileGraph?.documents.ontologyMappingManifests.length ?? 0,
+        projectionContracts: compileGraph?.documents.projectionContracts.length ?? 0,
+        queryManifests: compileGraph?.documents.queryManifests.length ?? 0,
+        releaseMetadata: compileGraph?.documents.releaseMetadata.length ?? 0,
+        routeManifests: compileGraph?.documents.routeManifests.length ?? 0,
+        schemaDefinitions: compileGraph?.documents.schemaDefinitions.length ?? 0,
+        skillManifests: compileGraph?.documents.skillManifests.length ?? 0,
+    };
+    const unknowns = buildCapabilityInventoryUnknowns(context);
+    return {
+        alphaConstraints: {
+            deferred: [
+                "additional local coding engines beyond Claude",
+                "sidecar/runtime-backed deploy workflows from the hosted alpha lane",
+                "runtime-local Builder host work initiated from the developer-local broker lane",
+            ],
+            detail: "Generated workspaces can inspect local authoring, compile-graph, and preview deploy posture, but they do not imply full live runtime descriptor or live-public deployment coverage.",
+            hostedPreviewDeploy: "Hosted preview/deploy remains narrower than local authoring: the current external alpha lane centers on tenant-app preview deploys and does not imply sidecar or runtime-backed deploy support.",
+            localAuthoring: "Developer-local MinuteWork authoring currently supports tenant-app, sidecar, or both through the broker plus the local sandbox/workspace MCP lane.",
+            supportedLocalAuthoringSurfaces: ["tenant-app", "sidecar", "both"],
+        },
+        authAndBindingInventory: {
+            authStatus: context.authStatus.status,
+            bindingStatus: context.bindingStatus.status,
+            detail: buildCapabilityInventoryAuthDetail(context),
+            matchesActiveAuthProfile: context.bindingStatus.matchesActiveAuthProfile,
+            platformBaseUrl: context.bindingStatus.binding?.platformBaseUrl ??
+                context.authStatus.profile?.platformBaseUrl ??
+                null,
+        },
+        capabilityGapReportContract: buildCapabilityGapReportContract(context),
+        compileGraphInventory: {
+            artifactPath: localRuntimeStatus.compileGraph.path,
+            detail: compileGraph !== null
+                ? `The compile graph is the authoritative local declarative inventory for schemas, manifests, and release metadata in this workspace. ${localRuntimeStatus.compileGraph.detail}`
+                : `No authoritative local compile graph is currently available. ${localRuntimeStatus.compileGraph.detail}`,
+            documentCounts: compileGraphDocumentCounts,
+            selectedInput: context.compilerAnalysis.validateReport.selectedInput,
+            status: localRuntimeStatus.compileGraph.status,
+        },
+        knownLocalSurface: {
+            builderGuidance: {
+                claudeMdPath: path.join(context.workspaceRoot, "CLAUDE.md"),
+                detail: "Generated Builder guidance is exported into the workspace root as CLAUDE.md plus the skills/ directory.",
+                skillsDirectoryPath: path.join(context.workspaceRoot, "skills"),
+            },
+            contractualDefaults: [
+                "`tenant-app` is the combined public plus private web starter.",
+                "`mw.core.site` is a first-party baseline runtime capability by architecture contract.",
+                "Generated workspaces are developer-local authoring clients, not live runtime descriptors.",
+                "Anonymous live delivery should prefer published snapshots or hosted release paths.",
+            ],
+            workspaceMcpTools: [...WORKSPACE_MCP_TOOL_SPECS],
+        },
+        publicationInventory: {
+            activeEnvironment: deployStatus.targetContext.activeEnvironment,
+            detail: "Preview/publication posture is derived from repo binding, compiled release metadata, and persisted preview receipts. Live deploy remains intentionally blocked in the current external alpha.",
+            liveTarget,
+            previewTarget,
+        },
+        recommendedNextChecks: buildCapabilityInventoryRecommendedChecks(context, localRuntimeStatus, unknowns),
+        starterSurfaceInventory: {
+            detail: enabledStarters.length > 0
+                ? `Enabled local implementation surfaces: ${enabledStarters.join(", ")}. Sandbox readiness depends on both starter paths and a current compile graph.`
+                : "No local implementation surfaces are enabled for this workspace.",
+            enabledStarters,
+            localRuntimeSurfaces: localRuntimeStatus.surfaces,
+        },
+        unknowns,
+        workspaceRoot: context.workspaceRoot,
+    };
+}
+function buildArtifactStatus(context, id, relativePathFromWorkspaceRoot, prerequisiteCodes) {
+    const canonicalPath = path.join(context.workspaceRoot, relativePathFromWorkspaceRoot);
+    const compileEligible = context.compilerAnalysis.validateReport.compileEligible;
+    const existsOnDisk = id === "compile_graph"
+        ? context.compileGraphArtifactExists
+        : id === "openapi"
+            ? context.openapiArtifactExists
+            : context.clientTypesArtifactExists;
+    if (id === "compile_graph" && existsOnDisk && context.persistedCompileGraphCorrupted) {
+        return {
+            canonicalPath,
+            detail: "A compile graph artifact exists on disk, but it is malformed. Regenerate it with `minutework compile`.",
+            exists: true,
+            id,
+            prerequisiteCodes,
+            status: "blocked",
+        };
+    }
+    if (id === "compile_graph" && existsOnDisk && context.persistedCompileGraphCurrent) {
+        return {
+            canonicalPath,
+            detail: "This generated artifact is present on disk for the current workspace.",
+            exists: true,
+            id,
+            prerequisiteCodes,
+            status: "available",
+        };
+    }
+    if (id === "compile_graph") {
+        return {
+            canonicalPath,
+            detail: compileEligible
+                ? existsOnDisk
+                    ? "A compile graph exists on disk, but it no longer matches the current source digests. Rerun `minutework compile`."
+                    : "The compile graph can be generated from the current local schema source by running `minutework compile`."
+                : existsOnDisk
+                    ? "A compile graph exists on disk, but the current local schema source no longer validates cleanly."
+                    : "The compile graph is blocked until the local schema source validates cleanly.",
+            exists: existsOnDisk,
+            id,
+            prerequisiteCodes,
+            status: compileEligible ? "ready" : "blocked",
+        };
+    }
+    if (!compileEligible) {
+        return {
+            canonicalPath,
+            detail: existsOnDisk
+                ? "A generated artifact exists on disk, but the current local schema source no longer validates cleanly."
+                : "Generated codegen artifacts are blocked until the local schema source validates cleanly.",
+            exists: existsOnDisk,
+            id,
+            prerequisiteCodes,
+            status: "blocked",
+        };
+    }
+    if (!context.persistedCompileGraphCurrent) {
+        return {
+            canonicalPath,
+            detail: existsOnDisk
+                ? "A generated artifact exists on disk, but the canonical compile graph is missing or stale. Rerun `minutework codegen`."
+                : "Generated codegen artifacts become available once the canonical compile graph is current and `minutework codegen` has been run.",
+            exists: existsOnDisk,
+            id,
+            prerequisiteCodes,
+            status: "ready",
+        };
+    }
+    const artifactIsCurrent = id === "openapi" ? context.persistedOpenapiCurrent : context.persistedClientTypesCurrent;
+    const artifactIsCorrupted = id === "openapi" ? context.persistedOpenapiCorrupted : false;
+    if (existsOnDisk && artifactIsCurrent) {
+        return {
+            canonicalPath,
+            detail: "This generated artifact is present on disk for the current compile graph.",
+            exists: true,
+            id,
+            prerequisiteCodes,
+            status: "available",
+        };
+    }
+    return {
+        canonicalPath,
+        detail: existsOnDisk
+            ? artifactIsCorrupted
+                ? "A generated OpenAPI artifact exists on disk, but it is malformed. Regenerate it with `minutework codegen`."
+                : "A generated artifact exists on disk, but it no longer matches the current compile graph. Rerun `minutework codegen`."
+            : "This generated artifact can be produced from the current compile graph by running `minutework codegen`.",
+        exists: existsOnDisk,
+        id,
+        prerequisiteCodes,
+        status: "ready",
+    };
+}
+function buildAuthStatus(authRecord, authRoot) {
+    if (!authRecord.profile) {
+        return {
+            authRoot,
+            currentProfilePath: authRecord.currentProfilePath,
+            expiresInSeconds: null,
+            profile: null,
+            profilePath: authRecord.profilePath,
+            status: "missing",
+        };
+    }
+    const profile = sanitizeAuthProfile(authRecord.profile);
+    const expiresAtMs = Date.parse(profile.expiresAt);
+    const expiresInSeconds = Number.isNaN(expiresAtMs)
+        ? null
+        : Math.max(Math.floor((expiresAtMs - Date.now()) / 1000), 0);
+    return {
+        authRoot,
+        currentProfilePath: authRecord.currentProfilePath,
+        expiresInSeconds,
+        profile,
+        profilePath: authRecord.profilePath,
+        status: expiresInSeconds === 0 ? "expired" : "active",
+    };
+}
+function buildBindingStatus(bindingPath, binding, activeAuthProfile) {
+    return {
+        binding,
+        exists: binding !== null,
+        matchesActiveAuthProfile: binding && activeAuthProfile ? binding.authProfileId === activeAuthProfile.id : null,
+        path: bindingPath,
+        status: binding ? "linked" : "missing",
+    };
+}
+function buildPlatformMismatchDiagnostics(activeAuthProfile, resolvedWorkspaceCliConfig) {
+    if (!activeAuthProfile) {
+        return [];
+    }
+    const normalizedAuthPlatformBaseUrl = activeAuthProfile.platformBaseUrl.replace(/\/+$/, "");
+    if (normalizedAuthPlatformBaseUrl === resolvedWorkspaceCliConfig.platformBaseUrl) {
+        return [];
+    }
+    return [
+        {
+            action: buildPlatformMismatchAction(resolvedWorkspaceCliConfig),
+            code: "workspace.auth.platform_mismatch",
+            detail: `The active CLI auth profile targets ${normalizedAuthPlatformBaseUrl}, but this workspace resolves the CLI platform from ${describeResolvedPlatformSource(resolvedWorkspaceCliConfig)} as ${resolvedWorkspaceCliConfig.platformBaseUrl}.`,
+            severity: "warning",
+            summary: "Active CLI auth profile targets a different platform.",
+        },
+    ];
+}
+function buildPreviewDeployTargetStatus(options) {
+    const previewUrl = normalizeOptionalString(options.previewState?.currentPreviewUrl);
+    const lastTerminalReceipt = options.previewState?.lastTerminalReceipt ?? null;
+    if (!options.binding) {
+        return {
+            canonicalPath: options.context.previewDeployStatePath,
+            compiledRelease: null,
+            currentPreviewUrl: previewUrl,
+            currentTarget: options.currentTarget,
+            detail: "Preview deploy status is unavailable until the workspace is linked to a tenant and published-site property.",
+            environment: "preview",
+            lastRequestedAt: null,
+            lastRequestedReceiptId: null,
+            lastRequestedReleaseKey: null,
+            lastTerminalReceipt,
+            propertyKey: null,
+            prerequisiteCodes: options.prerequisiteCodes,
+            releaseClass: null,
+            status: "blocked",
+        };
+    }
+    if (!options.compiledRelease) {
+        return {
+            canonicalPath: options.context.previewDeployStatePath,
+            compiledRelease: null,
+            currentPreviewUrl: previewUrl,
+            currentTarget: options.currentTarget,
+            detail: "The linked preview target does not have current hosted release metadata. Re-run `minutework compile` after confirming tenant-app preview env defaults.",
+            environment: "preview",
+            lastRequestedAt: options.previewState?.lastRequestedAt ?? null,
+            lastRequestedReceiptId: options.previewState?.lastRequestedReceiptId ?? null,
+            lastRequestedReleaseKey: options.previewState?.lastRequestedReleaseKey ?? null,
+            lastTerminalReceipt,
+            propertyKey: options.binding.propertyKey,
+            prerequisiteCodes: options.prerequisiteCodes,
+            releaseClass: options.binding.releaseClass,
+            status: "blocked",
+        };
+    }
+    if (lastTerminalReceipt?.deploymentState === "activated" && previewUrl) {
+        return {
+            canonicalPath: options.context.previewDeployStatePath,
+            compiledRelease: options.compiledRelease,
+            currentPreviewUrl: previewUrl,
+            currentTarget: options.currentTarget,
+            detail: "The linked preview target has a recorded activated deploy and a current preview URL.",
+            environment: "preview",
+            lastRequestedAt: options.previewState?.lastRequestedAt ?? null,
+            lastRequestedReceiptId: options.previewState?.lastRequestedReceiptId ?? null,
+            lastRequestedReleaseKey: options.previewState?.lastRequestedReleaseKey ?? null,
+            lastTerminalReceipt,
+            propertyKey: options.binding.propertyKey,
+            prerequisiteCodes: options.prerequisiteCodes,
+            releaseClass: options.binding.releaseClass,
+            status: "deployed",
+        };
+    }
+    if (lastTerminalReceipt?.deploymentState === "failed" ||
+        lastTerminalReceipt?.deploymentState === "rolled_back") {
+        return {
+            canonicalPath: options.context.previewDeployStatePath,
+            compiledRelease: options.compiledRelease,
+            currentPreviewUrl: previewUrl,
+            currentTarget: options.currentTarget,
+            detail: lastTerminalReceipt.deploymentState === "rolled_back"
+                ? "The last recorded preview deploy rolled back to the previous preview target."
+                : "The last recorded preview deploy failed.",
+            environment: "preview",
+            lastRequestedAt: options.previewState?.lastRequestedAt ?? null,
+            lastRequestedReceiptId: options.previewState?.lastRequestedReceiptId ?? null,
+            lastRequestedReleaseKey: options.previewState?.lastRequestedReleaseKey ?? null,
+            lastTerminalReceipt,
+            propertyKey: options.binding.propertyKey,
+            prerequisiteCodes: options.prerequisiteCodes,
+            releaseClass: options.binding.releaseClass,
+            status: "failed",
+        };
+    }
+    return {
+        canonicalPath: options.context.previewDeployStatePath,
+        compiledRelease: options.compiledRelease,
+        currentPreviewUrl: previewUrl,
+        currentTarget: options.currentTarget,
+        detail: options.context.previewDeployStateCorrupted
+            ? "The preview target is configured, but the persisted preview deploy state is malformed. The next deploy will replace it."
+            : options.previewState?.lastRequestedReceiptId
+                ? "The preview target is configured and has recorded deploy history."
+                : "The preview target is configured and ready for `minutework deploy --preview`.",
+        environment: "preview",
+        lastRequestedAt: options.previewState?.lastRequestedAt ?? null,
+        lastRequestedReceiptId: options.previewState?.lastRequestedReceiptId ?? null,
+        lastRequestedReleaseKey: options.previewState?.lastRequestedReleaseKey ?? null,
+        lastTerminalReceipt,
+        propertyKey: options.binding.propertyKey,
+        prerequisiteCodes: options.prerequisiteCodes,
+        releaseClass: options.binding.releaseClass,
+        status: "ready",
+    };
+}
+function buildLiveDeployTargetStatus(context, currentTarget) {
+    return {
+        canonicalPath: path.join(context.workspaceRoot, context.config.localState.directory, "deploy", "live"),
+        compiledRelease: null,
+        currentPreviewUrl: null,
+        currentTarget,
+        detail: "`minutework deploy --live` remains intentionally blocked for the external alpha.",
+        environment: "live",
+        lastRequestedAt: null,
+        lastRequestedReceiptId: null,
+        lastRequestedReleaseKey: null,
+        lastTerminalReceipt: null,
+        propertyKey: context.bindingStatus.binding?.propertyKey ?? null,
+        prerequisiteCodes: ["workspace.deploy.live_unsupported"],
+        releaseClass: context.bindingStatus.binding?.releaseClass ?? null,
+        status: "unsupported",
+    };
+}
+function collectDeployPrerequisiteCodes(options) {
+    const codes = [...collectPrerequisiteCodes(options.context)];
+    if (options.binding && !options.compiledRelease) {
+        codes.push("workspace.deploy.release_metadata_missing");
+    }
+    if (options.context.previewDeployStateCorrupted) {
+        codes.push("workspace.deploy.preview_state_corrupted");
+    }
+    return Array.from(new Set(codes));
+}
+function resolveCompiledPreviewReleaseMetadata(compileGraph, propertyKey) {
+    if (!compileGraph || !propertyKey) {
+        return null;
+    }
+    for (const document of compileGraph.documents.releaseMetadata) {
+        const parsed = HostedPreviewReleaseMetadataSchema.safeParse(document);
+        if (parsed.success && parsed.data.propertyKey === propertyKey) {
+            return mapCompiledRelease(parsed.data);
+        }
+    }
+    return null;
+}
+function mapCompiledRelease(metadata) {
+    return {
+        releaseDigest: metadata.releaseDigest,
+        releaseKey: metadata.releaseKey,
+        runtimeContentRef: metadata.runtimeContentRef,
+        sourceDigest: metadata.sourceDigest,
+        starterId: metadata.starterId,
+        workspaceName: metadata.workspaceName,
+    };
+}
+function resolvePreviewDeployStateForBinding(previewDeployState, binding) {
+    if (!previewDeployState || !binding) {
+        return null;
+    }
+    if (previewDeployState.propertyKey !== binding.propertyKey ||
+        previewDeployState.releaseClass !== binding.releaseClass) {
+        return null;
+    }
+    return previewDeployState;
+}
+function normalizeOptionalString(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildDiagnostics(options) {
+    const diagnostics = [];
+    if (!options.cursorConfigExists) {
+        diagnostics.push({
+            action: "Restore `.cursor/mcp.json` or run `minutework workspace sync-assets` for this workspace.",
+            code: "workspace.mcp.cursor_config_missing",
+            detail: "Cursor MCP wiring is missing from the generated workspace contract.",
+            path: options.cursorConfigPath,
+            severity: "warning",
+            summary: "Cursor MCP config is missing.",
+        });
+    }
+    if (!options.claudeDesktopSampleExists) {
+        diagnostics.push({
+            action: "Restore `mcp/claude-desktop.sample.json` or run `minutework workspace sync-assets` for this workspace.",
+            code: "workspace.mcp.claude_sample_missing",
+            detail: "The generated Claude Desktop MCP sample file is missing.",
+            path: options.claudeDesktopSamplePath,
+            severity: "warning",
+            summary: "Claude Desktop MCP sample is missing.",
+        });
+    }
+    if (options.bindingStatus.status === "missing" && !options.bindingStateMalformed) {
+        diagnostics.push({
+            action: "Run `minutework link` from the workspace root.",
+            code: "workspace.binding.missing",
+            detail: "The repo-local binding file does not exist yet.",
+            path: options.bindingStatus.path,
+            severity: "warning",
+            summary: "Workspace is not linked.",
+        });
+    }
+    if (options.authStatus.status === "missing" && !options.authStateMalformed) {
+        diagnostics.push({
+            action: "Run `minutework login` on this machine.",
+            code: "workspace.auth.missing",
+            detail: "No active machine-local CLI auth profile is available.",
+            path: options.authStatus.currentProfilePath,
+            severity: "warning",
+            summary: "No active CLI auth profile.",
+        });
+    }
+    if (options.authStatus.status === "expired") {
+        diagnostics.push({
+            action: "Run `minutework login` to refresh the local auth profile.",
+            code: "workspace.auth.expired",
+            detail: "The active CLI auth profile is present but expired.",
+            path: options.authStatus.profilePath ?? options.authStatus.currentProfilePath,
+            severity: "warning",
+            summary: "Active CLI auth profile is expired.",
+        });
+    }
+    if (options.bindingStatus.status === "linked" &&
+        options.authStatus.profile &&
+        options.bindingStatus.matchesActiveAuthProfile === false) {
+        diagnostics.push({
+            action: "Run `minutework link` or switch the active CLI auth profile.",
+            code: "workspace.auth.binding_mismatch",
+            detail: "The repo binding points at a different auth profile than the current active CLI profile.",
+            path: options.bindingStatus.path,
+            severity: "warning",
+            summary: "Binding and active auth profile do not match.",
+        });
+    }
+    if (!options.schemaDirectoryExists && !options.schemaMwExists) {
+        diagnostics.push({
+            action: "Create the schema directory, add a root `schema.mw`, or update `minutework.config.ts`.",
+            code: "workspace.schema.directory_missing",
+            detail: "The configured schema directory does not exist and no root schema.mw alternative was found.",
+            path: options.schemaDirectoryPath,
+            severity: "warning",
+            summary: "Schema directory is missing.",
+        });
+    }
+    if (!options.schemaEntrypointExists && !options.schemaMwExists) {
+        diagnostics.push({
+            action: "Create the configured schema entrypoint, create a root `schema.mw`, or update `minutework.config.ts`.",
+            code: "workspace.schema.entrypoint_missing",
+            detail: "Neither the configured schema entrypoint nor a root schema.mw file exists for this workspace.",
+            path: options.schemaEntrypointPath,
+            severity: "warning",
+            summary: "No supported schema authoring input is present.",
+        });
+    }
+    if (options.persistedCompileGraphCorrupted) {
+        diagnostics.push({
+            action: "Delete the malformed compile graph or rerun `minutework compile` to regenerate it.",
+            code: "workspace.schema.compile_graph_corrupted",
+            detail: "The on-disk compile graph exists but could not be parsed.",
+            severity: "warning",
+            summary: "Compile graph artifact is corrupted.",
+        });
+    }
+    return diagnostics;
+}
+function buildRecommendedActions(diagnostics) {
+    const actions = new Set();
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.code === "workspace.auth.missing" ||
+            diagnostic.code === "workspace.auth.expired" ||
+            diagnostic.code === "workspace.auth.pointer_malformed" ||
+            diagnostic.code === "workspace.auth.profile_malformed") {
+            actions.add("Run `minutework login` to refresh the machine-local auth profile.");
+            continue;
+        }
+        if (diagnostic.code === "workspace.binding.missing" || diagnostic.code === "workspace.binding.malformed") {
+            actions.add("Run `minutework link` to bind this repo to the active tenant/environment.");
+            continue;
+        }
+        if (diagnostic.code === "workspace.schema.directory_missing" ||
+            diagnostic.code === "workspace.schema.entrypoint_missing") {
+            actions.add("Create the configured schema files, add a root `schema.mw`, or update `minutework.config.ts`.");
+            continue;
+        }
+        if (diagnostic.code === "workspace.mcp.cursor_config_missing" ||
+            diagnostic.code === "workspace.mcp.claude_sample_missing") {
+            actions.add("Restore the generated MCP wiring files with `minutework workspace sync-assets`.");
+            continue;
+        }
+        if (diagnostic.code === "workspace.auth.binding_mismatch") {
+            actions.add("Align the active CLI auth profile with the repo binding via `minutework link`.");
+            continue;
+        }
+        if (diagnostic.code === "workspace.auth.platform_mismatch") {
+            actions.add("Run `minutework login` for the wired workspace platform, or remove any legacy platform override.");
+            continue;
+        }
+        if (diagnostic.code === "workspace.schema.compile_graph_corrupted") {
+            actions.add("Delete the malformed compile graph or rerun `minutework compile` to regenerate it.");
+            continue;
+        }
+        if (diagnostic.code === "compiler.input.conflict") {
+            actions.add("Remove either the configured TypeScript schema entrypoint or the root `schema.mw` file so the workspace has exactly one schema input.");
+            continue;
+        }
+        if (diagnostic.code === "compiler.input.missing") {
+            actions.add("Create the configured schema files, add a root `schema.mw`, or update `minutework.config.ts`.");
+            continue;
+        }
+        if (diagnostic.code === "compiler.source.export_missing" ||
+            diagnostic.code === "compiler.source.invalid" ||
+            diagnostic.code === "compiler.source.load_failed" ||
+            diagnostic.code === "compiler.source.parse_failed" ||
+            diagnostic.code === "compiler.schema.duplicate_key") {
+            actions.add("Fix the local schema authoring source until `minutework validate` succeeds.");
+            continue;
+        }
+        if (diagnostic.code.startsWith("compiler.")) {
+            actions.add("Fix the local schema authoring source until `minutework validate` succeeds.");
+        }
+    }
+    return [...actions];
+}
+function buildCapabilityInventoryAuthDetail(context) {
+    if (context.authStatus.status === "active" && context.bindingStatus.status === "linked") {
+        return "CLI auth and repo binding are both present, so generated-workspace preview/publication context can be evaluated for this tenant/property pair.";
+    }
+    if (context.authStatus.status !== "active" && context.bindingStatus.status !== "linked") {
+        return "The generated workspace is not authenticated or linked yet, so tenant-scoped runtime/publication state remains partially unknown.";
+    }
+    if (context.authStatus.status !== "active") {
+        return "Repo binding exists, but the current machine-local CLI auth profile is missing or expired.";
+    }
+    return "CLI auth exists, but the repo-local binding is missing or malformed.";
+}
+function buildCapabilityGapReportContract(context) {
+    if (context.capabilityGapReportCorrupted) {
+        return {
+            canonicalPath: context.capabilityGapReportPath,
+            detail: "A capability gap report file exists, but it is malformed. Repair or remove it before relying on it as structured architecture evidence.",
+            fileStatus: "corrupted",
+            gapCount: null,
+            layerValues: [...CapabilityGapLayerSchema.options],
+            reusabilityValues: [...CapabilityGapReusabilitySchema.options],
+            version: "MinuteWorkCapabilityGapReportV1",
+        };
+    }
+    if (context.capabilityGapReport) {
+        return {
+            canonicalPath: context.capabilityGapReportPath,
+            detail: "A structured capability gap report is already recorded for this workspace and can be extended with new reusable-substrate gaps.",
+            fileStatus: "available",
+            gapCount: context.capabilityGapReport.gaps.length,
+            layerValues: [...CapabilityGapLayerSchema.options],
+            reusabilityValues: [...CapabilityGapReusabilitySchema.options],
+            version: "MinuteWorkCapabilityGapReportV1",
+        };
+    }
+    return {
+        canonicalPath: context.capabilityGapReportPath,
+        detail: "No capability gap report has been recorded yet. Use this file to capture sanitized, reusable-substrate gaps discovered during early tenant builds.",
+        fileStatus: "missing",
+        gapCount: null,
+        layerValues: [...CapabilityGapLayerSchema.options],
+        reusabilityValues: [...CapabilityGapReusabilitySchema.options],
+        version: "MinuteWorkCapabilityGapReportV1",
+    };
+}
+function buildCapabilityInventoryUnknowns(context) {
+    const unknowns = [
+        {
+            detail: "Generated workspaces do not expose a live runtime descriptor or capability registry yet.",
+            id: "runtime_descriptor",
+            nextCheck: "Use a linked runtime-capability surface when one exists; until then, treat live runtime descriptor state as unknown.",
+        },
+        {
+            detail: "Installed runtime app-pack, skill, and sidecar activation state is not directly visible from workspace MCP today.",
+            id: "runtime_installed_state",
+            nextCheck: "Treat the compile graph as local desired-state inventory and verify installed state through linked runtime surfaces or human confirmation.",
+        },
+        {
+            detail: "Provider-specific runtime AI readiness and secret-backed service availability are not directly inspectable from the generated workspace.",
+            id: "runtime_provider_readiness",
+            nextCheck: "Inspect linked runtime/provider surfaces or confirm with an operator before inventing new provider infrastructure.",
+        },
+    ];
+    if (context.authStatus.status !== "active" || context.bindingStatus.status !== "linked") {
+        unknowns.push({
+            detail: "Because auth or repo binding is incomplete, the workspace cannot confidently resolve tenant-scoped runtime/publication state.",
+            id: "linked_tenant_runtime",
+            nextCheck: "Run `minutework login` and `minutework link`, then refresh the capability inventory.",
+        });
+    }
+    return unknowns;
+}
+function buildCapabilityInventoryRecommendedChecks(context, localRuntimeStatus, unknowns) {
+    const checks = new Set();
+    if (context.authStatus.status !== "active") {
+        checks.add("Run `minutework login` to refresh the machine-local auth profile.");
+    }
+    if (context.bindingStatus.status !== "linked") {
+        checks.add("Run `minutework link` to bind this repo to the active tenant/environment.");
+    }
+    if (!context.persistedCompileGraphCurrent) {
+        checks.add("Run `minutework compile` to refresh the authoritative local compile graph.");
+    }
+    if (context.persistedCompileGraphCurrent &&
+        (!context.persistedOpenapiCurrent || !context.persistedClientTypesCurrent)) {
+        checks.add("Run `minutework codegen` to refresh deterministic OpenAPI and client-type artifacts.");
+    }
+    if (localRuntimeStatus.surfaces.some((surface) => surface.status === "missing")) {
+        checks.add("Restore the missing starter paths or scaffold a fresh workspace before relying on local sandbox surfaces.");
+    }
+    if (context.capabilityGapReportCorrupted) {
+        checks.add("Repair or remove the malformed capability gap report before extending it.");
+    }
+    if (unknowns.length > 0) {
+        checks.add("Treat live runtime descriptor/provider state as unknown until a linked runtime-capability surface exposes it.");
+    }
+    checks.add("If runtime/platform/gateway source trees are available locally, inspect them directly for implemented capability inventory before inventing new substrate.");
+    checks.add("Use `minutework_capability_inventory` plus the more specific workspace MCP tools before assuming runtime capability coverage.");
+    return [...checks];
+}
+function collectDoctorDiagnostics(context) {
+    return [
+        ...context.diagnostics,
+        ...context.compilerAnalysis.validateReport.diagnostics.map((diagnostic) => buildCompilerDiagnostic(context, diagnostic)),
+    ];
+}
+function buildCompilerDiagnostic(context, diagnostic) {
+    return {
+        action: undefined,
+        code: diagnostic.code,
+        detail: diagnostic.detail,
+        path: diagnostic.path ? path.join(context.workspaceRoot, diagnostic.path) : undefined,
+        severity: diagnostic.severity,
+        summary: diagnostic.summary,
+    };
+}
+function buildStarter(id, context) {
+    const starter = buildNormalizedStarterConfig(id, context);
+    return {
+        ...starter,
+        id,
+    };
+}
+function buildNormalizedStarterConfig(id, context) {
+    const starter = id === "tenant-app" ? context.config.starters.tenantApp : context.config.starters.sidecar;
+    return {
+        absolutePath: path.join(context.workspaceRoot, starter.path),
+        enabled: starter.enabled,
+        path: starter.path,
+    };
+}
+function collectPrerequisiteCodes(context) {
+    return [
+        ...context.diagnostics.filter((item) => item.severity !== "info").map((item) => item.code),
+        ...context.compilerAnalysis.validateReport.diagnostics
+            .filter((item) => item.severity !== "info")
+            .map((item) => item.code),
+    ];
+}
+function collectSchemaPrerequisiteCodes(context) {
+    return [
+        ...context.diagnostics
+            .filter((item) => item.severity !== "info" && item.code.startsWith("workspace.schema."))
+            .map((item) => item.code),
+        ...context.compilerAnalysis.validateReport.diagnostics
+            .filter((item) => item.severity !== "info")
+            .map((item) => item.code),
+    ];
+}
+function describeResolvedPlatformSource(resolvedWorkspaceCliConfig) {
+    switch (resolvedWorkspaceCliConfig.platformBaseUrlSource) {
+        case "shellEnv":
+            return "exported shell env MW_CLI_PLATFORM_BASE_URL";
+        case "workspaceConfig":
+            return "minutework.config.ts";
+        case "workspaceDefault":
+            return "the MinuteWork local platform wiring";
+        default:
+            return "the workspace";
+    }
+}
+function buildPlatformMismatchAction(resolvedWorkspaceCliConfig) {
+    return resolvedWorkspaceCliConfig.hasLegacyPlatformOverride
+        ? `Run \`minutework login --platform ${resolvedWorkspaceCliConfig.platformBaseUrl}\` or remove the legacy platform override.`
+        : "Run `minutework login` to refresh auth for the wired workspace platform.";
+}
+async function exists(targetPath) {
+    try {
+        await fs.stat(targetPath);
+        return true;
+    }
+    catch (error) {
+        const errno = error;
+        if (errno.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function loadWorkspaceConfig(configPath) {
+    try {
+        return await loadSharedWorkspaceConfig(configPath);
+    }
+    catch (error) {
+        throw new WorkspaceMcpError(`MinuteWork config could not be loaded from ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function loadCurrentAuthProfile(paths) {
+    const diagnostics = [];
+    const currentProfilePath = path.join(paths.authRoot, "current-profile.json");
+    if (!(await exists(currentProfilePath))) {
+        return {
+            currentProfilePath,
+            diagnostics,
+            profile: null,
+            profilePath: null,
+        };
+    }
+    let pointer;
+    try {
+        pointer = await readJsonFile(currentProfilePath, z.object({
+            profileId: z.string().min(1),
+            platformBaseUrl: z.string().optional(),
+        }), "CLI auth profile pointer");
+    }
+    catch (error) {
+        if (error instanceof WorkspaceMcpError) {
+            diagnostics.push({
+                action: "Run `minutework login` to recreate the active CLI auth profile.",
+                code: "workspace.auth.pointer_malformed",
+                detail: error.message,
+                path: currentProfilePath,
+                severity: "warning",
+                summary: "CLI auth profile pointer is malformed.",
+            });
+            return {
+                currentProfilePath,
+                diagnostics,
+                profile: null,
+                profilePath: null,
+            };
+        }
+        throw error;
+    }
+    const profilePath = path.join(paths.authRoot, `${pointer.profileId}.json`);
+    if (!(await exists(profilePath))) {
+        return {
+            currentProfilePath,
+            diagnostics,
+            profile: null,
+            profilePath,
+        };
+    }
+    try {
+        const profile = await readJsonFile(profilePath, StoredAuthProfileSchema, "CLI auth profile");
+        return {
+            currentProfilePath,
+            diagnostics,
+            profile,
+            profilePath,
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceMcpError) {
+            diagnostics.push({
+                action: "Run `minutework login` to refresh the malformed CLI auth profile.",
+                code: "workspace.auth.profile_malformed",
+                detail: error.message,
+                path: profilePath,
+                severity: "warning",
+                summary: "CLI auth profile is malformed.",
+            });
+            return {
+                currentProfilePath,
+                diagnostics,
+                profile: null,
+                profilePath,
+            };
+        }
+        throw error;
+    }
+}
+async function readJsonFile(targetPath, schema, label) {
+    let raw;
+    try {
+        raw = await fs.readFile(targetPath, "utf8");
+    }
+    catch (error) {
+        const errno = error;
+        if (errno.code === "ENOENT") {
+            throw new WorkspaceMcpError(`${label} is missing at ${targetPath}.`);
+        }
+        throw error;
+    }
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new WorkspaceMcpError(`${label} is malformed at ${targetPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const parsed = schema.safeParse(parsedJson);
+    if (!parsed.success) {
+        throw new WorkspaceMcpError(`${label} is malformed at ${targetPath}: ${parsed.error.issues[0]?.message ?? "unknown error"}`);
+    }
+    return parsed.data;
+}
+async function readOptionalWorkspaceBinding(targetPath) {
+    if (!(await exists(targetPath))) {
+        return {
+            binding: null,
+            diagnostics: [],
+        };
+    }
+    try {
+        return {
+            binding: await readJsonFile(targetPath, BindingPayloadSchema, "workspace binding"),
+            diagnostics: [],
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceMcpError) {
+            return {
+                binding: null,
+                diagnostics: [
+                    {
+                        action: "Run `minutework link` to recreate the repo-local binding.",
+                        code: "workspace.binding.malformed",
+                        detail: error.message,
+                        path: targetPath,
+                        severity: "warning",
+                        summary: "Workspace binding is malformed.",
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
+}
+async function readOptionalPreviewDeployState(targetPath) {
+    if (!(await exists(targetPath))) {
+        return {
+            corrupted: false,
+            state: null,
+        };
+    }
+    try {
+        return {
+            corrupted: false,
+            state: await readJsonFile(targetPath, PreviewDeployStateSchema, "preview deploy state"),
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceMcpError) {
+            return {
+                corrupted: true,
+                state: null,
+            };
+        }
+        throw error;
+    }
+}
+async function readOptionalCapabilityGapReport(targetPath) {
+    if (!(await exists(targetPath))) {
+        return {
+            corrupted: false,
+            report: null,
+        };
+    }
+    try {
+        return {
+            corrupted: false,
+            report: await readJsonFile(targetPath, CapabilityGapReportSchema, "capability gap report"),
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceMcpError) {
+            return {
+                corrupted: true,
+                report: null,
+            };
+        }
+        throw error;
+    }
+}
+async function readOptionalCompileGraph(targetPath) {
+    try {
+        const raw = await fs.readFile(targetPath, "utf8");
+        return {
+            corrupted: false,
+            digest: createSha256Digest(raw),
+            graph: CompileGraphSchema.parse(JSON.parse(raw)),
+        };
+    }
+    catch (error) {
+        if (error instanceof WorkspaceMcpError) {
+            return {
+                corrupted: true,
+                digest: null,
+                graph: null,
+            };
+        }
+        if (error instanceof z.ZodError || error instanceof SyntaxError) {
+            return {
+                corrupted: true,
+                digest: null,
+                graph: null,
+            };
+        }
+        throw error;
+    }
+}
+function isPersistedCompileGraphCurrent(persistedGraph, staticAnalysis) {
+    if (!persistedGraph || !staticAnalysis.selectedInput) {
+        return false;
+    }
+    return (persistedGraph.sources.config.sha256 === staticAnalysis.configDigest &&
+        persistedGraph.sources.selectedInput.kind === staticAnalysis.selectedInput.kind &&
+        persistedGraph.sources.selectedInput.path === staticAnalysis.selectedInput.path &&
+        persistedGraph.sources.selectedInput.sha256 === staticAnalysis.selectedInput.sha256);
+}
+async function inspectGeneratedJsonArtifact(targetPath, expectedContents) {
+    if (!(await exists(targetPath))) {
+        return {
+            corrupted: false,
+            current: false,
+        };
+    }
+    const raw = await fs.readFile(targetPath, "utf8");
+    try {
+        JSON.parse(raw);
+    }
+    catch {
+        return {
+            corrupted: true,
+            current: false,
+        };
+    }
+    return {
+        corrupted: false,
+        current: expectedContents !== null && raw === expectedContents,
+    };
+}
+async function inspectGeneratedTextArtifact(targetPath, expectedContents) {
+    if (!(await exists(targetPath))) {
+        return {
+            current: false,
+        };
+    }
+    const raw = await fs.readFile(targetPath, "utf8");
+    return {
+        current: expectedContents !== null && raw === expectedContents,
+    };
+}
+function formatJson(payload) {
+    return `${JSON.stringify(payload, null, 2)}\n`;
+}
+function resolveCliStatePaths(options) {
+    const env = options?.env ?? process.env;
+    const platform = options?.platform ?? process.platform;
+    const home = env.HOME ?? env.USERPROFILE ?? "";
+    const localAppData = env.LOCALAPPDATA ?? "";
+    let minuteworkHome;
+    if (platform === "darwin") {
+        minuteworkHome = path.posix.join(home || "~", "Library", "Application Support", "MinuteWork");
+    }
+    else if (platform === "linux") {
+        minuteworkHome = path.posix.join(home || "~", ".local", "share", "minutework");
+    }
+    else if (platform === "win32") {
+        const windowsBase = localAppData ||
+            (home ? path.win32.join(home, "AppData", "Local") : path.win32.join("~", "AppData", "Local"));
+        minuteworkHome = path.win32.join(windowsBase, "MinuteWork");
+    }
+    else {
+        throw new WorkspaceMcpError(`Unsupported platform for MinuteWork CLI state: ${platform}`);
+    }
+    return {
+        authRoot: joinForPlatform(platform, minuteworkHome, "cli", "auth"),
+    };
+}
+async function resolveWorkspaceRoot(options) {
+    const startPath = options.workspacePath
+        ? path.resolve(options.cwd, options.workspacePath)
+        : path.resolve(options.cwd);
+    try {
+        return await discoverCompilerWorkspaceRoot(startPath);
+    }
+    catch (error) {
+        throw new WorkspaceMcpError(error instanceof Error ? error.message : "No MinuteWork workspace was found from the current directory upward.");
+    }
+}
+function sanitizeAuthProfile(profile) {
+    return {
+        createdAt: profile.createdAt,
+        expiresAt: profile.expiresAt,
+        id: profile.id,
+        platformBaseUrl: profile.platformBaseUrl,
+        scopeTemplate: profile.scopeTemplate,
+        scopes: profile.scopes,
+        tenantId: profile.tenantId,
+        tenantName: profile.tenantName,
+        tenantSlug: profile.tenantSlug,
+        tokenKind: profile.tokenKind,
+        user: profile.user,
+    };
+}
+function joinForPlatform(platform, root, ...segments) {
+    return platform === "win32" ? path.win32.join(root, ...segments) : path.posix.join(root, ...segments);
+}
+//# sourceMappingURL=context.js.map