@deftai/directive-core 0.55.0

package/dist/session/session-start.js

@@ -0,0 +1,290 @@
+import { randomUUID } from "node:crypto";
+import { disclosureLine } from "../policy/disclosure.js";
+import { resolvePolicy } from "../policy/resolve.js";
+import { runDefaultMode } from "../triage/welcome/default-mode.js";
+import { verifyRequiredTools } from "../verify-env/verify-tools.js";
+import { defaultGitRunner, gitHead, worktreePath } from "./git.js";
+import { newRitualStatePayload, ritualStatePath, ritualStep, writeRitualState, } from "./ritual-sentinel.js";
+export const QUICK_STEPS = ["alignment", "branch_policy", "triage_welcome"];
+export const GATED_STEPS = ["doctor", "cache_fresh"];
+const STEP_ALIASES = {
+    branch: "branch_policy",
+    "branch-policy": "branch_policy",
+    cache: "cache_fresh",
+    "cache-fresh": "cache_fresh",
+    triage: "triage_welcome",
+    "triage-welcome": "triage_welcome",
+};
+function normaliseStepName(name) {
+    return STEP_ALIASES[name] ?? name;
+}
+export function parseDeferrals(rawValues) {
+    const allowed = new Set([...QUICK_STEPS, ...GATED_STEPS]);
+    const deferrals = {};
+    const errors = [];
+    for (const raw of rawValues) {
+        const eq = raw.indexOf("=");
+        if (eq < 0) {
+            errors.push(`--defer expects step=reason, got ${JSON.stringify(raw)}`);
+            continue;
+        }
+        const name = raw.slice(0, eq);
+        const reason = raw.slice(eq + 1);
+        const stepName = normaliseStepName(name.trim());
+        if (!allowed.has(stepName)) {
+            errors.push(`unknown ritual step ${JSON.stringify(name)}; expected one of ${JSON.stringify([...allowed].sort())}`);
+            continue;
+        }
+        if (reason.trim().length === 0) {
+            errors.push(`--defer ${name}=... requires a non-empty reason`);
+            continue;
+        }
+        deferrals[stepName] = reason.trim();
+    }
+    return { deferrals, errors };
+}
+function recordDeferredSteps(steps, deferrals, now) {
+    const out = {};
+    for (const name of steps) {
+        const reason = deferrals[name];
+        if (reason) {
+            out[name] = ritualStep({ ok: true, ts: now, deferredReason: reason });
+        }
+    }
+    return out;
+}
+function defaultBranchCandidates(projectRoot, runGit) {
+    const sym = runGit(projectRoot, ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"]);
+    if (sym.code === 0 && sym.stdout) {
+        const parts = sym.stdout.split("/");
+        return [(parts.slice(1).join("/") || parts[0]) ?? ""];
+    }
+    const candidates = [];
+    for (const branch of ["main", "master"]) {
+        const check = runGit(projectRoot, [
+            "show-ref",
+            "--verify",
+            "--quiet",
+            `refs/remotes/origin/${branch}`,
+        ]);
+        if (check.code === 0) {
+            candidates.push(branch);
+        }
+    }
+    return candidates;
+}
+export function defaultBranchSync(projectRoot, runGit = defaultGitRunner) {
+    const candidates = defaultBranchCandidates(projectRoot, runGit);
+    if (candidates.length === 0) {
+        return {
+            branch: null,
+            upstream: null,
+            ahead: null,
+            behind: null,
+            warning: "[deft branch] Could not resolve a local default branch (`main` or `master`).",
+        };
+    }
+    const branch = candidates[0] ?? null;
+    if (!branch) {
+        return {
+            branch: null,
+            upstream: null,
+            ahead: null,
+            behind: null,
+            warning: "[deft branch] Could not resolve a local default branch (`main` or `master`).",
+        };
+    }
+    const upstreamResult = runGit(projectRoot, ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`]);
+    if (upstreamResult.code !== 0 || !upstreamResult.stdout) {
+        return {
+            branch,
+            upstream: null,
+            ahead: null,
+            behind: null,
+            warning: `[deft branch] Local ${branch} has no upstream tracking branch.`,
+        };
+    }
+    const upstream = upstreamResult.stdout;
+    const slash = upstream.indexOf("/");
+    const remote = slash >= 0 ? upstream.slice(0, slash) : "origin";
+    const remoteBranch = slash >= 0 ? upstream.slice(slash + 1) : upstream;
+    const fetch = runGit(projectRoot, ["fetch", "--quiet", remote, remoteBranch]);
+    if (fetch.code !== 0) {
+        const detail = fetch.stderr || "remote refresh failed";
+        return {
+            branch,
+            upstream,
+            ahead: null,
+            behind: null,
+            warning: `[deft branch] Could not refresh ${upstream} for local ${branch}: ${detail}`,
+        };
+    }
+    const counts = runGit(projectRoot, [
+        "rev-list",
+        "--left-right",
+        "--count",
+        `${branch}...${upstream}`,
+    ]);
+    if (counts.code !== 0 || !counts.stdout) {
+        const detail = counts.stderr || "ahead/behind count failed";
+        return {
+            branch,
+            upstream,
+            ahead: null,
+            behind: null,
+            warning: `[deft branch] Could not compare local ${branch} with ${upstream}: ${detail}`,
+        };
+    }
+    const parts = counts.stdout.trim().split(/\s+/);
+    if (parts.length !== 2) {
+        return {
+            branch,
+            upstream,
+            ahead: null,
+            behind: null,
+            warning: `[deft branch] Could not parse branch sync counts for ${branch} ` +
+                `and ${upstream}: ${counts.stdout}`,
+        };
+    }
+    const ahead = Number.parseInt(parts[0] ?? "", 10);
+    const behind = Number.parseInt(parts[1] ?? "", 10);
+    if (Number.isNaN(ahead) || Number.isNaN(behind)) {
+        return {
+            branch,
+            upstream,
+            ahead: null,
+            behind: null,
+            warning: `[deft branch] Could not parse branch sync counts for ${branch} ` +
+                `and ${upstream}: ${counts.stdout}`,
+        };
+    }
+    if (ahead === 0 && behind === 0) {
+        return { branch, upstream, ahead, behind, warning: null };
+    }
+    let warning;
+    if (ahead > 0 && behind > 0) {
+        warning =
+            `[deft branch] Local ${branch} has diverged from ${upstream} ` +
+                `(${ahead} ahead, ${behind} behind).`;
+    }
+    else if (behind > 0) {
+        const plural = behind === 1 ? "commit" : "commits";
+        warning = `[deft branch] Local ${branch} is behind ${upstream} by ${behind} ${plural}.`;
+    }
+    else {
+        const plural = ahead === 1 ? "commit" : "commits";
+        warning = `[deft branch] Local ${branch} is ahead of ${upstream} by ${ahead} ${plural}.`;
+    }
+    return { branch, upstream, ahead, behind, warning };
+}
+export function runSessionStart(projectRoot, options = {}) {
+    const instant = options.now ?? new Date();
+    const deferrals = options.deferrals ?? {};
+    const runGit = options.runGit ?? defaultGitRunner;
+    const { head: gitHeadValue, error: gitError } = gitHead(projectRoot, runGit);
+    if (gitHeadValue === null) {
+        const payload = {
+            ready: false,
+            message: gitError ?? "could not resolve git HEAD",
+        };
+        return { code: 2, payload, lines: [payload.message] };
+    }
+    const quickSteps = recordDeferredSteps(QUICK_STEPS, deferrals, instant);
+    const gatedSteps = recordDeferredSteps(GATED_STEPS, deferrals, instant);
+    const lines = [];
+    if (!quickSteps.alignment) {
+        const message = "Deft Directive active -- AGENTS.md loaded.";
+        quickSteps.alignment = ritualStep({ ok: true, ts: instant, message });
+        lines.push(message);
+    }
+    if (!quickSteps.branch_policy) {
+        const result = resolvePolicy(projectRoot);
+        const message = disclosureLine(result);
+        const ok = result.error === null || result.source === "default-fail-closed";
+        quickSteps.branch_policy = ritualStep({
+            ok,
+            ts: instant,
+            message,
+            exitCode: ok ? 0 : 2,
+        });
+        lines.push(message);
+        const branchSync = defaultBranchSync(projectRoot, runGit);
+        if (branchSync.warning) {
+            lines.push(branchSync.warning);
+        }
+    }
+    const verifyToolsFn = options.verifyTools ??
+        ((output) => {
+            const toolLines = [];
+            const result = verifyRequiredTools({ outputFn: (line) => toolLines.push(line) });
+            for (const line of toolLines) {
+                output(line);
+            }
+            return { exitCode: result.exitCode };
+        });
+    verifyToolsFn((line) => lines.push(line));
+    if (!quickSteps.triage_welcome) {
+        const captured = [];
+        const triageCommand = ["triage_welcome.run_default_mode", "--project-root", projectRoot];
+        try {
+            const runWelcome = options.runTriageWelcome ??
+                ((root, welcomeOpts) => {
+                    const outcome = runDefaultMode(root, {
+                        output: welcomeOpts.output,
+                        writeHistory: welcomeOpts.writeHistory,
+                    });
+                    return { exitCode: outcome.exitCode };
+                });
+            const outcome = runWelcome(projectRoot, {
+                writeHistory: options.writeHistory !== false,
+                now: instant,
+                output: (line) => captured.push(line),
+            });
+            const ok = outcome.exitCode === 0;
+            const message = captured.join("\n").trim() || "triage welcome completed";
+            quickSteps.triage_welcome = ritualStep({
+                ok,
+                ts: instant,
+                message,
+                exitCode: outcome.exitCode,
+                command: triageCommand,
+            });
+            lines.push(...captured);
+        }
+        catch (exc) {
+            const message = `triage welcome failed: ${String(exc)}`;
+            quickSteps.triage_welcome = ritualStep({
+                ok: false,
+                ts: instant,
+                message,
+                exitCode: 2,
+                command: triageCommand,
+            });
+            lines.push(message);
+        }
+    }
+    const payload = newRitualStatePayload({
+        sessionId: (options.newSessionId ?? randomUUID)(),
+        gitHead: gitHeadValue,
+        worktreePath: worktreePath(projectRoot, runGit),
+        startedAt: instant,
+        quickSteps,
+        gatedSteps,
+    });
+    const statePath = writeRitualState(projectRoot, payload);
+    const failed = Object.entries(quickSteps)
+        .filter(([, step]) => !step.ok && !step.deferred_reason)
+        .map(([name]) => name);
+    const code = failed.length > 0 ? 1 : 0;
+    const resultPayload = {
+        ready: code === 0,
+        exit_code: code,
+        state_path: statePath,
+        quick_steps: quickSteps,
+        gated_steps: gatedSteps,
+        message: code === 0 ? "session ritual recorded" : "session ritual failed",
+    };
+    return { code, payload: resultPayload, lines };
+}
+export { ritualStatePath };
+//# sourceMappingURL=session-start.js.map

package/dist/session/staleness.d.ts

@@ -0,0 +1,8 @@
+export interface SessionRitualStalenessResult {
+    readonly hours: number;
+    readonly source: "default" | "typed" | "default-on-error";
+    readonly error: string | null;
+}
+/** Resolve ``plan.policy.sessionRitualStalenessHours`` (#1348). */
+export declare function resolveSessionRitualStalenessHours(projectRoot: string): SessionRitualStalenessResult;
+//# sourceMappingURL=staleness.d.ts.map

package/dist/session/staleness.js

@@ -0,0 +1,91 @@
+import { loadProjectDefinition } from "../policy/resolve.js";
+const DEFAULT_SESSION_RITUAL_STALENESS_HOURS = 4;
+function pythonTypeName(value) {
+    if (value === null)
+        return "None";
+    if (Array.isArray(value))
+        return "list";
+    if (typeof value === "boolean")
+        return "bool";
+    if (typeof value === "number")
+        return Number.isInteger(value) ? "int" : "float";
+    if (typeof value === "string")
+        return "str";
+    if (typeof value === "object")
+        return "dict";
+    return typeof value;
+}
+function pythonRepr(value) {
+    if (value === undefined)
+        return "None";
+    if (typeof value === "string")
+        return `'${value}'`;
+    if (value === null)
+        return "None";
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    return String(value);
+}
+function validateSessionRitualStalenessHoursValue(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "number" || !Number.isInteger(value)) {
+        return [
+            "plan.policy.sessionRitualStalenessHours must be an integer; got " +
+                `${pythonTypeName(value)} (${pythonRepr(value)})`,
+        ];
+    }
+    if (value <= 0) {
+        return [`plan.policy.sessionRitualStalenessHours must be > 0; got ${value}`];
+    }
+    return [];
+}
+/** Resolve ``plan.policy.sessionRitualStalenessHours`` (#1348). */
+export function resolveSessionRitualStalenessHours(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return {
+            hours: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+            source: "default",
+            error: err,
+        };
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return {
+            hours: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+            source: "default",
+            error: "PROJECT-DEFINITION 'plan' is not an object",
+        };
+    }
+    const policyBlock = plan.policy;
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("sessionRitualStalenessHours" in policyBlock)) {
+        return {
+            hours: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+            source: "default",
+            error: null,
+        };
+    }
+    const raw = policyBlock.sessionRitualStalenessHours;
+    if (raw === null) {
+        return {
+            hours: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+            source: "default",
+            error: null,
+        };
+    }
+    const errors = validateSessionRitualStalenessHoursValue(raw);
+    if (errors.length > 0) {
+        return {
+            hours: DEFAULT_SESSION_RITUAL_STALENESS_HOURS,
+            source: "default-on-error",
+            error: errors[0] ?? null,
+        };
+    }
+    return { hours: raw, source: "typed", error: null };
+}
+//# sourceMappingURL=staleness.js.map

package/dist/session/time.d.ts

@@ -0,0 +1,5 @@
+/** Parse ISO-8601 timestamp (trailing Z or +00:00) into UTC Date. */
+export declare function parseTimestamp(raw: unknown): Date | null;
+/** Format UTC instant as ``YYYY-MM-DDTHH:MM:SSZ`` (Python ritual writer shape). */
+export declare function timestampIso(now?: Date): string;
+//# sourceMappingURL=time.d.ts.map

package/dist/session/time.js

@@ -0,0 +1,19 @@
+/** Parse ISO-8601 timestamp (trailing Z or +00:00) into UTC Date. */
+export function parseTimestamp(raw) {
+    if (typeof raw !== "string" || raw.length === 0) {
+        return null;
+    }
+    const normalised = raw.endsWith("Z") ? `${raw.slice(0, -1)}+00:00` : raw;
+    const parsed = new Date(normalised);
+    if (Number.isNaN(parsed.getTime())) {
+        return null;
+    }
+    return parsed;
+}
+/** Format UTC instant as ``YYYY-MM-DDTHH:MM:SSZ`` (Python ritual writer shape). */
+export function timestampIso(now) {
+    const instant = now ?? new Date();
+    const iso = instant.toISOString();
+    return iso.replace(/\.\d{3}Z$/, "Z");
+}
+//# sourceMappingURL=time.js.map

package/dist/session/verify-session-ritual.d.ts

@@ -0,0 +1,29 @@
+import { type GitRunner } from "./git.js";
+export declare const ENV_SKIP = "DEFT_SESSION_RITUAL_SKIP";
+export { ENTRYPOINT_TIMEOUT_EXIT_CODE, ENTRYPOINT_TIMEOUT_SECONDS, } from "./ritual-entrypoint.js";
+export declare const GATED_ENTRYPOINT_COMMANDS: Readonly<Record<string, readonly string[]>>;
+export interface VerifyResult {
+    readonly code: number;
+    readonly message: string;
+    readonly tier: string;
+    readonly statePath: string;
+    readonly bypassed: boolean;
+    readonly wouldFailCode: number | null;
+}
+export type RitualRunner = (command: readonly string[], projectRoot: string) => {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export interface VerifySessionRitualOptions {
+    readonly tier?: "quick" | "gated";
+    readonly now?: Date;
+    readonly runner?: RitualRunner;
+    readonly bypass?: boolean;
+    readonly envSkip?: string | undefined;
+    readonly runGit?: GitRunner;
+}
+export declare function verifySessionRitual(projectRoot: string, options?: VerifySessionRitualOptions): VerifyResult;
+export declare function emitVerifyJson(result: VerifyResult): string;
+export declare function emitBypassWarning(result: VerifyResult): string;
+//# sourceMappingURL=verify-session-ritual.d.ts.map

package/dist/session/verify-session-ritual.js

@@ -0,0 +1,222 @@
+import { existsSync } from "node:fs";
+import { formatFrameworkCommand } from "../render/framework-commands.js";
+import { defaultGitRunner, gitHead, worktreePath } from "./git.js";
+import { pythonJsonDump } from "./json.js";
+import { defaultRitualRunner } from "./ritual-entrypoint.js";
+import { readRitualState, ritualStatePath, ritualStep, writeRitualState, } from "./ritual-sentinel.js";
+import { GATED_STEPS, QUICK_STEPS } from "./session-start.js";
+import { resolveSessionRitualStalenessHours } from "./staleness.js";
+export const ENV_SKIP = "DEFT_SESSION_RITUAL_SKIP";
+export { ENTRYPOINT_TIMEOUT_EXIT_CODE, ENTRYPOINT_TIMEOUT_SECONDS, } from "./ritual-entrypoint.js";
+export const GATED_ENTRYPOINT_COMMANDS = {
+    doctor: ["doctor"],
+    cache_fresh: ["verify:cache-fresh"],
+};
+function truthy(raw) {
+    return new Set(["1", "true", "yes", "on"]).has((raw ?? "").trim().toLowerCase());
+}
+function stepPasses(step) {
+    if (!step || typeof step !== "object")
+        return false;
+    if (step.deferred_reason)
+        return true;
+    return step.ok === true;
+}
+function failedStepMessage(tierName, stepName, step) {
+    if (step === null || step === undefined) {
+        return (`session ritual ${tierName} step '${stepName}' is missing. ` +
+            `Run \`${formatFrameworkCommand(["session:start"])}\` before implementation dispatch.`);
+    }
+    if (typeof step === "object" &&
+        step !== null &&
+        step.deferred_reason) {
+        return "";
+    }
+    const message = typeof step === "object" && step !== null ? step.message : null;
+    const suffix = typeof message === "string" && message.length > 0 ? `: ${message}` : "";
+    return `session ritual ${tierName} step '${stepName}' failed${suffix}`;
+}
+function runGatedStep(projectRoot, payload, stepName, runner, now) {
+    const command = [...(GATED_ENTRYPOINT_COMMANDS[stepName] ?? [])];
+    const { code, stdout, stderr } = runner(command, projectRoot);
+    const message = stdout.trim() || stderr.trim() || `${command[0] ?? stepName} exited ${code}`;
+    const gated = payload.gated_steps ?? {};
+    gated[stepName] = ritualStep({
+        ok: code === 0,
+        ts: now,
+        exitCode: code,
+        message,
+        command,
+    });
+    payload.gated_steps = gated;
+    try {
+        writeRitualState(projectRoot, payload);
+    }
+    catch (exc) {
+        return `could not write session ritual state after ${stepName}: ${String(exc)}`;
+    }
+    return null;
+}
+function evaluateLoadedState(projectRoot, state, input) {
+    const runGit = input.runGit ?? defaultGitRunner;
+    const { head: currentHead, error: headError } = gitHead(projectRoot, runGit);
+    if (currentHead === null) {
+        return [2, headError ?? "could not resolve git HEAD"];
+    }
+    const currentWorktree = worktreePath(projectRoot, runGit);
+    if (state.worktreePath !== currentWorktree) {
+        return [
+            1,
+            `session ritual state belongs to a different worktree (${state.worktreePath}); run \`${formatFrameworkCommand(["session:start"])}\` here.`,
+        ];
+    }
+    if (state.gitHead !== currentHead) {
+        return [
+            1,
+            `session ritual state is stale because git HEAD changed. Run \`${formatFrameworkCommand(["session:start"])}\` again.`,
+        ];
+    }
+    const staleness = resolveSessionRitualStalenessHours(projectRoot);
+    if (staleness.source === "default-on-error") {
+        return [2, staleness.error ?? "session ritual staleness policy is invalid"];
+    }
+    const maxAgeMs = staleness.hours * 60 * 60 * 1000;
+    if (input.now.getTime() - state.startedAt.getTime() > maxAgeMs) {
+        const startCommand = formatFrameworkCommand(["session:start"]);
+        return [
+            1,
+            `session ritual state is stale (older than ${staleness.hours}h). Run \`${startCommand}\` again.`,
+        ];
+    }
+    for (const stepName of QUICK_STEPS) {
+        const step = state.quickSteps[stepName];
+        if (!stepPasses(step)) {
+            return [1, failedStepMessage("quick", stepName, step)];
+        }
+    }
+    if (input.tier === "gated") {
+        for (const stepName of GATED_STEPS) {
+            const step = state.gatedSteps[stepName];
+            if (!stepPasses(step)) {
+                return [1, failedStepMessage("gated", stepName, step)];
+            }
+        }
+    }
+    return [0, `OK session ritual ${input.tier} tier is fresh.`];
+}
+export function verifySessionRitual(projectRoot, options = {}) {
+    const tier = options.tier ?? "quick";
+    if (tier !== "quick" && tier !== "gated") {
+        return {
+            code: 2,
+            message: `tier must be 'quick' or 'gated', got ${JSON.stringify(tier)}`,
+            tier,
+            statePath: ritualStatePath(projectRoot),
+            bypassed: false,
+            wouldFailCode: null,
+        };
+    }
+    const instant = options.now ?? new Date();
+    const envSkip = options.envSkip ?? process.env[ENV_SKIP];
+    const isBypassed = options.bypass ?? truthy(envSkip);
+    const statePath = ritualStatePath(projectRoot);
+    const missingStateFile = !existsSync(statePath);
+    let [state, err] = readRitualState(projectRoot);
+    if (state === null) {
+        const code = missingStateFile ? 1 : 2;
+        const startCommand = formatFrameworkCommand(["session:start"]);
+        const message = code === 1
+            ? `${err}. Run \`${startCommand}\` before implementation dispatch.`
+            : (err ?? "ritual state invalid");
+        if (isBypassed) {
+            return { code: 0, message, tier, statePath, bypassed: true, wouldFailCode: code };
+        }
+        return { code, message, tier, statePath, bypassed: false, wouldFailCode: null };
+    }
+    if (tier === "gated" && !isBypassed) {
+        const [precheckCode, precheckMessage] = evaluateLoadedState(projectRoot, state, {
+            tier: "quick",
+            now: instant,
+            runGit: options.runGit,
+        });
+        if (precheckCode !== 0) {
+            return {
+                code: precheckCode,
+                message: precheckMessage,
+                tier,
+                statePath,
+                bypassed: false,
+                wouldFailCode: null,
+            };
+        }
+        const payload = { ...state.raw };
+        const gated = { ...payload.gated_steps };
+        payload.gated_steps = gated;
+        const runCmd = options.runner ?? defaultRitualRunner;
+        for (const stepName of GATED_STEPS) {
+            const step = gated[stepName];
+            if (step?.deferred_reason)
+                continue;
+            if (stepPasses(step))
+                continue;
+            const writeError = runGatedStep(projectRoot, payload, stepName, runCmd, instant);
+            if (writeError !== null) {
+                return {
+                    code: 2,
+                    message: writeError,
+                    tier,
+                    statePath,
+                    bypassed: false,
+                    wouldFailCode: null,
+                };
+            }
+        }
+        const reloaded = readRitualState(projectRoot);
+        state = reloaded[0];
+        err = reloaded[1];
+        if (state === null) {
+            return {
+                code: 2,
+                message: err ?? "ritual state invalid after gated update",
+                tier,
+                statePath,
+                bypassed: false,
+                wouldFailCode: null,
+            };
+        }
+    }
+    const [code, message] = evaluateLoadedState(projectRoot, state, {
+        tier,
+        now: instant,
+        runGit: options.runGit,
+    });
+    if (isBypassed) {
+        return {
+            code: 0,
+            message,
+            tier,
+            statePath,
+            bypassed: true,
+            wouldFailCode: code === 0 ? null : code,
+        };
+    }
+    return { code, message, tier, statePath, bypassed: false, wouldFailCode: null };
+}
+export function emitVerifyJson(result) {
+    return pythonJsonDump({
+        ready: result.code === 0,
+        exit_code: result.code,
+        tier: result.tier,
+        message: result.message,
+        state_path: result.statePath,
+        bypassed: result.bypassed,
+        would_fail_code: result.wouldFailCode,
+    });
+}
+export function emitBypassWarning(result) {
+    if (result.bypassed && result.wouldFailCode !== null) {
+        return `[deft] WARNING: ${ENV_SKIP}=1 bypassed a session ritual failure (${result.message})`;
+    }
+    return "";
+}
+//# sourceMappingURL=verify-session-ritual.js.map

package/dist/slice/cli.d.ts

@@ -0,0 +1,21 @@
+import { type RecordExistingArgs } from "./existing.js";
+export interface ParsedCli {
+    readonly command: "record-existing" | "list";
+    readonly recordArgs?: RecordExistingArgs;
+    readonly waveMap: Map<number, number[]>;
+    readonly listProjectRoot?: string | null;
+    readonly listAsJson?: boolean;
+    readonly error?: string;
+}
+/** Parse argv mirroring slice_record_existing.py argparse surface. */
+export declare function parseCli(argv: string[]): ParsedCli;
+/** Run slice CLI and return exit code + captured output. */
+export declare function runCli(argv: string[]): {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+/** CLI entrypoint writing directly to stdio. */
+export declare function main(argv: string[]): number;
+export declare const CLI_HELP = "usage: slice_record_existing.py [-h] {record-existing,list} ... (ported TS CLI)";
+//# sourceMappingURL=cli.d.ts.map