@bli-cockpit/cli 0.2.48 → 0.2.49

package/dist/commands/local-args.js

@@ -1,12 +1,11 @@
-// CLI argument parsing for the local cockpit collector. Split out of
-// commands/local.ts so the command runners read as a table of contents and
-// the parser (pure, independently testable) can change at its own rate.
-//
-// Behavior-preserving extraction: functions moved verbatim, no logic change.
-import { DEFAULT_DASHBOARD_URL } from "../local-state.js";
-import { DEFAULT_AUTOSTART_INTERVAL_SECONDS } from "../autostart.js";
-import { IntentSourceSchema, WorkIntentSchema, WorkPhaseSchema, } from "@bli-cockpit/telemetry-core";
-const WORK_ROOT_FLAGS = ["--repo", "--workspace"];
+import { parseAgentRulesArgs, parseAnalyzeArgs, parseAutostartArgs, parseBackfillArgs, parseDoctorArgs, parseInstallArgs, parseLoginArgs, parseLogoutArgs, parseOnboardArgs, parseReleaseArgs, parseServeArgs, parseSessionsArgs, parseStartArgs, parseStatusArgs, parseSyncArgs, parseUpdateArgs, } from "./local-args-collector.js";
+import { parseBriefArgs, parseCorrectArgs, parseJarvisArgs, parseModelArgs, parseNotesArgs, parseOpsArgs, parseScoutArgs, parseSettingsArgs, parseSlackArgs, parseTeamArgs, parseWorkbookArgs, } from "./local-args-tower.js";
+// `normalizeUrl` has always been part of this module's surface — `local.ts` and
+// `local-auth.ts` import it from here — so it stays exported from this address
+// even though it now lives next door. The same goes for the four names the
+// Tower parsers publish.
+export { normalizeUrl } from "./local-arg-values.js";
+export { SCOUT_MIN_PREFIX_LENGTH, SLACK_WORKSPACE_KEYS, WORKBOOK_MIN_WIDTH, } from "./local-args-tower.js";
 // The six human "set my machine up" doors. They are one thing wearing six
 // hats, so they all run the convergence command — but they keep accepting the
 // flags they always accepted, because DMs, runbooks and AGENTS.md rules across
@@ -86,1544 +85,4 @@ export function parseLocalArgs(argv) {
         default:
             throw new Error(`Unknown local command: ${command ?? ""}`);
     }
-}
-function parseOnboardLikeArgs(args, command) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--email",
-            "--device-name",
-            "--ticket",
-            "--branch",
-            "--json",
-            "--no-auth",
-            "--poll-interval-ms",
-            "--timeout-ms",
-            "--max-depth",
-            "--max-repos",
-            "--allow-home-root",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--email",
-            "--device-name",
-            "--ticket",
-            "--branch",
-            "--poll-interval-ms",
-            "--timeout-ms",
-            "--max-depth",
-            "--max-repos",
-        ],
-    });
-    assertNoPositionals(values.positionals, command);
-    return {
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        collectionRoots: optionalNonEmptyList(workRootFlagValues(values)),
-        dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
-        dashboardUrlExplicit: values.flags.has("--dashboard-url"),
-        claimedOwnerEmail: optionalEmail(values.flags.get("--email")),
-        deviceName: optionalNonEmpty(values.flags.get("--device-name")),
-        activeTicketId: optionalNonEmpty(values.flags.get("--ticket")),
-        branch: optionalNonEmpty(values.flags.get("--branch")),
-        noAuth: values.booleans.has("--no-auth"),
-        json: values.booleans.has("--json"),
-        pollIntervalMs: optionalPositiveInteger(values.flags.get("--poll-interval-ms"), "--poll-interval-ms"),
-        timeoutMs: optionalPositiveInteger(values.flags.get("--timeout-ms"), "--timeout-ms"),
-        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
-        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
-        allowHomeRoot: values.booleans.has("--allow-home-root"),
-    };
-}
-function parseOnboardArgs(args) {
-    return { kind: "onboard", ...parseOnboardLikeArgs(args, "onboard") };
-}
-function parseUpdateArgs(alias, args) {
-    return {
-        kind: "update",
-        alias,
-        ...parseOnboardLikeArgs(args, alias),
-    };
-}
-function parseDoctorArgs(alias, args) {
-    // The allowed set is the UNION of what the six setup doors used to accept.
-    // An alias that silently rejected a flag its own docs told people to pass
-    // would be a worse dead end than the one we are removing.
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--update-tag",
-            "--dry-run",
-            "--json",
-            "--allow-home-root",
-            "--max-depth",
-            "--max-repos",
-            // Accepted and ignored: the convergence run works these out itself.
-            // Rejecting them would break existing DMs and runbooks for no gain.
-            "--email",
-            "--device-name",
-            "--ticket",
-            "--branch",
-            "--no-auth",
-            "--poll-interval-ms",
-            "--timeout-ms",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--update-tag",
-            "--max-depth",
-            "--max-repos",
-            "--email",
-            "--device-name",
-            "--ticket",
-            "--branch",
-            "--poll-interval-ms",
-            "--timeout-ms",
-        ],
-    });
-    assertNoPositionals(values.positionals, alias);
-    const updateTag = optionalNonEmpty(values.flags.get("--update-tag"));
-    if (updateTag && !/^[a-z0-9][a-z0-9._-]*$/u.test(updateTag)) {
-        throw new Error("--update-tag must be a lowercase npm dist-tag such as 'next' or 'latest'.");
-    }
-    return {
-        kind: "doctor",
-        alias,
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        collectionRoots: optionalNonEmptyList(workRootFlagValues(values)),
-        dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
-        updateTag,
-        dryRun: values.booleans.has("--dry-run"),
-        json: values.booleans.has("--json"),
-        allowHomeRoot: values.booleans.has("--allow-home-root"),
-        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
-        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
-    };
-}
-function parseInstallArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--supabase-url",
-            "--json",
-            "--allow-home-root",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--supabase-url",
-        ],
-    });
-    assertNoPositionals(values.positionals, "install");
-    return {
-        kind: "install",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
-        supabaseUrl: optionalNonEmpty(values.flags.get("--supabase-url")),
-        json: values.booleans.has("--json"),
-        allowHomeRoot: values.booleans.has("--allow-home-root"),
-    };
-}
-function parseReleaseArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--dry-run",
-            "--tag",
-            "--access",
-            "--otp",
-            "--skip-checks",
-        ],
-        valueFlags: ["--tag", "--access", "--otp"],
-    });
-    assertNoPositionals(values.positionals, "release");
-    const releaseArgs = [];
-    if (values.booleans.has("--dry-run"))
-        releaseArgs.push("--dry-run");
-    if (values.booleans.has("--skip-checks"))
-        releaseArgs.push("--skip-checks");
-    for (const flag of ["--tag", "--access", "--otp"]) {
-        const value = values.flags.get(flag);
-        if (value !== undefined)
-            releaseArgs.push(flag, value);
-    }
-    return { kind: "release", args: releaseArgs };
-}
-function parseLoginArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--email",
-            "--device-name",
-            "--json",
-            "--no-auth",
-            "--poll-interval-ms",
-            "--timeout-ms",
-        ],
-        valueFlags: [
-            "--home",
-            "--dashboard-url",
-            "--email",
-            "--device-name",
-            "--poll-interval-ms",
-            "--timeout-ms",
-        ],
-    });
-    assertNoPositionals(values.positionals, "login");
-    return {
-        kind: "login",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        claimedOwnerEmail: optionalEmail(values.flags.get("--email")),
-        deviceName: optionalNonEmpty(values.flags.get("--device-name")),
-        json: values.booleans.has("--json"),
-        noAuth: values.booleans.has("--no-auth"),
-        pollIntervalMs: optionalPositiveInteger(values.flags.get("--poll-interval-ms"), "--poll-interval-ms"),
-        timeoutMs: optionalPositiveInteger(values.flags.get("--timeout-ms"), "--timeout-ms"),
-    };
-}
-function parseLogoutArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--json", "--revoke", "--dashboard-url", "--yes"],
-        valueFlags: ["--home", "--dashboard-url"],
-    });
-    assertNoPositionals(values.positionals, "logout");
-    return {
-        kind: "logout",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        json: values.booleans.has("--json"),
-        revoke: values.booleans.has("--revoke"),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        yes: values.booleans.has("--yes"),
-    };
-}
-const SETTINGS_SECTIONS = ["personal", "switches", "models", "env"];
-/**
- * `cockpit settings [section] [verb] [args]` (BLI-3461).
- *
- * The flag set is the UNION across sections and the combinations are checked
- * afterwards, per section — the same shape `parseDoctorArgs` uses. A flag that
- * belongs to another section is refused by name rather than silently ignored,
- * because a dropped `--project` on an env write is a change a person believes
- * they made.
- */
-function parseSettingsArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--json",
-            "--chat-model",
-            "--brief-model",
-            "--chat",
-            "--memory",
-            "--project",
-            "--file",
-            "--id",
-            "--content-stdin",
-            "--yes",
-        ],
-        valueFlags: [
-            "--home",
-            "--dashboard-url",
-            "--chat-model",
-            "--brief-model",
-            "--chat",
-            "--memory",
-            "--project",
-            "--file",
-            "--id",
-        ],
-    });
-    const [rawSection, ...rest] = values.positionals;
-    const common = {
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        yes: values.booleans.has("--yes"),
-        json: values.booleans.has("--json"),
-    };
-    if (!rawSection) {
-        if (rest.length > 0)
-            throw new Error("settings does not accept that argument.");
-        return { kind: "settings", section: "overview", action: "show", ...common };
-    }
-    if (!SETTINGS_SECTIONS.includes(rawSection)) {
-        throw new Error(`settings section must be one of ${SETTINGS_SECTIONS.join(", ")} — or nothing, for all of them.`);
-    }
-    const section = rawSection;
-    if (section === "personal") {
-        if (rest.length > 0)
-            throw new Error("settings personal does not accept positional arguments.");
-        const chatModel = optionalNonEmpty(values.flags.get("--chat-model"));
-        const briefModel = optionalNonEmpty(values.flags.get("--brief-model"));
-        return {
-            kind: "settings",
-            section,
-            action: chatModel || briefModel ? "set" : "show",
-            chatModel,
-            briefModel,
-            ...common,
-        };
-    }
-    if (section === "switches") {
-        if (rest.length === 0) {
-            return { kind: "settings", section, action: "show", ...common };
-        }
-        if (rest[0] !== "set") {
-            throw new Error("settings switches takes no verb, or `set <key> <value>`.");
-        }
-        const [, key, value, ...extra] = rest;
-        if (!key || !value || extra.length > 0) {
-            throw new Error("settings switches set needs exactly a key and a value.");
-        }
-        return { kind: "settings", section, action: "set", switchKey: key, switchValue: value, ...common };
-    }
-    if (section === "models") {
-        if (rest.length === 0) {
-            return { kind: "settings", section, action: "show", ...common };
-        }
-        if (rest[0] !== "set" || rest.length > 1) {
-            throw new Error("settings models takes no verb, or `set --chat <key>` / `set --memory <id>`.");
-        }
-        const orgChatModel = optionalNonEmpty(values.flags.get("--chat"));
-        const orgMemoryModel = optionalNonEmpty(values.flags.get("--memory"));
-        if (!orgChatModel && !orgMemoryModel) {
-            throw new Error("settings models set needs --chat <key>, --memory <id>, or both.");
-        }
-        return { kind: "settings", section, action: "set", orgChatModel, orgMemoryModel, ...common };
-    }
-    // env
-    const verb = rest[0] ?? "list";
-    if (rest.length > 1)
-        throw new Error("settings env takes one verb: list, set, or delete.");
-    if (verb === "list") {
-        return { kind: "settings", section, action: "list", ...common };
-    }
-    if (verb === "set") {
-        const envProject = optionalNonEmpty(values.flags.get("--project"));
-        const envFile = optionalNonEmpty(values.flags.get("--file"));
-        if (!envProject || !envFile) {
-            throw new Error("settings env set needs --project <project> and --file <file name>.");
-        }
-        if (!values.booleans.has("--content-stdin")) {
-            // Deliberate: there is no `--content <value>` flag and never will be. A
-            // secret on a command line lands in shell history and in every process
-            // listing on the machine.
-            throw new Error("settings env set reads the file contents from stdin: add --content-stdin and pipe the file in.");
-        }
-        return {
-            kind: "settings",
-            section,
-            action: "set",
-            envProject,
-            envFile,
-            contentStdin: true,
-            ...common,
-        };
-    }
-    if (verb === "delete") {
-        const envId = optionalNonEmpty(values.flags.get("--id"));
-        if (!envId)
-            throw new Error("settings env delete needs --id <uuid>.");
-        return { kind: "settings", section, action: "delete", envId, ...common };
-    }
-    throw new Error("settings env takes one verb: list, set, or delete.");
-}
-/** `cockpit team [members|invite <email>|role <userId>]` (BLI-3461). */
-function parseTeamArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--dashboard-url", "--json", "--role", "--team-id", "--yes"],
-        valueFlags: ["--home", "--dashboard-url", "--role", "--team-id"],
-    });
-    const common = {
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        teamId: optionalNonEmpty(values.flags.get("--team-id")),
-        yes: values.booleans.has("--yes"),
-        json: values.booleans.has("--json"),
-    };
-    const [verb, subject, ...extra] = values.positionals;
-    if (extra.length > 0)
-        throw new Error("team does not accept that many arguments.");
-    if (!verb || verb === "members") {
-        if (subject)
-            throw new Error("team members does not accept positional arguments.");
-        return { kind: "team", action: "members", ...common };
-    }
-    if (verb === "invite") {
-        if (!subject)
-            throw new Error("team invite needs an email address.");
-        const email = optionalEmail(subject);
-        const role = optionalNonEmpty(values.flags.get("--role"));
-        if (!role)
-            throw new Error("team invite needs --role <role>.");
-        return { kind: "team", action: "invite", email, role, ...common };
-    }
-    if (verb === "role") {
-        if (!subject)
-            throw new Error("team role needs the user id whose role is changing.");
-        const role = optionalNonEmpty(values.flags.get("--role"));
-        if (!role)
-            throw new Error("team role needs --role <role>.");
-        return { kind: "team", action: "role", targetUserId: subject, role, ...common };
-    }
-    throw new Error("team takes one verb: members, invite, or role.");
-}
-/** `cockpit model [show|set <key>]` — the alias surface for the personal chat model. */
-function parseModelArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--dashboard-url", "--json"],
-        valueFlags: ["--home", "--dashboard-url"],
-    });
-    const [verb, key, ...extra] = values.positionals;
-    if (extra.length > 0)
-        throw new Error("model does not accept that many arguments.");
-    const common = {
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        json: values.booleans.has("--json"),
-    };
-    if (!verb || verb === "show") {
-        if (key)
-            throw new Error("model show does not accept positional arguments.");
-        return { kind: "model", action: "show", ...common };
-    }
-    if (verb === "set") {
-        if (!key)
-            throw new Error("model set needs a model key, e.g. openai:gpt-5.6-terra.");
-        return { kind: "model", action: "set", modelKey: key, ...common };
-    }
-    throw new Error("model takes one verb: show or set <key>.");
-}
-function parseStartArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--branch",
-            "--ticket",
-            "--clear-ticket",
-            "--topic",
-            "--topic-summary",
-            "--intent",
-            "--phase",
-            "--intent-source",
-            "--intent-confidence",
-            "--operator-id",
-            "--session-id",
-            "--json",
-            "--max-depth",
-            "--max-repos",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--branch",
-            "--ticket",
-            "--topic",
-            "--topic-summary",
-            "--intent",
-            "--phase",
-            "--intent-source",
-            "--intent-confidence",
-            "--operator-id",
-            "--session-id",
-            "--max-depth",
-            "--max-repos",
-        ],
-    });
-    assertNoPositionals(values.positionals, "start");
-    const activeTicketId = optionalNonEmpty(values.flags.get("--ticket"));
-    const clearTicket = values.booleans.has("--clear-ticket");
-    if (activeTicketId && clearTicket) {
-        throw new Error("--ticket and --clear-ticket cannot be combined.");
-    }
-    const topicLabel = optionalNonEmpty(values.flags.get("--topic"));
-    const topicSummaryRedacted = optionalNonEmpty(values.flags.get("--topic-summary"));
-    const workIntent = optionalSchemaValue(WorkIntentSchema, values.flags.get("--intent"), "--intent");
-    const workPhase = optionalSchemaValue(WorkPhaseSchema, values.flags.get("--phase"), "--phase");
-    const intentConfidence = optionalConfidence(values.flags.get("--intent-confidence"), "--intent-confidence");
-    const explicitIntentMetadata = Boolean(topicLabel ||
-        topicSummaryRedacted ||
-        workIntent ||
-        workPhase ||
-        intentConfidence !== undefined);
-    return {
-        kind: "start",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        branch: optionalNonEmpty(values.flags.get("--branch")),
-        activeTicketId,
-        clearTicket,
-        topicLabel,
-        topicSummaryRedacted,
-        workIntent,
-        workPhase,
-        intentSource: optionalSchemaValue(IntentSourceSchema, values.flags.get("--intent-source"), "--intent-source") ?? (explicitIntentMetadata ? "explicit_user" : undefined),
-        intentConfidence,
-        operatorId: optionalNonEmpty(values.flags.get("--operator-id")),
-        sessionId: optionalNonEmpty(values.flags.get("--session-id")),
-        json: values.booleans.has("--json"),
-        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
-        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
-    };
-}
-function parseSyncArgs(args) {
-    return parseSyncLikeArgs(args, "sync");
-}
-function parseAnalyzeArgs(args) {
-    return parseSyncLikeArgs(args, "analyze");
-}
-function parseSyncLikeArgs(args, command) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--json",
-            "--max-depth",
-            "--max-repos",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--max-depth",
-            "--max-repos",
-        ],
-    });
-    assertNoPositionals(values.positionals, command);
-    return {
-        kind: command,
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        json: values.booleans.has("--json"),
-        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
-        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
-    };
-}
-function parseBackfillArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--since-days",
-            "--all",
-            "--source",
-            "--dry-run",
-            "--max-files",
-            "--max-depth",
-            "--max-repos",
-            "--yes",
-            "--json",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--since-days",
-            "--source",
-            "--max-files",
-            "--max-depth",
-            "--max-repos",
-        ],
-    });
-    assertNoPositionals(values.positionals, "backfill");
-    const source = values.flags.get("--source");
-    if (source !== undefined && source !== "codex" && source !== "claude") {
-        throw new Error("--source must be 'codex' or 'claude'. Omit it to scan both.");
-    }
-    const sinceDays = optionalPositiveInteger(values.flags.get("--since-days"), "--since-days");
-    const all = values.booleans.has("--all");
-    if (all && sinceDays !== undefined) {
-        throw new Error("--since-days and --all cannot be combined.");
-    }
-    return {
-        kind: "backfill",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        source,
-        sinceDays,
-        all,
-        dryRun: values.booleans.has("--dry-run"),
-        maxFiles: optionalPositiveInteger(values.flags.get("--max-files"), "--max-files"),
-        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
-        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
-        yes: values.booleans.has("--yes"),
-        json: values.booleans.has("--json"),
-    };
-}
-function parseStatusArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--json",
-            "--max-depth",
-            "--max-repos",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--max-depth",
-            "--max-repos",
-        ],
-    });
-    assertNoPositionals(values.positionals, "status");
-    return {
-        kind: "status",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        json: values.booleans.has("--json"),
-        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
-        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
-    };
-}
-function parseSessionsArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--source",
-            "--since-days",
-            "--all",
-            "--json",
-            "--max-depth",
-            "--max-repos",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--source",
-            "--since-days",
-            "--max-depth",
-            "--max-repos",
-        ],
-    });
-    assertNoPositionals(values.positionals, "sessions");
-    const source = values.flags.get("--source");
-    if (source !== undefined && source !== "codex" && source !== "claude") {
-        throw new Error("--source must be 'codex' or 'claude'. Omit it to scan both.");
-    }
-    const sinceDays = optionalPositiveInteger(values.flags.get("--since-days"), "--since-days");
-    const all = values.booleans.has("--all");
-    if (all && sinceDays !== undefined) {
-        throw new Error("--since-days and --all cannot be combined.");
-    }
-    return {
-        kind: "sessions",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        source,
-        sinceDays,
-        all,
-        json: values.booleans.has("--json"),
-        maxDepth: optionalPositiveInteger(values.flags.get("--max-depth"), "--max-depth"),
-        maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
-    };
-}
-function parseServeArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--repo", "--workspace", "--port"],
-        valueFlags: ["--home", "--repo", "--workspace", "--port"],
-    });
-    assertNoPositionals(values.positionals, "serve");
-    const port = Number(values.flags.get("--port") ?? "4174");
-    if (!Number.isInteger(port) || port < 1 || port > 65535) {
-        throw new Error("--port must be a TCP port between 1 and 65535.");
-    }
-    return {
-        kind: "serve",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        port,
-    };
-}
-function parseAutostartArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--interval-seconds",
-            "--parent-pid",
-            "--json",
-        ],
-        valueFlags: [
-            "--home",
-            "--repo",
-            "--workspace",
-            "--dashboard-url",
-            "--interval-seconds",
-            "--parent-pid",
-        ],
-    });
-    if (values.positionals.length > 1) {
-        throw new Error("autostart accepts at most one action (install|uninstall|status).");
-    }
-    const action = values.positionals[0] ?? "install";
-    if (action !== "install" &&
-        action !== "uninstall" &&
-        action !== "status" &&
-        action !== "heal-detached") {
-        throw new Error("autostart action must be install, uninstall, or status.");
-    }
-    return {
-        kind: "autostart",
-        action,
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
-        intervalSeconds: optionalPositiveInteger(values.flags.get("--interval-seconds"), "--interval-seconds") ?? DEFAULT_AUTOSTART_INTERVAL_SECONDS,
-        parentPid: optionalPositiveInteger(values.flags.get("--parent-pid"), "--parent-pid"),
-        json: values.booleans.has("--json"),
-    };
-}
-function parseAgentRulesArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--host", "--repo", "--workspace", "--json"],
-        valueFlags: ["--home", "--host", "--repo", "--workspace"],
-    });
-    if (values.positionals.length > 1) {
-        throw new Error("agent-rules accepts at most one action (install|uninstall|status).");
-    }
-    const action = values.positionals[0] ?? "install";
-    if (action !== "install" && action !== "uninstall" && action !== "status") {
-        throw new Error("agent-rules action must be install, uninstall, or status.");
-    }
-    return {
-        kind: "agent-rules",
-        action,
-        host: parseAgentRulesHost(values.flags.get("--host")),
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
-        json: values.booleans.has("--json"),
-    };
-}
-function parseAgentRulesHost(value) {
-    const host = value?.trim().toLowerCase() || "all";
-    if (host === "codex" || host === "claude" || host === "all")
-        return host;
-    throw new Error("agent-rules --host must be codex, claude, or all.");
-}
-function parseJarvisArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--prompt",
-            "--as",
-            "--thread",
-            "--model",
-            "--image",
-            "--file",
-            "--no-stream",
-            // BLI-3484: which day's page this turn is about.
-            "--date",
-            // BLI-3458: reading back what was already said, rather than saying
-            // something new. Neither takes a turn or reaches the model.
-            "--threads",
-            "--history",
-            "--limit",
-            "--json",
-        ],
-        valueFlags: [
-            "--home",
-            "--dashboard-url",
-            "--prompt",
-            "--as",
-            "--thread",
-            "--model",
-            "--image",
-            "--file",
-            "--date",
-            "--limit",
-        ],
-    });
-    const flaggedPrompt = optionalNonEmpty(values.flags.get("--prompt"));
-    const positionalPrompt = optionalNonEmpty(values.positionals.join(" "));
-    if (flaggedPrompt && positionalPrompt) {
-        throw new Error("jarvis accepts either --prompt or positional text, not both.");
-    }
-    const thread = optionalNonEmpty(values.flags.get("--thread")) ?? "main";
-    if (!/^[A-Za-z0-9_-]{1,40}$/.test(thread)) {
-        throw new Error("jarvis --thread must use 1 to 40 letters, numbers, underscores, or hyphens.");
-    }
-    // BLI-3414: `--file` is a plain alias for `--image` — same flag, whichever
-    // word a person reaches for first.
-    const image = optionalNonEmpty(values.flags.get("--image"));
-    const file = optionalNonEmpty(values.flags.get("--file"));
-    if (image && file) {
-        throw new Error("jarvis accepts either --image or --file, not both — they are the same flag.");
-    }
-    // BLI-3458. Reading history and asking a question are different acts, and a
-    // command that quietly did one while you asked for the other would be worse
-    // than a refusal — `--threads` with a question would silently drop the
-    // question.
-    const threads = values.booleans.has("--threads");
-    const history = values.booleans.has("--history");
-    if (threads && history) {
-        throw new Error("jarvis --threads lists every thread; --history replays one. Pass one, not both.");
-    }
-    if ((threads || history) && (flaggedPrompt || positionalPrompt)) {
-        throw new Error("jarvis --threads and --history read back what was already said; they do not take a question.");
-    }
-    if ((threads || history) && image) {
-        throw new Error("jarvis --threads and --history do not take an attachment.");
-    }
-    // BLI-3484. `--date` binds the page that was live on one of the subject's
-    // days, so a turn can be about Sunday's page. Refused on the two reading
-    // commands for the same reason an attachment is: they replay what was said
-    // and bind no page at all.
-    const date = optionalNonEmpty(values.flags.get("--date"));
-    if ((threads || history) && date) {
-        throw new Error("jarvis --threads and --history replay what was said; they bind no page.");
-    }
-    return {
-        kind: "jarvis",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        prompt: flaggedPrompt ?? positionalPrompt,
-        subject: optionalNonEmpty(values.flags.get("--as")),
-        thread,
-        threads,
-        history,
-        limit: optionalPositiveInteger(values.flags.get("--limit"), "--limit"),
-        // BLI-3381: no client-side allowlist — the dashboard forwards this key
-        // to the inference server's own allowlist and relays its refusal.
-        model: optionalNonEmpty(values.flags.get("--model")),
-        ...(date ? { date } : {}),
-        imagePath: image ?? file,
-        // BLI-3457: streaming is on unless a caller opts out. A dashboard that
-        // does not stream yet still answers plain JSON, so this flag is for
-        // callers that want the single-body shape on purpose, not a compat knob.
-        stream: !values.booleans.has("--no-stream"),
-        json: values.booleans.has("--json"),
-    };
-}
-/** The shortest prefix `cockpit scout start` will resolve. Below this, ids collide. */
-export const SCOUT_MIN_PREFIX_LENGTH = 6;
-/**
- * `cockpit scout [--days <n>]` reads the board; `cockpit scout start|dismiss|undo
- * <id>` moves one card. Positional shape modelled on `autostart`: an optional
- * action word first, then what it acts on.
- */
-function parseScoutArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--dashboard-url", "--days", "--json"],
-        valueFlags: ["--home", "--dashboard-url", "--days"],
-    });
-    if (values.positionals.length > 2) {
-        throw new Error("scout accepts at most an action (start|dismiss|undo) and one experiment id.");
-    }
-    const [rawAction, rawRef] = values.positionals;
-    const base = {
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        days: optionalPositiveInteger(values.flags.get("--days"), "--days"),
-        json: values.booleans.has("--json"),
-    };
-    if (!rawAction)
-        return { kind: "scout", action: "board", ...base };
-    if (rawAction !== "start" && rawAction !== "dismiss" && rawAction !== "undo") {
-        throw new Error("scout action must be start, dismiss, or undo.");
-    }
-    const experimentRef = optionalNonEmpty(rawRef);
-    if (!experimentRef) {
-        throw new Error(`scout ${rawAction} needs an experiment id from the board.`);
-    }
-    if (experimentRef.length < SCOUT_MIN_PREFIX_LENGTH) {
-        throw new Error(`scout ${rawAction} needs a full experiment id or a prefix of at least ${SCOUT_MIN_PREFIX_LENGTH} characters.`);
-    }
-    return { kind: "scout", action: rawAction, experimentRef, ...base };
-}
-/**
- * `cockpit ops status [--job <id>] [--skips]` and
- * `cockpit ops recompile --person <p> [--dry-run]` (BLI-3462).
- *
- * There is deliberately **no `--cadence`** on `recompile`. The compile path
- * behind it (`writePageAgain` → `publishPage`) takes no cadence and writes a
- * daily; accepting the flag and dropping it is the silent breakage BLI-2490
- * forbids, and threading cadence through that path is its own change. Ask for a
- * weekly or a monthly with the compile script, which does support it.
- */
-function parseOpsArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--job",
-            "--skips",
-            "--person",
-            "--dry-run",
-            "--json",
-        ],
-        valueFlags: ["--home", "--dashboard-url", "--job", "--person"],
-    });
-    if (values.positionals.length > 1) {
-        throw new Error("ops accepts one action: status or recompile.");
-    }
-    const rawAction = values.positionals[0] ?? "status";
-    if (rawAction !== "status" && rawAction !== "recompile") {
-        throw new Error("ops action must be status or recompile.");
-    }
-    const base = {
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        json: values.booleans.has("--json"),
-    };
-    if (rawAction === "status") {
-        return {
-            kind: "ops",
-            action: "status",
-            job: optionalNonEmpty(values.flags.get("--job")),
-            skips: values.booleans.has("--skips"),
-            ...base,
-        };
-    }
-    const person = optionalNonEmpty(values.flags.get("--person"));
-    if (!person) {
-        throw new Error("ops recompile needs --person <email|name|id>. Nothing is recompiled by default, on purpose.");
-    }
-    return {
-        kind: "ops",
-        action: "recompile",
-        person,
-        dryRun: values.booleans.has("--dry-run"),
-        ...base,
-    };
-}
-/** The workspaces Cockpit collects. A typo is refused here rather than searched for. */
-export const SLACK_WORKSPACE_KEYS = ["bli", "blue_pearl"];
-/**
- * `cockpit slack coverage [--workspace <key>] [--stale-only]` and
- * `cockpit slack read [--person|--channel|--query|--since|--until|--limit]`
- * (BLI-3462).
- */
-function parseSlackArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--workspace",
-            "--stale-only",
-            "--person",
-            "--channel",
-            "--query",
-            "--since",
-            "--until",
-            "--limit",
-            "--json",
-        ],
-        valueFlags: [
-            "--home",
-            "--dashboard-url",
-            "--workspace",
-            "--person",
-            "--channel",
-            "--query",
-            "--since",
-            "--until",
-            "--limit",
-        ],
-    });
-    if (values.positionals.length > 1) {
-        throw new Error("slack accepts one action: coverage or read.");
-    }
-    const rawAction = values.positionals[0] ?? "coverage";
-    if (rawAction !== "coverage" && rawAction !== "read") {
-        throw new Error("slack action must be coverage or read.");
-    }
-    const base = {
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        json: values.booleans.has("--json"),
-    };
-    if (rawAction === "coverage") {
-        // `--workspace` here is a Slack workspace key, NOT the collection-root
-        // `--workspace <path>` every setup command takes. Named at the point of use
-        // so the two cannot be confused silently.
-        const workspace = optionalNonEmpty(values.flags.get("--workspace"));
-        if (workspace && !SLACK_WORKSPACE_KEYS.includes(workspace)) {
-            throw new Error(`slack --workspace must be one of ${SLACK_WORKSPACE_KEYS.join(", ")}; got ${workspace}.`);
-        }
-        return {
-            kind: "slack",
-            action: "coverage",
-            workspace,
-            staleOnly: values.booleans.has("--stale-only"),
-            ...base,
-        };
-    }
-    const person = optionalNonEmpty(values.flags.get("--person"));
-    const channel = optionalNonEmpty(values.flags.get("--channel"));
-    const query = optionalNonEmpty(values.flags.get("--query"));
-    if (!person && !channel && !query) {
-        throw new Error("slack read needs at least one of --person, --channel or --query. An unfiltered dump of every " +
-            "message is not something this command offers.");
-    }
-    return {
-        kind: "slack",
-        action: "read",
-        person,
-        channel,
-        query,
-        since: optionalNonEmpty(values.flags.get("--since")),
-        until: optionalNonEmpty(values.flags.get("--until")),
-        limit: optionalPositiveInteger(values.flags.get("--limit"), "--limit"),
-        ...base,
-    };
-}
-/** The narrowest width worth wrapping to; below it every line is one word. */
-export const WORKBOOK_MIN_WIDTH = 20;
-/**
- * `cockpit workbook` with nothing lists the library, one positional lists a
- * project's shelf, two read a document.
- */
-function parseWorkbookArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--section",
-            "--width",
-            "--markdown",
-            "--json",
-        ],
-        valueFlags: ["--home", "--dashboard-url", "--section", "--width"],
-    });
-    if (values.positionals.length > 2) {
-        throw new Error("workbook accepts at most a project and a document.");
-    }
-    const project = optionalNonEmpty(values.positionals[0]);
-    const doc = optionalNonEmpty(values.positionals[1]);
-    const section = optionalNonEmpty(values.flags.get("--section"));
-    const markdown = values.booleans.has("--markdown");
-    if (!doc && (section || markdown)) {
-        throw new Error("workbook --section and --markdown need a project and a document, e.g. `cockpit workbook tower workbook`.");
-    }
-    const width = optionalPositiveInteger(values.flags.get("--width"), "--width");
-    if (width !== undefined && width < WORKBOOK_MIN_WIDTH) {
-        throw new Error(`workbook --width must be at least ${WORKBOOK_MIN_WIDTH}.`);
-    }
-    return {
-        kind: "workbook",
-        project,
-        doc,
-        section,
-        markdown,
-        width,
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        json: values.booleans.has("--json"),
-    };
-}
-/**
- * `cockpit brief` (BLI-3458) — the TODAY page, in the terminal.
- *
- * `--for` is the terminal's `?p=`, and it follows the same rule the website
- * does: the dashboard resolves it against the roster and the database (or the
- * route's own mirror of the database's rule) decides whether the page opens.
- * Nothing is decided here.
- *
- * `--date` (BLI-3484) is the terminal's `?d=`, and the same sentence applies to
- * it twice over: what counts as a date, where that person's day starts, and
- * whether anything was compiled for it are all the dashboard's answer. A local
- * copy of "when does Tuesday begin" would be a second answer to a question this
- * product already answers per person, per zone.
- */
-function parseBriefArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--for",
-            "--as",
-            "--who",
-            "--version",
-            "--date",
-            "--delta",
-            "--against",
-            "--days",
-            "--tldr",
-            "--full",
-            "--versions",
-            "--claims",
-            "--render",
-            "--reason",
-            "--wait",
-            "--no-wait",
-            "--json",
-        ],
-        valueFlags: [
-            "--home",
-            "--dashboard-url",
-            "--for",
-            "--as",
-            "--who",
-            "--version",
-            "--date",
-            "--against",
-            "--days",
-            "--reason",
-        ],
-    });
-    // Bare `cockpit brief` reads the page, which is what somebody typing it almost
-    // always wants — the same shape `cockpit notes` and `cockpit scout` have.
-    // `status` (BLI-3462) answers why a brief was or was not delivered.
-    const first = values.positionals[0];
-    const action = (first === undefined ? "read" : first);
-    if (!["read", "edit", "rewrite", "history", "status"].includes(action)) {
-        throw new Error(`Unknown brief command: ${first}. Try edit, rewrite, history or status, or nothing to read it.`);
-    }
-    if (values.positionals.length > (first === undefined ? 0 : 1)) {
-        throw new Error(`brief ${action} does not take "${values.positionals[1]}".`);
-    }
-    const tldr = values.booleans.has("--tldr");
-    const full = values.booleans.has("--full");
-    if (tldr && full) {
-        throw new Error("brief accepts either --tldr or --full, not both.");
-    }
-    const wait = values.booleans.has("--wait");
-    const noWait = values.booleans.has("--no-wait");
-    if (wait && noWait) {
-        throw new Error("brief rewrite accepts either --wait or --no-wait, not both.");
-    }
-    const reason = optionalNonEmpty(values.flags.get("--reason"));
-    if (reason && reason.length > 280) {
-        // The server's own ceiling (`REASON_MAX`). Said here so the person is told
-        // before the page is opened rather than after they have finished editing.
-        throw new Error("A reason is limited to 280 characters.");
-    }
-    if (action !== "edit" && reason) {
-        throw new Error("--reason belongs to `cockpit brief edit`.");
-    }
-    if (action !== "rewrite" && (wait || noWait)) {
-        throw new Error("--wait and --no-wait belong to `cockpit brief rewrite`.");
-    }
-    // ── Reading a past day (BLI-3484) ────────────────────────────────────────
-    const date = optionalNonEmpty(values.flags.get("--date"));
-    const against = optionalNonEmpty(values.flags.get("--against"));
-    const delta = values.booleans.has("--delta");
-    const days = optionalPositiveInteger(values.flags.get("--days"), "--days");
-    if (date && action !== "read") {
-        throw new Error("--date belongs to `cockpit brief` on its own — it reads one day's page.");
-    }
-    if (delta && action !== "read") {
-        throw new Error("--delta belongs to `cockpit brief` on its own.");
-    }
-    if (against && !delta) {
-        // Said rather than silently ignored: somebody who typed `--against` asked
-        // for a comparison, and running the plain read would answer a different
-        // question without saying so.
-        throw new Error("--against needs --delta: it names the day to compare against.");
-    }
-    if (days !== undefined && action !== "history") {
-        throw new Error("--days belongs to `cockpit brief history`.");
-    }
-    if (action === "history" && (values.booleans.has("--tldr") || values.booleans.has("--claims"))) {
-        throw new Error("brief history lists days; --tldr and --claims belong to reading a page.");
-    }
-    // `--as` is accepted as an alias so the two conversational commands read the
-    // same way; `cockpit jarvis --as <person>` has meant this since BLI-3380.
-    // `--who` is the third spelling, and it exists because `cockpit brief status
-    // --who <person>` is the terminal echo of `jarvis:dm --who`.
-    const forPerson = optionalNonEmpty(values.flags.get("--for"));
-    const asPerson = optionalNonEmpty(values.flags.get("--as"));
-    const whoPerson = optionalNonEmpty(values.flags.get("--who"));
-    const named = [forPerson, asPerson, whoPerson].filter(Boolean);
-    if (new Set(named).size > 1) {
-        throw new Error("brief --for, --as and --who must name the same person.");
-    }
-    const render = values.booleans.has("--render");
-    if (render && action !== "status") {
-        throw new Error("brief --render belongs to `cockpit brief status`; the page is printed by default.");
-    }
-    return {
-        kind: "brief",
-        action,
-        render,
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        subject: forPerson ?? asPerson ?? whoPerson,
-        version: optionalNonEmpty(values.flags.get("--version")),
-        ...(date ? { date } : {}),
-        ...(delta ? { delta: true } : {}),
-        ...(against ? { against } : {}),
-        ...(days !== undefined ? { days } : {}),
-        tldr,
-        versions: values.booleans.has("--versions"),
-        claims: values.booleans.has("--claims"),
-        ...(reason ? { reason } : {}),
-        // Waiting is the default; only an explicit `--no-wait` turns it off. A
-        // person who typed `rewrite` wants the page, not a receipt.
-        ...(noWait ? { wait: false } : {}),
-        json: values.booleans.has("--json"),
-    };
-}
-/**
- * `cockpit correct` (BLI-3458) — say that one line on the page is wrong.
- *
- * `--claim` is required and comes from `cockpit brief --claims`, which prints
- * the id beside every line it names. A correction with no claim would be a note
- * about the page in general, and the panel has a sentinel for that; the
- * terminal does not offer it, because a person who has just read
- * `[claimId] the sentence` has the id in front of them.
- *
- * `--text` may be omitted when something is piped in — `git log | cockpit
- * correct --claim x` — and the command reads stdin instead. Absent both, the
- * command refuses rather than filing an empty correction.
- */
-function parseCorrectArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--claim",
-            "--text",
-            "--for",
-            "--as",
-            "--version",
-            "--supersedes",
-            "--json",
-        ],
-        valueFlags: [
-            "--home",
-            "--dashboard-url",
-            "--claim",
-            "--text",
-            "--for",
-            "--as",
-            "--version",
-            "--supersedes",
-        ],
-    });
-    const claimId = optionalNonEmpty(values.flags.get("--claim"));
-    if (!claimId) {
-        throw new Error("correct needs --claim <claimId>. Run `cockpit brief --claims` to see the id beside every line.");
-    }
-    const flaggedText = optionalNonEmpty(values.flags.get("--text"));
-    const positionalText = optionalNonEmpty(values.positionals.join(" "));
-    if (flaggedText && positionalText) {
-        throw new Error("correct accepts either --text or positional text, not both.");
-    }
-    const text = flaggedText ?? positionalText;
-    if (text && text.length > 4000) {
-        throw new Error("A correction is limited to 4000 characters.");
-    }
-    const forPerson = optionalNonEmpty(values.flags.get("--for"));
-    const asPerson = optionalNonEmpty(values.flags.get("--as"));
-    if (forPerson && asPerson && forPerson !== asPerson) {
-        throw new Error("correct --for and --as must name the same person.");
-    }
-    return {
-        kind: "correct",
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        claimId,
-        text,
-        subject: forPerson ?? asPerson,
-        version: optionalNonEmpty(values.flags.get("--version")),
-        supersedes: optionalNonEmpty(values.flags.get("--supersedes")),
-        json: values.booleans.has("--json"),
-    };
-}
-const NOTES_ACTIONS = new Set([
-    "list",
-    "show",
-    "shelf",
-    "shelves",
-    "upload",
-    "paste",
-    "share",
-    "unshare",
-    "move",
-]);
-/** Actions whose first positional is the note it acts on. */
-const NOTES_ACTIONS_NEEDING_A_NOTE = new Set([
-    "show",
-    "share",
-    "unshare",
-    "move",
-]);
-function parseNotesArgs(args) {
-    const values = parseNamedArgs(args, {
-        allowedFlags: [
-            "--home",
-            "--dashboard-url",
-            "--file",
-            "--name",
-            "--exclude",
-            "--to",
-            "--clear-shelf",
-            "--series",
-            "--kind",
-            "--since",
-            "--until",
-            "--limit",
-            "--yes",
-            "--json",
-        ],
-        valueFlags: [
-            "--home",
-            "--dashboard-url",
-            "--file",
-            "--name",
-            "--exclude",
-            "--to",
-            "--series",
-            "--kind",
-            "--since",
-            "--until",
-            "--limit",
-        ],
-    });
-    // Bare `cockpit notes` is the list, which is the thing a person typing it
-    // almost always wants — same reasoning as bare `cockpit` running convergence.
-    const first = values.positionals[0];
-    const action = (first === undefined ? "list" : first);
-    if (!NOTES_ACTIONS.has(action)) {
-        throw new Error(`Unknown notes command: ${first}. Try list, show, shelf, shelves, upload, paste, share, unshare, or move.`);
-    }
-    const rest = values.positionals.slice(first === undefined ? 0 : 1);
-    const json = values.booleans.has("--json");
-    // `--json` implies `--yes`: a machine-readable run has nobody to prompt, and
-    // failing it for want of a confirmation flag it cannot see is a worse
-    // surprise than an explicit share it already asked for by name.
-    const yes = values.booleans.has("--yes") || json;
-    let noteId;
-    if (NOTES_ACTIONS_NEEDING_A_NOTE.has(action)) {
-        noteId = optionalNonEmpty(rest[0]);
-        if (!noteId)
-            throw new Error(`notes ${action} needs a note id.`);
-        if (rest.length > 1) {
-            throw new Error(`notes ${action} takes one note id, not ${rest.length}.`);
-        }
-    }
-    let paths;
-    if (action === "upload") {
-        // Explicit paths only. No globbing happens here — a shell that expands
-        // `*.md` hands us the names it found, and a shell that does not would have
-        // this command silently uploading a file literally called `*.md`.
-        paths = rest.filter((value) => value.trim() !== "");
-        if (paths.length === 0)
-            throw new Error("notes upload needs at least one file path.");
-    }
-    else if (action !== "paste" && !NOTES_ACTIONS_NEEDING_A_NOTE.has(action) && rest.length > 0) {
-        throw new Error(`notes ${action} does not take "${rest[0]}".`);
-    }
-    const to = optionalNonEmpty(values.flags.get("--to"));
-    const clearShelf = values.booleans.has("--clear-shelf");
-    if (action === "move") {
-        if (to && clearShelf) {
-            throw new Error("notes move accepts either --to or --clear-shelf, not both.");
-        }
-        if (!to && !clearShelf) {
-            throw new Error('notes move needs --to "<shelf>" or --clear-shelf.');
-        }
-    }
-    const limit = optionalPositiveInteger(values.flags.get("--limit"), "--limit");
-    return {
-        kind: "notes",
-        action,
-        homeDir: optionalNonEmpty(values.flags.get("--home")),
-        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
-        ...(noteId ? { noteId } : {}),
-        ...(paths ? { paths } : {}),
-        filePath: optionalNonEmpty(values.flags.get("--file")),
-        name: optionalNonEmpty(values.flags.get("--name")),
-        exclude: optionalNonEmpty(values.flags.get("--exclude")),
-        ...(to ? { to } : {}),
-        ...(clearShelf ? { clearShelf } : {}),
-        series: optionalNonEmpty(values.flags.get("--series")),
-        meetingKind: optionalNonEmpty(values.flags.get("--kind")),
-        since: optionalNonEmpty(values.flags.get("--since")),
-        until: optionalNonEmpty(values.flags.get("--until")),
-        ...(limit === undefined ? {} : { limit }),
-        yes,
-        json,
-    };
-}
-function parseNamedArgs(args, options) {
-    const allowed = new Set(options.allowedFlags);
-    const valueFlags = new Set(options.valueFlags);
-    const flags = new Map();
-    const flagValues = new Map();
-    const booleans = new Set();
-    const positionals = [];
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index] ?? "";
-        rejectServiceRoleLikeArgument(arg);
-        if (!arg.startsWith("--")) {
-            positionals.push(arg);
-            continue;
-        }
-        const [flag, inlineValue] = arg.split("=", 2);
-        if (!allowed.has(flag))
-            throw new Error(`Unknown flag: ${flag}`);
-        if (valueFlags.has(flag)) {
-            const value = inlineValue ?? args[index + 1];
-            if (!value || value.startsWith("--")) {
-                throw new Error(`${flag} requires a value.`);
-            }
-            rejectServiceRoleLikeArgument(value);
-            flags.set(flag, value);
-            const existing = flagValues.get(flag) ?? [];
-            existing.push(value);
-            flagValues.set(flag, existing);
-            if (inlineValue === undefined)
-                index += 1;
-        }
-        else {
-            if (inlineValue !== undefined)
-                throw new Error(`${flag} does not accept a value.`);
-            booleans.add(flag);
-        }
-    }
-    return { flags, flagValues, booleans, positionals };
-}
-function workRootFlagValue(values) {
-    const provided = WORK_ROOT_FLAGS.filter((flag) => values.flags.has(flag));
-    if (provided.length === 0)
-        return undefined;
-    const uniqueValues = new Set(provided.map((flag) => values.flags.get(flag)).filter(Boolean));
-    if (uniqueValues.size > 1) {
-        throw new Error("--repo and --workspace must point to the same path.");
-    }
-    return values.flags.get("--workspace") ?? values.flags.get("--repo");
-}
-function workRootFlagValues(values) {
-    const roots = [];
-    for (const flag of WORK_ROOT_FLAGS) {
-        roots.push(...(values.flagValues.get(flag) ?? []));
-    }
-    return roots;
-}
-function optionalNonEmptyList(values) {
-    const filtered = values
-        .map((value) => optionalNonEmpty(value))
-        .filter((value) => Boolean(value));
-    return filtered.length > 0 ? filtered : undefined;
-}
-function assertNoPositionals(positionals, command) {
-    if (positionals.length > 0) {
-        throw new Error(`${command} does not accept positional arguments.`);
-    }
-}
-function optionalNonEmpty(value) {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : undefined;
-}
-function optionalUrl(value) {
-    return value === undefined ? undefined : normalizeUrl(value);
-}
-function optionalEmail(value) {
-    const trimmed = value?.trim().toLowerCase();
-    if (!trimmed)
-        return undefined;
-    if (!trimmed.includes("@")) {
-        throw new Error("--email must be a valid email address.");
-    }
-    return trimmed;
-}
-function optionalPositiveInteger(value, flag) {
-    if (value === undefined)
-        return undefined;
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < 1) {
-        throw new Error(`${flag} must be a positive integer.`);
-    }
-    return parsed;
-}
-function optionalConfidence(value, flag) {
-    if (value === undefined)
-        return undefined;
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
-        throw new Error(`${flag} must be a number between 0 and 1.`);
-    }
-    return parsed;
-}
-function optionalSchemaValue(schema, value, flag) {
-    const trimmed = optionalNonEmpty(value);
-    if (!trimmed)
-        return undefined;
-    const parsed = schema.safeParse(trimmed);
-    if (!parsed.success || parsed.data === undefined) {
-        throw new Error(`${flag} has an unsupported value.`);
-    }
-    return parsed.data;
-}
-export function normalizeUrl(value) {
-    const trimmed = value.trim().replace(/\/+$/, "");
-    if (!trimmed)
-        throw new Error("URL value cannot be empty.");
-    return trimmed;
-}
-function rejectServiceRoleLikeArgument(value) {
-    if (!looksLikeServiceRoleSecret(value))
-        return;
-    throw new Error("Service-role credentials are not accepted by local collector commands.");
-}
-function looksLikeServiceRoleSecret(value) {
-    if (serviceCredentialNamePattern().test(value))
-        return true;
-    const parts = value.split(".");
-    if (parts.length !== 3)
-        return false;
-    try {
-        const payload = Buffer.from(base64UrlToBase64(parts[1] ?? ""), "base64").toString("utf8");
-        return serviceCredentialPayloadPattern().test(payload);
-    }
-    catch {
-        // Deliberately silent (BLI-3238), and it must stay silent: this is the
-        // "is this argument a service-role JWT?" test, so a value that will not
-        // decode is simply not one. Anything logged here would be a fragment of a
-        // credential.
-        return false;
-    }
-}
-function serviceCredentialNamePattern() {
-    return new RegExp([
-        ["SUPABASE", "SERVICE", "ROLE", "KEY"].join("[_-]?"),
-        ["service", "role"].join("[_-]?"),
-    ].join("|"), "i");
-}
-function serviceCredentialPayloadPattern() {
-    const privilegedRole = ["service", "role"].join("_");
-    return new RegExp(`"role"\\s*:\\s*"${privilegedRole}"`);
-}
-function base64UrlToBase64(value) {
-    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
-    return `${normalized}${"=".repeat((4 - (normalized.length % 4)) % 4)}`;
 }