@deftai/directive-core 0.55.0

package/dist/slice/record.js

@@ -0,0 +1,139 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { DEFAULT_SLICES_LOG_REL_PATH } from "./constants.js";
+import { pythonJsonStringify } from "./json.js";
+import { withAppendLock } from "./lock.js";
+import { validateRecord } from "./validate.js";
+const defaultDeps = {
+    readFile: readFileSync,
+    exists: existsSync,
+    append: appendFileSync,
+    fsync: fsyncSync,
+    open: openSync,
+    close: closeSync,
+    mkdir: mkdirSync,
+    withLock: withAppendLock,
+};
+function resolvePath(path) {
+    return path !== undefined ? resolve(path) : resolve(DEFAULT_SLICES_LOG_REL_PATH);
+}
+export function newSliceId() {
+    return randomUUID();
+}
+/** Return the current UTC time in canonical ISO-8601 form with Z suffix (no fractional seconds). */
+export function nowIso() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function parseJsonlIds(logPath, deps, warn) {
+    if (!deps.exists(logPath)) {
+        return new Set();
+    }
+    const seen = new Set();
+    const raw = deps.readFile(logPath, "utf8");
+    const lines = raw.split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+        const stripped = lines[i]?.trim() ?? "";
+        if (stripped.length === 0) {
+            continue;
+        }
+        try {
+            const obj = JSON.parse(stripped);
+            if (obj !== null && typeof obj === "object" && !Array.isArray(obj)) {
+                const sid = obj.slice_id;
+                if (typeof sid === "string") {
+                    seen.add(sid);
+                }
+            }
+        }
+        catch (err) {
+            warn?.(`slices.jsonl: skipping malformed JSON on line ${i + 1}: ${String(err)}`);
+        }
+    }
+    return seen;
+}
+/** Validate + append record without acquiring the sidecar lock. */
+export function writeSliceUnlocked(record, options = {}) {
+    const deps = { ...defaultDeps, ...options.deps };
+    validateRecord(record);
+    const logPath = resolvePath(options.path);
+    deps.mkdir(dirname(logPath), { recursive: true });
+    const resolvedId = String(record.slice_id);
+    const existing = parseJsonlIds(logPath, deps, options.warn);
+    if (existing.has(resolvedId)) {
+        return resolvedId;
+    }
+    const line = `${pythonJsonStringify(record)}\n`;
+    deps.append(logPath, line, { encoding: "utf8" });
+    const fd = deps.open(logPath, "a");
+    try {
+        deps.fsync(fd);
+    }
+    finally {
+        deps.close(fd);
+    }
+    return resolvedId;
+}
+/** Validate and atomically append a cohort record to slices.jsonl. */
+export function writeSlice(umbrella, children, options, deps = {}) {
+    const mergedDeps = { ...defaultDeps, ...deps };
+    const resolvedId = options.sliceId ?? options.newSliceId?.() ?? newSliceId();
+    const record = {
+        slice_id: resolvedId,
+        umbrella,
+        umbrella_url: options.umbrellaUrl,
+        sliced_at: options.slicedAt ?? options.nowIso?.() ?? nowIso(),
+        actor: options.actor,
+        children: [...children].map((child) => ({ ...child })),
+        expected_close_signal: options.expectedCloseSignal ?? "all-children-merged",
+    };
+    if (options.notes !== undefined) {
+        record.notes = options.notes;
+    }
+    const logPath = resolvePath(options.path);
+    return mergedDeps.withLock(logPath, () => writeSliceUnlocked(record, { path: logPath, deps: mergedDeps }));
+}
+/** Return every well-formed slice record in insertion order. */
+export function readAll(options = {}) {
+    const deps = { ...defaultDeps, ...options.deps };
+    const logPath = resolvePath(options.path);
+    if (!deps.exists(logPath)) {
+        return [];
+    }
+    const out = [];
+    const raw = deps.readFile(logPath, "utf8");
+    const lines = raw.split("\n");
+    for (let i = 0; i < lines.length; i += 1) {
+        const stripped = lines[i]?.trim() ?? "";
+        if (stripped.length === 0) {
+            continue;
+        }
+        try {
+            const obj = JSON.parse(stripped);
+            if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+                options.warn?.(`slices.jsonl: skipping non-object entry on line ${i + 1} (got ${obj === null ? "null" : typeof obj})`);
+                continue;
+            }
+            out.push(obj);
+        }
+        catch (err) {
+            options.warn?.(`slices.jsonl: skipping malformed JSON on line ${i + 1}: ${String(err)}`);
+        }
+    }
+    return out;
+}
+export function findBySliceId(sliceId, options = {}) {
+    for (const record of readAll(options)) {
+        if (record.slice_id === sliceId) {
+            return record;
+        }
+    }
+    return null;
+}
+export function findByUmbrella(umbrella, options = {}) {
+    return readAll(options).filter((record) => record.umbrella === umbrella);
+}
+export function slicesPath(projectRoot) {
+    return join(resolve(projectRoot), DEFAULT_SLICES_LOG_REL_PATH);
+}
+//# sourceMappingURL=record.js.map

package/dist/slice/validate.d.ts

@@ -0,0 +1,3 @@
+/** Hand-rolled mirror of vbrief/schemas/slices.schema.json. */
+export declare function validateRecord(record: unknown): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/slice/validate.js

@@ -0,0 +1,86 @@
+import { ALLOWED_FIELDS, CHILD_ALLOWED_FIELDS, CHILD_REQUIRED_FIELDS, ISO8601_RE, REQUIRED_FIELDS, UUID_RE, VALID_EXPECTED_CLOSE_SIGNALS, } from "./constants.js";
+import { SliceRecordError } from "./errors.js";
+function validateChild(child, index) {
+    if (child === null || typeof child !== "object" || Array.isArray(child)) {
+        throw new SliceRecordError(`children[${index}] must be a dict, got ${child === null ? "null" : typeof child}`);
+    }
+    const record = child;
+    const missing = CHILD_REQUIRED_FIELDS.filter((field) => !(field in record));
+    if (missing.length > 0) {
+        throw new SliceRecordError(`children[${index}] missing required field(s): ${missing}`);
+    }
+    const extras = Object.keys(record)
+        .filter((key) => !CHILD_ALLOWED_FIELDS.has(key))
+        .sort();
+    if (extras.length > 0) {
+        throw new SliceRecordError(`children[${index}] has unknown field(s): ${extras}`);
+    }
+    const n = record.n;
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 1) {
+        throw new SliceRecordError(`children[${index}].n must be a positive int, got ${String(n)}`);
+    }
+    const url = record.url;
+    if (typeof url !== "string" || url.length === 0) {
+        throw new SliceRecordError(`children[${index}].url must be a non-empty string, got ${String(url)}`);
+    }
+    const wave = record.wave;
+    if (typeof wave !== "number" || !Number.isInteger(wave) || wave < 1) {
+        throw new SliceRecordError(`children[${index}].wave must be a positive int, got ${String(wave)}`);
+    }
+    const role = record.role;
+    if (typeof role !== "string" || role.length === 0) {
+        throw new SliceRecordError(`children[${index}].role must be a non-empty string, got ${String(role)}`);
+    }
+}
+/** Hand-rolled mirror of vbrief/schemas/slices.schema.json. */
+export function validateRecord(record) {
+    if (record === null || typeof record !== "object" || Array.isArray(record)) {
+        throw new SliceRecordError(`record must be a dict, got ${record === null ? "null" : typeof record}`);
+    }
+    const obj = record;
+    const missing = REQUIRED_FIELDS.filter((field) => !(field in obj));
+    if (missing.length > 0) {
+        throw new SliceRecordError(`record missing required field(s): ${missing}`);
+    }
+    const extras = Object.keys(obj)
+        .filter((key) => !ALLOWED_FIELDS.has(key))
+        .sort();
+    if (extras.length > 0) {
+        throw new SliceRecordError(`record has unknown field(s): ${extras}`);
+    }
+    const sliceId = obj.slice_id;
+    if (typeof sliceId !== "string" || !UUID_RE.test(sliceId)) {
+        throw new SliceRecordError(`slice_id must be a UUID string, got ${String(sliceId)}`);
+    }
+    const umbrella = obj.umbrella;
+    if (typeof umbrella !== "number" || !Number.isInteger(umbrella) || umbrella < 1) {
+        throw new SliceRecordError(`umbrella must be a positive int, got ${String(umbrella)}`);
+    }
+    const umbrellaUrl = obj.umbrella_url;
+    if (typeof umbrellaUrl !== "string" || umbrellaUrl.length === 0) {
+        throw new SliceRecordError(`umbrella_url must be a non-empty string, got ${String(umbrellaUrl)}`);
+    }
+    const slicedAt = obj.sliced_at;
+    if (typeof slicedAt !== "string" || !ISO8601_RE.test(slicedAt)) {
+        throw new SliceRecordError(`sliced_at must be ISO-8601 UTC with Z suffix (e.g. 2026-05-13T18:00:00Z), got ${String(slicedAt)}`);
+    }
+    const actor = obj.actor;
+    if (typeof actor !== "string" || actor.length === 0) {
+        throw new SliceRecordError(`actor must be a non-empty string, got ${String(actor)}`);
+    }
+    const children = obj.children;
+    if (!Array.isArray(children) || children.length === 0) {
+        throw new SliceRecordError("children must be a non-empty list of child records");
+    }
+    for (let i = 0; i < children.length; i += 1) {
+        validateChild(children[i], i);
+    }
+    const expected = obj.expected_close_signal;
+    if (typeof expected !== "string" || !VALID_EXPECTED_CLOSE_SIGNALS.has(expected)) {
+        throw new SliceRecordError(`expected_close_signal must be one of ${[...VALID_EXPECTED_CLOSE_SIGNALS].sort()}, got ${String(expected)}`);
+    }
+    if ("notes" in obj && typeof obj.notes !== "string") {
+        throw new SliceRecordError(`notes must be a string, got ${typeof obj.notes}`);
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/story-ready/allocation.d.ts

@@ -0,0 +1,14 @@
+export declare const ALLOCATION_HEADING = "## Allocation context";
+export declare const SOLO_KIND = "solo";
+export declare const SWARM_COHORT_KIND = "swarm-cohort";
+export declare const VALID_DISPATCH_KINDS: Set<string>;
+/** Strip a parsed field value; return null for null-equivalent tokens. */
+export declare function normaliseValue(raw: string): string | null;
+export type AllocationFields = Record<string, string | null>;
+export type ParsedAllocation = readonly [found: boolean, fields: AllocationFields];
+/**
+ * Parse the `## Allocation context` section from a dispatch envelope.
+ * Pure — no I/O. Never throws.
+ */
+export declare function parseAllocationSection(text: string | null | undefined): ParsedAllocation;
+//# sourceMappingURL=allocation.d.ts.map

package/dist/story-ready/allocation.js

@@ -0,0 +1,61 @@
+export const ALLOCATION_HEADING = "## Allocation context";
+export const SOLO_KIND = "solo";
+export const SWARM_COHORT_KIND = "swarm-cohort";
+export const VALID_DISPATCH_KINDS = new Set([SOLO_KIND, SWARM_COHORT_KIND]);
+const NULL_TOKENS = new Set(["", "null", "none", "n/a"]);
+/** Strip a parsed field value; return null for null-equivalent tokens. */
+export function normaliseValue(raw) {
+    let value = raw.trim();
+    for (const pair of ["``", "`", '"', "'"]) {
+        if (value.length >= 2 * pair.length && value.startsWith(pair) && value.endsWith(pair)) {
+            value = value.slice(pair.length, value.length - pair.length).trim();
+            break;
+        }
+    }
+    if (NULL_TOKENS.has(value.toLowerCase())) {
+        return null;
+    }
+    return value;
+}
+/**
+ * Parse the `## Allocation context` section from a dispatch envelope.
+ * Pure — no I/O. Never throws.
+ */
+export function parseAllocationSection(text) {
+    if (text === null || text === undefined) {
+        return [false, {}];
+    }
+    const lines = text.split(/\r?\n/);
+    let headingIdx = null;
+    for (let idx = 0; idx < lines.length; idx += 1) {
+        if (lines[idx]?.trim() === ALLOCATION_HEADING) {
+            headingIdx = idx;
+            break;
+        }
+    }
+    if (headingIdx === null) {
+        return [false, {}];
+    }
+    const fields = {};
+    for (const line of lines.slice(headingIdx + 1)) {
+        const stripped = line.trim();
+        if (stripped.startsWith("#")) {
+            break;
+        }
+        if (!stripped.startsWith("- ") && !stripped.startsWith("* ")) {
+            continue;
+        }
+        const body = stripped.slice(2);
+        const colonIdx = body.indexOf(":");
+        if (colonIdx === -1) {
+            continue;
+        }
+        const key = body.slice(0, colonIdx).trim().replace(/`/g, "").trim();
+        const value = body.slice(colonIdx + 1);
+        if (key.length > 0) {
+            fields[key] = normaliseValue(value);
+        }
+    }
+    return [true, fields];
+}
+//# sourceMappingURL=allocation.js.map

package/dist/story-ready/evaluate.d.ts

@@ -0,0 +1,23 @@
+import { type PathLike } from "node:fs";
+import { type ParsedAllocation, parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND } from "./allocation.js";
+export declare const ACTIVE_FOLDER = "active";
+export declare const ELIGIBLE_STATUS = "running";
+/** Result of story-start Gate 0 evaluation; mirrors the Python `(exit_code, message)` tuple. */
+export interface EvaluateResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly message: string;
+    readonly dispatchKind: string | null;
+}
+export interface EvaluateOptions {
+    readonly gitStatus?: string | null;
+    readonly allocationContext?: string | null;
+    readonly allowDirty?: boolean;
+    readonly parsed?: ParsedAllocation;
+}
+/**
+ * Pure evaluator — returns exit code + human message. Faithful to
+ * `scripts/preflight_story_start.evaluate`.
+ */
+export declare function evaluate(vbriefPath: PathLike, options?: EvaluateOptions): EvaluateResult;
+export { parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND };
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/story-ready/evaluate.js

@@ -0,0 +1,161 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND, VALID_DISPATCH_KINDS, } from "./allocation.js";
+export const ACTIVE_FOLDER = "active";
+export const ELIGIBLE_STATUS = "running";
+function checkVbrief(vbriefPath) {
+    let path;
+    try {
+        path = resolve(String(vbriefPath));
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: `could not interpret vBRIEF path '${String(vbriefPath)}': ${String(err)}`,
+        };
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            return { ok: false, reason: `target vBRIEF not found at ${path}` };
+        }
+        return {
+            ok: false,
+            reason: `could not read target vBRIEF at ${path}: ${String(e.message ?? err)}`,
+        };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch (err) {
+        const e = err;
+        const line = typeof e.lineNumber === "number" ? e.lineNumber : "?";
+        return {
+            ok: false,
+            reason: `target vBRIEF at ${path} is not valid JSON: ${e.message} (line ${line})`,
+        };
+    }
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        return { ok: false, reason: `target vBRIEF at ${path} top-level value is not a JSON object` };
+    }
+    const folder = path.split(/[/\\]/).slice(-2, -1)[0] ?? "";
+    if (folder !== ACTIVE_FOLDER) {
+        return {
+            ok: false,
+            reason: `target vBRIEF is in ${folder}/ -- only vbrief/active/ is eligible ` +
+                `for a story start (activate it via \`task scope:activate -- ${path}\`)`,
+        };
+    }
+    const plan = payload.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return { ok: false, reason: `target vBRIEF at ${path} lacks a \`plan\` object -- malformed` };
+    }
+    const status = plan.status;
+    if (typeof status !== "string" || status.length === 0) {
+        return { ok: false, reason: `target vBRIEF at ${path} lacks \`plan.status\` -- malformed` };
+    }
+    if (status !== ELIGIBLE_STATUS) {
+        return {
+            ok: false,
+            reason: `target vBRIEF plan.status is '${status}' -- only '${ELIGIBLE_STATUS}' ` +
+                "is eligible for a story start",
+        };
+    }
+    return { ok: true };
+}
+function readyMessage(treeNote, suffix) {
+    return `OK: ready to start -- ${treeNote}, vBRIEF active+running, ${suffix}`;
+}
+function classifyAllocation(fields, treeNote) {
+    const dispatchKind = fields.dispatch_kind ?? null;
+    if (!("dispatch_kind" in fields) || dispatchKind === null) {
+        return {
+            exitCode: 2,
+            dispatchKind: null,
+            message: "config error: `## Allocation context` section is present but has no " +
+                "`dispatch_kind` field -- cannot classify the dispatch (Story A schema " +
+                "requires dispatch_kind: solo | swarm-cohort).",
+        };
+    }
+    if (!VALID_DISPATCH_KINDS.has(dispatchKind)) {
+        return {
+            exitCode: 2,
+            dispatchKind,
+            message: `config error: unrecognised dispatch_kind '${dispatchKind}' -- ` +
+                `expected one of ${[...VALID_DISPATCH_KINDS].sort().join(", ")}.`,
+        };
+    }
+    if (dispatchKind === SOLO_KIND) {
+        return {
+            exitCode: 0,
+            dispatchKind,
+            message: readyMessage(treeNote, "dispatch_kind: solo."),
+        };
+    }
+    const incomplete = ["allocation_plan_id", "batching_rationale"].filter((name) => fields[name] === null || fields[name] === undefined);
+    if (incomplete.length > 0) {
+        return {
+            exitCode: 1,
+            dispatchKind,
+            message: "not ready: swarm-cohort dispatch has an incomplete consent token -- " +
+                `null or missing ${incomplete.join(", ")}. A swarm-cohort start gate ` +
+                "requires a non-null allocation_plan_id AND batching_rationale (#1371 carve-out).",
+        };
+    }
+    return {
+        exitCode: 0,
+        dispatchKind,
+        message: readyMessage(treeNote, "swarm-cohort consent token satisfied (allocation_plan_id + batching_rationale present)."),
+    };
+}
+/**
+ * Pure evaluator — returns exit code + human message. Faithful to
+ * `scripts/preflight_story_start.evaluate`.
+ */
+export function evaluate(vbriefPath, options = {}) {
+    const gitStatus = options.gitStatus ?? null;
+    const allowDirty = options.allowDirty ?? false;
+    if (gitStatus === null) {
+        return {
+            exitCode: 2,
+            dispatchKind: null,
+            message: "config error: could not determine working-tree state -- is this a " +
+                "git work tree and is git on PATH? (Gate 0 fails closed.)",
+        };
+    }
+    const dirty = gitStatus.trim().length > 0;
+    if (dirty && !allowDirty) {
+        return {
+            exitCode: 1,
+            dispatchKind: null,
+            message: "not ready: working tree is dirty. Commit, stash, or include the " +
+                "existing work (re-run with --allow-dirty after operator approval) " +
+                "before starting the story.",
+        };
+    }
+    const treeNote = dirty ? "dirty tree allowed (--allow-dirty)" : "tree clean";
+    const vbriefCheck = checkVbrief(vbriefPath);
+    if (!vbriefCheck.ok) {
+        return {
+            exitCode: 1,
+            dispatchKind: null,
+            message: `not ready: ${vbriefCheck.reason}.`,
+        };
+    }
+    const [found, fields] = options.parsed ?? parseAllocationSection(options.allocationContext ?? null);
+    if (!found) {
+        return {
+            exitCode: 0,
+            dispatchKind: null,
+            message: readyMessage(treeNote, "no `## Allocation context` section (solo path, #1371 carve-out)."),
+        };
+    }
+    return classifyAllocation(fields, treeNote);
+}
+export { parseAllocationSection, SOLO_KIND, SWARM_COHORT_KIND };
+//# sourceMappingURL=evaluate.js.map

package/dist/story-ready/git.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Return raw `git status --porcelain` output, or `null` when undeterminable.
+ * Maps to config error (exit 2) at the evaluator — fail closed, never assume clean.
+ */
+export declare function gitPorcelain(projectRoot: string): string | null;
+//# sourceMappingURL=git.d.ts.map

package/dist/story-ready/git.js

@@ -0,0 +1,26 @@
+import { execFileSync } from "node:child_process";
+/**
+ * Return raw `git status --porcelain` output, or `null` when undeterminable.
+ * Maps to config error (exit 2) at the evaluator — fail closed, never assume clean.
+ */
+export function gitPorcelain(projectRoot) {
+    try {
+        const proc = execFileSync("git", ["status", "--porcelain"], {
+            cwd: projectRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return proc;
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            return null;
+        }
+        if (typeof e.status === "number" && e.status !== 0) {
+            return null;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=git.js.map

package/dist/story-ready/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./allocation.js";
+export * from "./evaluate.js";
+export * from "./git.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/story-ready/index.js

@@ -0,0 +1,4 @@
+export * from "./allocation.js";
+export * from "./evaluate.js";
+export * from "./git.js";
+//# sourceMappingURL=index.js.map

package/dist/subprocess/max-buffer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared stdout ceiling for subprocess captures whose output can be large.
+ *
+ * Node's `spawnSync` / `execFileSync` default to a 1 MB stdout buffer. A
+ * `gh api --paginate` response that concatenates every page (e.g. a repo's
+ * full release or issue list), and other potentially large captures (a
+ * `uv run python` gate, a spawned Node helper), routinely exceed 1 MB. When
+ * they do, the capture aborts with `error.code === "ENOBUFS"`, a `null`
+ * status, truncated stdout, and an EMPTY stderr -- surfacing downstream as a
+ * failure with no detail (#1867: `task release:publish` / `release:rollback`
+ * and consumer `task triage:scope -- --diff-from-upstream`).
+ *
+ * Every subprocess capture site that may produce a large response MUST pass
+ * this ceiling, and MUST surface `result.error.message` when stderr is empty
+ * so an overflow is never silent again.
+ */
+export declare const SUBPROCESS_MAX_BUFFER: number;
+//# sourceMappingURL=max-buffer.d.ts.map

package/dist/subprocess/max-buffer.js

@@ -0,0 +1,18 @@
+/**
+ * Shared stdout ceiling for subprocess captures whose output can be large.
+ *
+ * Node's `spawnSync` / `execFileSync` default to a 1 MB stdout buffer. A
+ * `gh api --paginate` response that concatenates every page (e.g. a repo's
+ * full release or issue list), and other potentially large captures (a
+ * `uv run python` gate, a spawned Node helper), routinely exceed 1 MB. When
+ * they do, the capture aborts with `error.code === "ENOBUFS"`, a `null`
+ * status, truncated stdout, and an EMPTY stderr -- surfacing downstream as a
+ * failure with no detail (#1867: `task release:publish` / `release:rollback`
+ * and consumer `task triage:scope -- --diff-from-upstream`).
+ *
+ * Every subprocess capture site that may produce a large response MUST pass
+ * this ceiling, and MUST surface `result.error.message` when stderr is empty
+ * so an overflow is never silent again.
+ */
+export const SUBPROCESS_MAX_BUFFER = 64 * 1024 * 1024;
+//# sourceMappingURL=max-buffer.js.map

package/dist/swarm/complete-cohort-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare function completeCohortMain(argv?: string[]): number;
+//# sourceMappingURL=complete-cohort-cli.d.ts.map

package/dist/swarm/complete-cohort-cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { completeCohort } from "./complete-cohort.js";
+export function completeCohortMain(argv = process.argv.slice(2)) {
+    const stories = [];
+    const cohortGlobs = [];
+    let projectRoot = ".";
+    let dryRun = false;
+    let emitJson = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--cohort" && argv[i + 1] !== undefined) {
+            cohortGlobs.push(argv[i + 1] ?? "");
+            i += 1;
+        }
+        else if (arg === "--project-root" && argv[i + 1] !== undefined) {
+            projectRoot = argv[i + 1] ?? ".";
+            i += 1;
+        }
+        else if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--json") {
+            emitJson = true;
+        }
+        else if (arg !== undefined && !arg.startsWith("-")) {
+            stories.push(arg);
+        }
+    }
+    const result = completeCohort({ stories, cohortGlobs, projectRoot, dryRun, emitJson });
+    if (result.stdout.length > 0) {
+        process.stdout.write(result.stdout);
+    }
+    if (result.stderr.length > 0) {
+        process.stderr.write(result.stderr);
+    }
+    return result.exitCode;
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(completeCohortMain());
+}
+//# sourceMappingURL=complete-cohort-cli.js.map

package/dist/swarm/complete-cohort.d.ts

@@ -0,0 +1,34 @@
+export interface TransitionRecord {
+    kind: "story" | "epic";
+    path: string;
+    action: string;
+    ok: boolean;
+    detail: string;
+}
+export interface SweepResult {
+    project_root: string;
+    dry_run: boolean;
+    stories: TransitionRecord[];
+    parents: TransitionRecord[];
+    errors: string[];
+    ok: boolean;
+}
+export declare function resolveCohortPaths(positional: readonly string[], cohortGlobs: readonly string[], projectRoot: string): {
+    paths: string[];
+    errors: string[];
+};
+export declare function sweepCohort(storyPaths: readonly string[], projectRoot: string, dryRun: boolean): SweepResult;
+export declare function sweepResultToDict(result: SweepResult): Record<string, unknown>;
+export declare function renderSweepText(result: SweepResult): string;
+export declare function completeCohort(args: {
+    stories?: readonly string[];
+    cohortGlobs?: readonly string[];
+    projectRoot: string;
+    dryRun?: boolean;
+    emitJson?: boolean;
+}): {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+//# sourceMappingURL=complete-cohort.d.ts.map