@deftai/directive 0.126.0-beta.2 → 0.126.0

package/dist/occupancy-steal.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { stealOccupancy } from "@deftai/directive-core/session";
+import { occupancyUnrecognizedArgument } from "./occupancy-unrecognized.js";
+export function parseArgs(argv) {
+    const parsed = { projectRoot: ".", confirm: false, occupant: null };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--confirm") {
+            parsed.confirm = true;
+        }
+        else if (arg === "--occupant") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...parsed, error: "argument --occupant: expected one argument" };
+            }
+            parsed.occupant = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--occupant=")) {
+            const value = arg.slice("--occupant=".length);
+            if (value.length === 0 || value.startsWith("--")) {
+                return { ...parsed, error: "argument --occupant: expected one argument" };
+            }
+            parsed.occupant = value;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            const value = arg.slice("--project-root=".length);
+            if (value.length === 0 || value.startsWith("--")) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+        }
+        else if (arg === "--session-id") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected one argument" };
+            }
+            const sessionId = value.trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
+            i += 1;
+        }
+        else if (arg?.startsWith("--session-id=")) {
+            const sessionId = arg.slice("--session-id=".length).trim();
+            if (sessionId.length === 0 || sessionId.startsWith("--")) {
+                return { ...parsed, error: "argument --session-id: expected a non-empty value" };
+            }
+            parsed.sessionId = sessionId;
+        }
+        else {
+            return { ...parsed, error: occupancyUnrecognizedArgument(arg) };
+        }
+    }
+    return parsed;
+}
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`occupancy:steal: ${args.error}\n`);
+        return 2;
+    }
+    const result = stealOccupancy(resolve(args.projectRoot), {
+        sessionId: args.sessionId,
+        confirm: args.confirm,
+        occupant: args.occupant ?? undefined,
+        env: process.env,
+    });
+    const sink = result.code === 0 ? process.stdout : process.stderr;
+    sink.write(`${result.message}\n`);
+    return result.code;
+}
+//# sourceMappingURL=occupancy-steal.js.map

package/dist/occupancy-unrecognized.d.ts

@@ -0,0 +1,3 @@
+/** Occupancy-namespace parse: unknown flags name the help surface (#4411). */
+export declare function occupancyUnrecognizedArgument(arg: string | undefined): string;
+//# sourceMappingURL=occupancy-unrecognized.d.ts.map

package/dist/occupancy-unrecognized.js

@@ -0,0 +1,5 @@
+/** Occupancy-namespace parse: unknown flags name the help surface (#4411). */
+export function occupancyUnrecognizedArgument(arg) {
+    return `unrecognized argument: ${arg}. See \`deft help\` or \`deft commands\`.`;
+}
+//# sourceMappingURL=occupancy-unrecognized.js.map

package/dist/orchestration-cli/coverage-map.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Wave 8.5 s4 coverage map (#1838): Python CLI tests → TS vitest / existing core coverage.
+ * Used in the PR body table and audited by coverage-map.test.ts.
+ */
+export type CoverageKind = "existing-coverage" | "orchestration-cli-spec";
+export interface CoverageEntry {
+    readonly pythonTest: string;
+    readonly kind: CoverageKind;
+    readonly tsTarget: string;
+    readonly notes?: string;
+}
+export declare const ORCHESTRATION_CLI_PYTHON_TESTS: readonly ["test_pr_check_closing_keywords.py", "test_pr_check_protected_issues.py", "test_pr_merge_readiness.py", "test_pr_merge_readiness_fallbacks.py", "test_pr_wait_mergeable.py", "test_release.py", "test_release_branch_gate.py", "test_release_e2e.py", "test_release_prerelease.py", "test_release_publish.py", "test_release_pyproject_sync.py", "test_release_rollback.py", "test_release_rollback_725.py", "test_release_skip_flags.py", "test_release_subprocess_path.py", "test_release_summary.py", "test_release_tag_availability.py", "test_release_upgrade_banner.py", "test_release_vbrief_lifecycle.py", "test_swarm_complete_cohort.py", "test_swarm_launch.py", "test_swarm_readiness.py", "test_swarm_verify_review_clean.py", "test_swarm_worktrees.py", "test_subagent_monitor.py", "test_probe_session.py", "test_resolve_changelog_unreleased.py", "test_resolve_version.py"];
+export declare const ORCHESTRATION_CLI_COVERAGE_MAP: readonly CoverageEntry[];
+/** Every in-scope Python file must appear at least once in the map. */
+export declare function coverageMapCompleteness(): {
+    ok: boolean;
+    missing: string[];
+};
+/** Markdown table for PR body (#1838 Wave 8.5 s4). */
+export declare function renderCoverageMapMarkdown(): string;
+//# sourceMappingURL=coverage-map.d.ts.map

package/dist/orchestration-cli/coverage-map.js

@@ -0,0 +1,225 @@
+export const ORCHESTRATION_CLI_PYTHON_TESTS = [
+    "test_pr_check_closing_keywords.py",
+    "test_pr_check_protected_issues.py",
+    "test_pr_merge_readiness.py",
+    "test_pr_merge_readiness_fallbacks.py",
+    "test_pr_wait_mergeable.py",
+    "test_release.py",
+    "test_release_branch_gate.py",
+    "test_release_e2e.py",
+    "test_release_prerelease.py",
+    "test_release_publish.py",
+    "test_release_pyproject_sync.py",
+    "test_release_rollback.py",
+    "test_release_rollback_725.py",
+    "test_release_skip_flags.py",
+    "test_release_subprocess_path.py",
+    "test_release_summary.py",
+    "test_release_tag_availability.py",
+    "test_release_upgrade_banner.py",
+    "test_release_vbrief_lifecycle.py",
+    "test_swarm_complete_cohort.py",
+    "test_swarm_launch.py",
+    "test_swarm_readiness.py",
+    "test_swarm_verify_review_clean.py",
+    "test_swarm_worktrees.py",
+    "test_subagent_monitor.py",
+    "test_probe_session.py",
+    "test_resolve_changelog_unreleased.py",
+    "test_resolve_version.py",
+];
+export const ORCHESTRATION_CLI_COVERAGE_MAP = [
+    {
+        pythonTest: "test_pr_check_closing_keywords.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-closing-keywords/main.test.ts",
+        notes: "Offline + gh argv parsing; covered by pr-closing-keywords unit tests.",
+    },
+    {
+        pythonTest: "test_pr_check_protected_issues.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-protected-issues/main.test.ts",
+    },
+    {
+        pythonTest: "test_pr_merge_readiness.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-merge-readiness/main.test.ts",
+        notes: "Greptile parse + gate evaluation",
+    },
+    {
+        pythonTest: "test_pr_merge_readiness_fallbacks.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-merge-readiness/gh.test.ts",
+        notes: "Layered gh fallbacks",
+    },
+    {
+        pythonTest: "test_pr_wait_mergeable.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/pr-wait-mergeable/main.test.ts",
+    },
+    {
+        pythonTest: "test_pr_check_closing_keywords.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/pr-cli.test.ts",
+        notes: "deft-ts pr-closing-keywords argv / exit 2 for missing input",
+    },
+    {
+        pythonTest: "test_pr_merge_readiness.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/pr-cli.test.ts",
+        notes: "deft-ts pr-merge-readiness / pr-protected-issues / pr-wait-mergeable dispatcher",
+    },
+    {
+        pythonTest: "test_release.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/main.test.ts",
+        notes: "Pipeline + changelog promotion",
+    },
+    {
+        pythonTest: "test_release_branch_gate.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline-branches.test.ts",
+    },
+    {
+        pythonTest: "test_release_e2e.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-e2e/main.test.ts",
+    },
+    {
+        pythonTest: "test_release_prerelease.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/version.test.ts",
+    },
+    {
+        pythonTest: "test_release_publish.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-publish/main.test.ts",
+    },
+    {
+        pythonTest: "test_release_pyproject_sync.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pyproject.test.ts",
+    },
+    {
+        pythonTest: "test_release_rollback.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-rollback/rollback.test.ts",
+    },
+    {
+        pythonTest: "test_release_rollback_725.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release-rollback/rollback-coverage.test.ts",
+    },
+    {
+        pythonTest: "test_release_skip_flags.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/flags.test.ts",
+    },
+    {
+        pythonTest: "test_release_subprocess_path.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/python-steps.test.ts",
+    },
+    {
+        pythonTest: "test_release_summary.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline.test.ts",
+    },
+    {
+        pythonTest: "test_release_tag_availability.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/gh.test.ts",
+    },
+    {
+        pythonTest: "test_release_upgrade_banner.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline-branches.test.ts",
+    },
+    {
+        pythonTest: "test_release_vbrief_lifecycle.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/release/pipeline.test.ts",
+    },
+    {
+        pythonTest: "test_release.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/release-cli.test.ts",
+        notes: "deft-ts release / release-publish / release-rollback / release-e2e argv surface",
+    },
+    {
+        pythonTest: "test_swarm_complete_cohort.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/complete-cohort-sweep.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_launch.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/swarm.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_readiness.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/readiness-branches.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_verify_review_clean.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/swarm-branches.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_worktrees.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/swarm/worktrees.test.ts",
+    },
+    {
+        pythonTest: "test_swarm_launch.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/swarm-cli.test.ts",
+        notes: "deft-ts swarm-* dispatcher argv + exit codes",
+    },
+    {
+        pythonTest: "test_subagent_monitor.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/orchestration/orchestration.test.ts",
+    },
+    {
+        pythonTest: "test_probe_session.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/orchestration/orchestration.test.ts",
+    },
+    {
+        pythonTest: "test_subagent_monitor.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/probe-orchestration-cli.test.ts",
+        notes: "deft-ts subagent-monitor / probe-session dispatcher",
+    },
+    {
+        pythonTest: "test_probe_session.py",
+        kind: "orchestration-cli-spec",
+        tsTarget: "packages/cli/src/orchestration-cli/probe-orchestration-cli.test.ts",
+    },
+    {
+        pythonTest: "test_resolve_changelog_unreleased.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/platform/platform.test.ts",
+        notes: "No deft-ts verb; resolve-changelog is platform module",
+    },
+    {
+        pythonTest: "test_resolve_version.py",
+        kind: "existing-coverage",
+        tsTarget: "packages/core/src/platform/branch-coverage.test.ts",
+        notes: "No deft-ts verb; resolve-version is platform module",
+    },
+];
+/** Every in-scope Python file must appear at least once in the map. */
+export function coverageMapCompleteness() {
+    const mapped = new Set(ORCHESTRATION_CLI_COVERAGE_MAP.map((e) => e.pythonTest));
+    const missing = ORCHESTRATION_CLI_PYTHON_TESTS.filter((f) => !mapped.has(f));
+    return { ok: missing.length === 0, missing: [...missing] };
+}
+/** Markdown table for PR body (#1838 Wave 8.5 s4). */
+export function renderCoverageMapMarkdown() {
+    const rows = ORCHESTRATION_CLI_COVERAGE_MAP.map((e) => `| \`${e.pythonTest}\` | ${e.kind} | \`${e.tsTarget}\` | ${e.notes ?? ""} |`);
+    return ["| Python test | Kind | TS target | Notes |", "| --- | --- | --- | --- |", ...rows].join("\n");
+}
+//# sourceMappingURL=coverage-map.js.map

package/dist/orchestration-cli/helpers.d.ts

@@ -0,0 +1,11 @@
+import type { DispatchIo } from "../dispatch.js";
+/** Silent IO sinks for dispatcher / CLI wrapper tests. */
+export declare function silentIo(): DispatchIo;
+/** Capture stderr while keeping stdout silent. */
+export declare function captureStderrIo(): {
+    io: DispatchIo;
+    stderr: string[];
+};
+/** Run a CLI `run()` export without polluting the vitest console. */
+export declare function muteProcessStreams<T>(fn: () => T): T;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/orchestration-cli/helpers.js

@@ -0,0 +1,35 @@
+/** Silent IO sinks for dispatcher / CLI wrapper tests. */
+export function silentIo() {
+    return {
+        writeOut: () => { },
+        writeErr: () => { },
+    };
+}
+/** Capture stderr while keeping stdout silent. */
+export function captureStderrIo() {
+    const stderr = [];
+    return {
+        stderr,
+        io: {
+            writeOut: () => { },
+            writeErr: (text) => {
+                stderr.push(text);
+            },
+        },
+    };
+}
+/** Run a CLI `run()` export without polluting the vitest console. */
+export function muteProcessStreams(fn) {
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = (() => true);
+    process.stderr.write = (() => true);
+    try {
+        return fn();
+    }
+    finally {
+        process.stdout.write = stdoutWrite;
+        process.stderr.write = stderrWrite;
+    }
+}
+//# sourceMappingURL=helpers.js.map

package/dist/ownership-doctor.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export interface OwnershipDoctorArgs {
+    projectRoot: string;
+    json: boolean;
+    owner: string | null;
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): OwnershipDoctorArgs;
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=ownership-doctor.d.ts.map

package/dist/ownership-doctor.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * ownership:doctor / ownership-doctor (#1617)
+ * Diagnose WSL root-runtime vs filesystem project-owner mismatch.
+ * Reachable under mismatch (not blocked by the protected-mutation guard).
+ */
+import { resolve } from "node:path";
+import { evaluateWslOwnershipGuard, OWNERSHIP_FACTS_CLASSIFIER, ownershipGuardToDict, } from "@deftai/directive-core/platform";
+import { isDirectEntrypoint } from "./entrypoint.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        json: false,
+        owner: null,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--") {
+        }
+        else if (arg === "--json") {
+            parsed.json = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--owner") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --owner: expected uid:gid" };
+            }
+            parsed.owner = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--owner=")) {
+            parsed.owner = arg.slice("--owner=".length);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return { ...parsed, error: "__help__" };
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+const HELP = "usage: deft ownership:doctor [--project-root PATH] [--owner uid:gid] [--json]\n" +
+    "Diagnose WSL agent-as-root vs filesystem project-owner mismatch (#1617).\n" +
+    `Classifier: ${OWNERSHIP_FACTS_CLASSIFIER}\n` +
+    "Vocabulary: filesystem project-owner (this command) ≠ occupancy/session owner ≠ issue-emit recovery owner.\n" +
+    "Recovery: deft ownership:fix -- --project-root . [--owner uid:gid]\n";
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error === "__help__") {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`ownership:doctor: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const verdict = evaluateWslOwnershipGuard({
+        projectRoot,
+        explicitOwner: args.owner,
+    });
+    if (args.json) {
+        process.stdout.write(`${JSON.stringify(ownershipGuardToDict(verdict), null, 2)}\n`);
+    }
+    else {
+        for (const line of verdict.messages) {
+            process.stdout.write(`${line}\n`);
+        }
+        if (verdict.intendedOwner.uid !== null) {
+            process.stdout.write(`filesystem project-owner: ${verdict.intendedOwner.uid}:${verdict.intendedOwner.gid}` +
+                `${verdict.intendedOwner.account ? ` (${verdict.intendedOwner.account})` : ""}` +
+                ` via ${verdict.intendedOwner.source}\n`);
+        }
+        process.stdout.write(`status=${verdict.status} wsl=${verdict.wsl} mount=${verdict.mount.capability} ` +
+            `block_protected_mutation=${verdict.blockProtectedMutation}\n`);
+    }
+    if (verdict.status === "fail")
+        return 1;
+    return 0;
+}
+if (isDirectEntrypoint(import.meta.url)) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=ownership-doctor.js.map

package/dist/ownership-fix.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export interface OwnershipFixArgs {
+    projectRoot: string;
+    owner: string | null;
+    json: boolean;
+    error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): OwnershipFixArgs;
+export declare function run(argv: readonly string[]): number;
+//# sourceMappingURL=ownership-fix.d.ts.map

package/dist/ownership-fix.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * ownership:fix / ownership-fix (#1617)
+ * Scoped repair of root-owned objects under approved roots only.
+ * Reachable under mismatch; env-sourced owner alone does not authorize chown.
+ */
+import { resolve } from "node:path";
+import { DEFT_PROJECT_OWNER, fixScopedOwnership, OWNERSHIP_FACTS_CLASSIFIER, } from "@deftai/directive-core/platform";
+import { isDirectEntrypoint } from "./entrypoint.js";
+export function parseArgs(argv) {
+    const parsed = {
+        projectRoot: ".",
+        owner: null,
+        json: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--") {
+        }
+        else if (arg === "--json") {
+            parsed.json = true;
+        }
+        else if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --project-root: expected one argument" };
+            }
+            parsed.projectRoot = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            parsed.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg === "--owner") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --owner: expected uid:gid" };
+            }
+            parsed.owner = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--owner=")) {
+            parsed.owner = arg.slice("--owner=".length);
+        }
+        else if (arg === "--help" || arg === "-h") {
+            return { ...parsed, error: "__help__" };
+        }
+        else {
+            return { ...parsed, error: `unrecognized argument: ${arg}` };
+        }
+    }
+    return parsed;
+}
+const HELP = "usage: deft ownership:fix [--project-root PATH] [--owner uid:gid] [--json]\n" +
+    "Repair root-owned objects under approved project roots only (#1617).\n" +
+    "No blanket HOME chown. No symlink follow outside approved roots.\n" +
+    `Pass --owner uid:gid or ${DEFT_PROJECT_OWNER}=uid:gid when inference is ambiguous.\n` +
+    `Classifier: ${OWNERSHIP_FACTS_CLASSIFIER}\n`;
+export function run(argv) {
+    const args = parseArgs(argv);
+    if (args.error === "__help__") {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`ownership:fix: ${args.error}\n`);
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const result = fixScopedOwnership({
+        projectRoot,
+        explicitOwner: args.owner,
+    });
+    if (args.json) {
+        process.stdout.write(`${JSON.stringify({
+            repaired: result.repaired,
+            skipped_protected: result.skippedProtected,
+            failed: result.failed,
+            messages: result.messages,
+            ok: result.ok,
+        }, null, 2)}\n`);
+    }
+    else {
+        for (const line of result.messages) {
+            process.stdout.write(`${line}\n`);
+        }
+    }
+    return result.exitCode;
+}
+if (isDirectEntrypoint(import.meta.url)) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=ownership-fix.js.map

package/dist/plan-sequence.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+interface Parsed {
+    projectRoot: string;
+    action: "set" | "current" | "clear" | "advance" | null;
+    file: string | null;
+    jsonInline: string | null;
+    emitJson: boolean;
+    expectedGeneration: number | undefined;
+    error?: string;
+}
+export declare function parseArgs(argv: string[]): Parsed;
+export declare function main(argv?: string[]): number;
+export {};
+//# sourceMappingURL=plan-sequence.d.ts.map