@skillcap/gdh 0.22.0 → 0.24.0

package/node_modules/@gdh/cli/dist/index.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildGdhStatusResult, CLAUDE_CHECK_SKILL_RELATIVE_PATH, CLAUDE_CHECK_UPDATE_HOOK_RELATIVE_PATH, CLAUDE_MIGRATE_SKILL_RELATIVE_PATH, CLAUDE_ONBOARD_SKILL_RELATIVE_PATH, CLAUDE_PREPARE_SKILL_RELATIVE_PATH, CLAUDE_SCAN_SKILL_RELATIVE_PATH, CLAUDE_STATUS_SKILL_RELATIVE_PATH, CODEX_CHECK_SKILL_RELATIVE_PATH, CODEX_MIGRATE_SKILL_RELATIVE_PATH, CODEX_ONBOARD_SKILL_RELATIVE_PATH, CODEX_PREPARE_SKILL_RELATIVE_PATH, CODEX_SCAN_SKILL_RELATIVE_PATH, CODEX_STATUS_SKILL_RELATIVE_PATH, CURSOR_CHECK_SKILL_RELATIVE_PATH, CURSOR_MIGRATE_SKILL_RELATIVE_PATH, CURSOR_ONBOARD_SKILL_RELATIVE_PATH, CURSOR_PREPARE_SKILL_RELATIVE_PATH, CURSOR_SCAN_SKILL_RELATIVE_PATH, CURSOR_STATUS_SKILL_RELATIVE_PATH, createGsdSnapshot, getSupportedAgentAdaptersStatus, installSupportedAgentAdapters, } from "@gdh/adapters";
-import { checkManagedLsp, doctorManagedLsp, getManagedLspStatus, hasCompleteOnboardingSurface, inspectCacheState, pruneCacheState, pruneManagedLsp, readProjectConfig, readWorktreeState, resolveAuthoringStatus, resolveEffectiveTargetPath, resolvePinnedVersion, resolveProjectRoot, resolveTargetGodotDocsVersion, restartManagedLsp, runAuthoringCheck, runImportRefresh, runTargetPrepare, runWarmup, stopManagedLsp, } from "@gdh/authoring";
+import { checkManagedLsp, doctorAuthoringDiagnostics, doctorManagedLsp, getAuthoringDiagnosticsStatus, getCurrentAuthoringDiagnostics, getManagedLspStatus, hasCompleteOnboardingSurface, inspectCacheState, pruneCacheState, pruneAuthoringDiagnostics, pruneManagedLsp, readProjectConfig, readWorktreeState, refreshAuthoringDiagnostics, resolveAuthoringStatus, resolveEffectiveTargetPath, resolvePinnedVersion, resolveProjectRoot, resolveTargetGodotDocsVersion, restartManagedLsp, runAuthoringCheck, runImportRefresh, runTargetPrepare, runWarmup, stopManagedLsp, } from "@gdh/authoring";
 import { definePackageBoundary, GDH_AUTHORING_DOGFOOD_VERSION, GDH_AUTHORING_SLICE_REPORT_VERSION, GDH_PRODUCT_NAME, resolveCurrentGdhInstall, resolveGdhProductMetadata, } from "@gdh/core";
 import { fetchOfficialGodotDoc, getGuidanceStatus, resolveGuidanceQuery, searchOfficialGodotDocs, } from "@gdh/docs";
 import { createMcpManifest, invokeMcpTool, serveMcpOverStdio } from "@gdh/mcp";
@@ -13,11 +13,21 @@ import { inspectAuthoringEffectiveness, inspectAuthoringSessions, inspectGuidanc
 import { checkRuntimeRecipe, createRuntimeBridgeManager, serveRuntimeBridgeBroker, inspectRuntimeBridgeSurface, installRuntimeBridgeSurface, listRuntimeRecipes, removeRuntimeBridgeSurface, repairRuntimeBridgeSurface, runRuntimeRecipe, showRuntimeRecipe, } from "@gdh/runtime";
 import { applyRepairableOnboardingWrites, onboardGodotProject, persistInventoryForTarget, readInventoryCacheOrScan, scanGodotProjectInventory, } from "@gdh/scan";
 import { exerciseRuntimeCorpusEntry, inspectRuntimeCorpusStatus, inspectRuntimeVerificationBundleState, inspectRuntimeVerificationReadiness, listRuntimeScenarios, materializeRuntimeCorpusEntry, recordRuntimeCorpusValidation, runRuntimeVerificationScenario, showRuntimeScenario, } from "@gdh/verify";
-import { migrateProjectLifecycleSurface } from "./migrate.js";
+import { clearEnvelope, clearMigrationBackups, migrateProjectLifecycleSurface, recordEnvelopeResult, } from "./migrate.js";
 import { runBridgeSessionCommand } from "./bridge-session.js";
 import { cleanupGdhMcpProcesses } from "./mcp-cleanup.js";
 import { presentPublicRuntimeTerms } from "./public-terms.js";
-import { runSelfUpdateCommand } from "./self-update.js";
+import { runSelfUpdateCommand as runSelfUpdateCommandImpl } from "./self-update.js";
+/**
+ * Re-export of `runSelfUpdateCommand` so the integration test in
+ * `packages/cli/src/self-update.integration.test.ts` (Plan 73-06) can drive
+ * the dispatcher directly without depending on the self-update module's
+ * surface evolving. The implementation lives in `./self-update.js`; this
+ * is a thin pass-through that preserves identical signature and behavior.
+ */
+export async function runSelfUpdateCommand(args, io) {
+    return runSelfUpdateCommandImpl(args, io);
+}
 import { executeSetupCommand, isSetupCanceledError, renderDurableTruthCollisionHint, renderSetupIntro, renderSetupOutro, renderSetupSummary, } from "./setup.js";
 import { emitUpdateBannerIfStale } from "./update-banner.js";
 export const cliPackage = definePackageBoundary({
@@ -124,6 +134,9 @@ export async function runCli(args, io = { stdout: process.stdout, stderr: proces
     if (command === "migrate") {
         return runMigrateCommand(rest, io);
     }
+    if (command === "migration") {
+        return runMigrationCommand(rest, io);
+    }
     if (command === "self-update") {
         return runSelfUpdateCommand(rest, io);
     }
@@ -507,16 +520,191 @@ async function runAuthoringCommand(args, io) {
             "Usage: gdh authoring <command> [target]",
             "",
             "Commands:",
-            "  check [target]  Run the current authoring-check entrypoint and print a structured result.",
+            "  check [target]        Run the current authoring-check entrypoint and print a structured result.",
+            "  diagnostics <command> Inspect current Godot authoring diagnostics snapshots.",
         ].join("\n") + "\n");
         return 0;
     }
     if (subcommand === "check") {
         return runAuthoringCheckCommand(rest, io);
     }
-    io.stderr.write(`Unknown authoring command: ${subcommand}\n\nUsage: gdh authoring check [target]\n`);
+    if (subcommand === "diagnostics") {
+        return runAuthoringDiagnosticsCommand(rest, io);
+    }
+    io.stderr.write(`Unknown authoring command: ${subcommand}\n\nUsage: gdh authoring <check|diagnostics> [target]\n`);
+    return 1;
+}
+async function runAuthoringDiagnosticsCommand(args, io) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "help") {
+        io.stdout.write([
+            "Usage: gdh authoring diagnostics <command> [target]",
+            "",
+            "Inspect current Godot authoring diagnostics snapshots from the GDH diagnostics broker.",
+            "These commands report CURRENT diagnostics snapshots, not final validation evidence.",
+            "Use `gdh authoring check` for bounded validation evidence at task boundaries.",
+            "Use `gdh lsp status|doctor|restart|prune|stop` for LSP lifecycle management.",
+            "",
+            "Commands:",
+            "  status [target]                    Print broker health and snapshot freshness.",
+            "  current [target]                   Print current normalized diagnostics snapshot.",
+            "  refresh [target] [--changed <p>…]  Refresh diagnostics for changed files.",
+            "  doctor [target]                    Explain stale, missing, or unavailable states.",
+            "  prune [target]                     Remove stale broker metadata.",
+        ].join("\n") + "\n");
+        return 0;
+    }
+    if (subcommand === "status") {
+        return runAuthoringDiagnosticsSubcommand("status", rest, io);
+    }
+    if (subcommand === "current") {
+        return runAuthoringDiagnosticsSubcommand("current", rest, io);
+    }
+    if (subcommand === "refresh") {
+        return runAuthoringDiagnosticsRefreshCommand(rest, io);
+    }
+    if (subcommand === "doctor") {
+        return runAuthoringDiagnosticsSubcommand("doctor", rest, io);
+    }
+    if (subcommand === "prune") {
+        return runAuthoringDiagnosticsSubcommand("prune", rest, io);
+    }
+    io.stderr.write([
+        `Unknown authoring diagnostics command: ${subcommand}`,
+        "",
+        "Usage: gdh authoring diagnostics <status|current|refresh|doctor|prune> [target]",
+    ].join("\n") + "\n");
     return 1;
 }
+async function runAuthoringDiagnosticsSubcommand(command, args, io) {
+    const helpText = {
+        status: [
+            "Usage: gdh authoring diagnostics status [target]",
+            "Usage: gdh authoring diagnostics status --target <path>",
+            "",
+            "Print diagnostics broker health, snapshot freshness, and scope summary as JSON.",
+            "Reports CURRENT broker state — not final validation evidence.",
+            "Use `gdh authoring check` for bounded validation evidence.",
+        ].join("\n"),
+        current: [
+            "Usage: gdh authoring diagnostics current [target]",
+            "Usage: gdh authoring diagnostics current --target <path>",
+            "",
+            "Print the current normalized diagnostics snapshot without triggering a refresh.",
+            "Reports CURRENT broker snapshot — not final validation evidence.",
+            "Use `gdh authoring diagnostics refresh` to update the snapshot after edits.",
+        ].join("\n"),
+        doctor: [
+            "Usage: gdh authoring diagnostics doctor [target]",
+            "Usage: gdh authoring diagnostics doctor --target <path>",
+            "",
+            "Explain stale, missing, incompatible, or unavailable diagnostics broker states.",
+            "Provides actionable recovery steps — does not recommend raw process killing.",
+        ].join("\n"),
+        prune: [
+            "Usage: gdh authoring diagnostics prune [target]",
+            "Usage: gdh authoring diagnostics prune --target <path>",
+            "",
+            "Remove stale diagnostics broker metadata under .gdh-state.",
+            "Only removes GDH-owned metadata — does not affect the managed LSP lifecycle.",
+        ].join("\n"),
+    };
+    if (args.includes("--help")) {
+        io.stdout.write(`${helpText[command]}\n`);
+        return 0;
+    }
+    const parsedTarget = parseSingleTargetPathArg(args, {
+        usage: `${helpText[command]}\n`,
+        allowTargetOption: true,
+    });
+    if (parsedTarget.error !== null) {
+        io.stderr.write(parsedTarget.error);
+        return 1;
+    }
+    const targetPath = parsedTarget.targetPath;
+    try {
+        const context = await buildAuthoringContext(targetPath);
+        const input = {
+            targetPath: context.targetPath,
+            status: context.status,
+            projectConfig: context.projectConfig,
+        };
+        if (command === "status") {
+            const result = await getAuthoringDiagnosticsStatus(input);
+            writeJsonResult(io, result);
+        }
+        else if (command === "current") {
+            const result = await getCurrentAuthoringDiagnostics(input);
+            writeJsonResult(io, result);
+        }
+        else if (command === "doctor") {
+            const result = await doctorAuthoringDiagnostics(input);
+            writeJsonResult(io, result);
+        }
+        else {
+            const result = await pruneAuthoringDiagnostics(input);
+            writeJsonResult(io, result);
+        }
+        return 0;
+    }
+    catch (error) {
+        io.stderr.write(`Failed to run authoring diagnostics ${command} for "${targetPath}": ${formatCliError(error)}\n`);
+        return 1;
+    }
+}
+async function runAuthoringDiagnosticsRefreshCommand(args, io) {
+    const usage = [
+        "Usage: gdh authoring diagnostics refresh [target] [--changed <path>...]",
+        "Usage: gdh authoring diagnostics refresh --target <path> [--changed <path>...]",
+        "",
+        "Open or refresh specified files through the managed LSP and persist the diagnostics snapshot.",
+        "Omitting --changed refreshes all project GDScript files.",
+        "Reports CURRENT broker snapshot after refresh — not final validation evidence.",
+        "Use `gdh authoring check --mode final` for bounded handoff evidence.",
+    ].join("\n");
+    if (args.includes("--help")) {
+        io.stdout.write(`${usage}\n`);
+        return 0;
+    }
+    // Collect --changed values (may be repeated)
+    const changedFiles = [];
+    const filteredArgs = [];
+    let i = 0;
+    while (i < args.length) {
+        if (args[i] === "--changed" && i + 1 < args.length) {
+            changedFiles.push(args[i + 1]);
+            i += 2;
+        }
+        else {
+            filteredArgs.push(args[i]);
+            i += 1;
+        }
+    }
+    const parsedTarget = parseSingleTargetPathArg(filteredArgs, {
+        usage: `${usage}\n`,
+        allowTargetOption: true,
+    });
+    if (parsedTarget.error !== null) {
+        io.stderr.write(parsedTarget.error);
+        return 1;
+    }
+    const targetPath = parsedTarget.targetPath;
+    try {
+        const context = await buildAuthoringContext(targetPath);
+        const result = await refreshAuthoringDiagnostics({
+            targetPath: context.targetPath,
+            status: context.status,
+            projectConfig: context.projectConfig,
+            ...(changedFiles.length > 0 && { changedFiles }),
+        });
+        writeJsonResult(io, result);
+        return 0;
+    }
+    catch (error) {
+        io.stderr.write(`Failed to refresh authoring diagnostics for "${targetPath}": ${formatCliError(error)}\n`);
+        return 1;
+    }
+}
 async function runLspCommand(args, io) {
     const [subcommand, ...rest] = args;
     if (!subcommand || subcommand === "--help" || subcommand === "help") {
@@ -1791,6 +1979,235 @@ async function runMigrateCommand(args, io) {
         return 1;
     }
 }
+export async function runMigrationCommand(args, io) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "help") {
+        io.stdout.write([
+            "Usage: gdh migration <command>",
+            "",
+            "Commands:",
+            "  clear-backups [target]                                  Remove .gdh-state/backup/ when all deferred-action probes are clean (idempotent).",
+            "  record-envelope-result <slug> --result-file <path>      Record a Phase 73 envelope output_contract from a JSON file.",
+            "  record-envelope-result <slug> --result <inline-json>    Record a Phase 73 envelope output_contract inline (JSON string).",
+            "  clear-envelope <slug> [target]                          Drop the recorded envelopes slot for <slug> from migration.json (testing/debug).",
+        ].join("\n") + "\n");
+        return 0;
+    }
+    if (subcommand === "clear-backups") {
+        return runMigrationClearBackupsCommand(rest, io);
+    }
+    if (subcommand === "record-envelope-result") {
+        return runMigrationRecordEnvelopeResultCommand(rest, io);
+    }
+    if (subcommand === "clear-envelope") {
+        return runMigrationClearEnvelopeCommand(rest, io);
+    }
+    io.stderr.write([
+        `Unknown migration command: ${subcommand}`,
+        "",
+        "Run `gdh migration --help` for the list of supported subcommands.",
+    ].join("\n") + "\n");
+    return 1;
+}
+async function runMigrationClearBackupsCommand(args, io) {
+    if (args.includes("--help")) {
+        io.stdout.write([
+            "Usage: gdh migration clear-backups [target]",
+            "",
+            "Remove .gdh-state/backup/ when all deferred-action probes are clean.",
+            "Exits 0 on cleared and noop, 1 on blocked_by_pending_probes.",
+        ].join("\n") + "\n");
+        return 0;
+    }
+    const unsupportedOptionsError = findUnsupportedOptionsError(args, {
+        usage: "Usage: gdh migration clear-backups [target]\n",
+    });
+    if (unsupportedOptionsError !== null) {
+        io.stderr.write(unsupportedOptionsError);
+        return 1;
+    }
+    const { targetPath, error: targetPathError } = parseOptionalPositionalTargetPath(args, {
+        usage: "Usage: gdh migration clear-backups [target]\n",
+    });
+    if (targetPathError !== null) {
+        io.stderr.write(targetPathError);
+        return 1;
+    }
+    try {
+        const result = await clearMigrationBackups({ targetPath });
+        writeJsonResult(io, result);
+        return result.state === "blocked_by_pending_probes" ? 1 : 0;
+    }
+    catch (error) {
+        io.stderr.write(`Failed to clear migration backups for "${targetPath}": ${formatCliError(error)}\n`);
+        return 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// Phase 73 — gdh migration record-envelope-result (D-07 / D-13)
+// ---------------------------------------------------------------------------
+const RECORD_ENVELOPE_RESULT_USAGE = "Usage: gdh migration record-envelope-result <slug> [--result-file <path> | --result <json>] [--target <path>]\n";
+/**
+ * Subcommand `"record-envelope-result"` for `gdh migration` (Phase 73 D-07).
+ * Mutually-exclusive `--result-file` / `--result` gate; resolves `--target`
+ * via {@link parseSingleTargetPathArg} after stripping the slug positional;
+ * delegates validation and atomic write to {@link recordEnvelopeResult} in
+ * `./migrate.js`. Exit 0 on `recorded`, exit 1 on `blocked`.
+ */
+async function runMigrationRecordEnvelopeResultCommand(args, io) {
+    if (args.includes("--help")) {
+        io.stdout.write([
+            "Usage: gdh migration record-envelope-result <slug> --result-file <path> [--target <path>]",
+            "Usage: gdh migration record-envelope-result <slug> --result <inline-json> [--target <path>]",
+            "",
+            "Record a Phase 73 envelope output_contract block. Validates against the",
+            "GdhMigrationEnvelopeOutput typed union (apply / abort / needs_clarification);",
+            "appends to migration.json.envelopes[<slug>] and migration.json.envelopes[<slug>].attempts[].",
+            'Does NOT advance the chain — re-run `gdh self-update` after recording.',
+            "",
+            'Exits 0 on { state: "recorded" }, 1 on { state: "blocked" }.',
+        ].join("\n") + "\n");
+        return 0;
+    }
+    const unsupportedOptionsError = findUnsupportedOptionsError(args, {
+        usage: RECORD_ENVELOPE_RESULT_USAGE,
+        optionsWithValues: ["--result-file", "--result", "--target"],
+    });
+    if (unsupportedOptionsError !== null) {
+        io.stderr.write(unsupportedOptionsError);
+        return 1;
+    }
+    // Walk argv and skip the value following each value-bearing flag so it is
+    // not misinterpreted as a positional. Boolean flags would belong here too
+    // if any were supported (none currently).
+    const resolvedPositionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? "";
+        if (arg === "--result" || arg === "--result-file" || arg === "--target") {
+            i++; // skip value
+            continue;
+        }
+        if (arg.startsWith("--"))
+            continue;
+        resolvedPositionals.push(arg);
+    }
+    if (resolvedPositionals.length === 0) {
+        io.stderr.write("Usage error: gdh migration record-envelope-result requires a <slug> positional argument.\n");
+        return 1;
+    }
+    if (resolvedPositionals.length > 1) {
+        io.stderr.write(`Usage error: gdh migration record-envelope-result accepts a single <slug>; received ${resolvedPositionals.length}.\n`);
+        return 1;
+    }
+    const slug = resolvedPositionals[0];
+    const resultFile = readSingleOptionValue(args, "--result-file");
+    const resultInline = readSingleOptionValue(args, "--result");
+    // Mutually exclusive: exactly one of the two MUST be present.
+    if ((resultFile === null) === (resultInline === null)) {
+        io.stderr.write("Usage error: provide exactly one of --result-file <path> or --result <inline-json>.\n");
+        return 1;
+    }
+    // Use the canonical helper so --target resolution is symmetric with
+    // runStatusCommand and the other migration dispatchers (no ad-hoc
+    // path.resolve(targetExplicit) here). Strip the slug positional + the
+    // value-bearing flags' values before delegating so the helper sees only
+    // [--target <path>] (or nothing).
+    const argsForTargetParse = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? "";
+        if (arg === "--target") {
+            argsForTargetParse.push(arg);
+            const next = args[i + 1];
+            if (next !== undefined)
+                argsForTargetParse.push(next);
+            i++;
+            continue;
+        }
+        if (arg === "--result" || arg === "--result-file") {
+            i++; // skip value
+            continue;
+        }
+        if (arg === slug)
+            continue; // strip the consumed positional
+        if (arg.startsWith("--"))
+            continue; // strip help and other flags
+        // Any leftover positional would have been caught above.
+    }
+    const { targetPath, error: targetError } = parseSingleTargetPathArg(argsForTargetParse, {
+        usage: RECORD_ENVELOPE_RESULT_USAGE,
+        allowTargetOption: true,
+    });
+    if (targetError !== null) {
+        io.stderr.write(targetError);
+        return 1;
+    }
+    try {
+        const result = await recordEnvelopeResult({
+            targetPath,
+            envelopeRef: slug,
+            resultSource: resultFile !== null
+                ? { kind: "file", absolutePath: path.resolve(resultFile) }
+                : { kind: "inline", json: resultInline },
+        });
+        writeJsonResult(io, result);
+        return result.state === "blocked" ? 1 : 0;
+    }
+    catch (error) {
+        io.stderr.write(`Failed to record envelope result for "${targetPath}": ${formatCliError(error)}\n`);
+        return 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// Phase 73 — gdh migration clear-envelope (testing/debug)
+// ---------------------------------------------------------------------------
+/**
+ * Subcommand `"clear-envelope"` for `gdh migration` (testing/debug companion).
+ * Removes the per-slug slot from `migration.json.envelopes`; idempotent noop
+ * on missing slot or missing migration state. Does NOT touch
+ * `pending_envelope_resume` (mirrors D-13 isolation in
+ * {@link recordEnvelopeResult}). Exit 0 always.
+ */
+async function runMigrationClearEnvelopeCommand(args, io) {
+    if (args.includes("--help")) {
+        io.stdout.write([
+            "Usage: gdh migration clear-envelope <slug> [target]",
+            "",
+            "Remove the recorded envelopes slot for <slug> from migration.json.",
+            "Does NOT touch pending_envelope_resume. Idempotent.",
+            "",
+            "Exits 0 on cleared and noop.",
+        ].join("\n") + "\n");
+        return 0;
+    }
+    const unsupportedOptionsError = findUnsupportedOptionsError(args, {
+        usage: "Usage: gdh migration clear-envelope <slug> [target]\n",
+    });
+    if (unsupportedOptionsError !== null) {
+        io.stderr.write(unsupportedOptionsError);
+        return 1;
+    }
+    const positional = args.filter((a) => !a.startsWith("--"));
+    if (positional.length === 0) {
+        io.stderr.write("Usage error: gdh migration clear-envelope requires a <slug> positional argument.\n");
+        return 1;
+    }
+    if (positional.length > 2) {
+        io.stderr.write("Usage error: gdh migration clear-envelope accepts at most <slug> and an optional [target].\n");
+        return 1;
+    }
+    const slug = positional[0];
+    const targetCandidate = positional[1] ?? null;
+    const targetPath = targetCandidate !== null ? path.resolve(targetCandidate) : process.cwd();
+    try {
+        const result = await clearEnvelope({ targetPath, envelopeRef: slug });
+        writeJsonResult(io, result);
+        return 0;
+    }
+    catch (error) {
+        io.stderr.write(`Failed to clear envelope "${slug}" for "${targetPath}": ${formatCliError(error)}\n`);
+        return 1;
+    }
+}
 async function runBridgeStatusCommand(args, io) {
     if (args.includes("--help")) {
         io.stdout.write([
@@ -3985,6 +4402,7 @@ function renderHelp() {
         "  adapters install [target] [--dry-run] [--agent <name>] [--user] [--dev-repo <path>] [--integration-root <path>] Install or repair supported-agent reinforcement.",
         "  adapters gsd snapshot [target] [--files <path>] Export a read-only GSD projection.",
         "  authoring check [target] Run the current authoring-check entrypoint.",
+        "  authoring diagnostics <status|current|refresh|doctor|prune> [target] Inspect current Godot authoring diagnostics snapshots.",
         "  lsp <status|check|stop|restart|prune|doctor> [target] Manage authoring.lsp lifecycle state.",
         "  warmup [target] [--dry-run] Inspect or apply authoring worktree warmup.",
         "  target prepare [target] [--source-target <path>] [--dry-run] Prepare target-local generated/import state.",