agent-sdd 1.0.3

package/dist/features/lint/application/RunLint.js

@@ -0,0 +1,100 @@
+import { appendDiagnostic, emptyReport, } from "../domain/Diagnostic.js";
+import { lintRecordsFromMarkdown } from "../domain/SpecParser.js";
+import { applicabilityRequiredRule, approvalRecordRules, assumptionDowngradeApprovalRule, baselineVersionRequiredRule, boundaryConcurrencyModelRule, boundaryPolicyRefRule, dataScopeRequiredRule, debtBudgetFormRule, deprecatedFieldsRequiredRule, fieldTypeRules, generatedArtifactSurfaceRefRule, lifecycleStatusRules, migrationCrossPartitionRule, migrationEnforcementStageRule, openQBlockingRule, partitionDefaultPolicySetRule, REQUIRED_PARTITION_SECTIONS, sectionViolations, testObligationRules, weaselFindings, } from "../domain/Rules.js";
+import { reachableBoundaryIds } from "../../../shared/domain/BoundaryReachability.js";
+import { fileInGlobs } from "../../../shared/domain/GlobMatch.js";
+export async function runLint(cwd, ports) {
+    const config = await ports.config.config(cwd);
+    const entries = await ports.files.resolveSpecFiles(cwd, config.lint.specFiles);
+    let report = emptyReport();
+    for (const entry of entries) {
+        report = lintFileInto(report, entry, config.lint.approverBlocklist, config.lint.partitionGlob);
+    }
+    return report;
+}
+function lintFileInto(report, entry, approverBlocklist, partitionGlob) {
+    let next = report;
+    /*
+     * §2 — section presence. When `lint.partition_glob` is configured, the §2
+     * structure check applies to files whose path matches a glob (OQ-011 / BEH-052);
+     * otherwise it falls back to heading-based detection ("## 1. Context").
+     */
+    const isPartitionFile = partitionGlob.length > 0
+        ? fileInGlobs(entry.path, partitionGlob)
+        : looksLikePartitionFile(entry.content);
+    if (isPartitionFile) {
+        for (const v of sectionViolations(entry.content)) {
+            next = appendDiagnostic(next, {
+                severity: "error",
+                rule: v.rule,
+                file: entry.path,
+                message: v.message,
+            });
+        }
+    }
+    /*
+     * ID-level rules + weasel scan share the parsed records (P0.5: weasel
+     * pass 2 needs them for field-aware modal-verb detection).
+     */
+    const records = lintRecordsFromMarkdown(entry.path, entry.content);
+    const boundaryIds = reachableBoundaryIds(records);
+    /*
+     * §5.1 — weasel words in normative sections (Pass 1) + modal verbs in
+     * normative fields (Pass 2, P0.5).
+     */
+    for (const w of weaselFindings(entry.content, records)) {
+        const where = w.field !== undefined
+            ? `normative field ${w.field}`
+            : `normative section "${w.section}"`;
+        next = appendDiagnostic(next, {
+            severity: "error",
+            rule: "sdd:weasel-word",
+            file: entry.path,
+            line: w.line,
+            message: `Banned phrase "${w.word}" in ${where} (SDD §5.1).`,
+        });
+    }
+    for (const rec of records) {
+        for (const d of [
+            ...lifecycleStatusRules(rec),
+            ...approvalRecordRules(rec),
+            ...testObligationRules(rec),
+            ...fieldTypeRules(rec),
+            /* P1 (ENF-003/009/010/011/012) */
+            ...baselineVersionRequiredRule(rec),
+            ...deprecatedFieldsRequiredRule(rec),
+            ...assumptionDowngradeApprovalRule(rec, approverBlocklist),
+            ...partitionDefaultPolicySetRule(rec),
+            ...generatedArtifactSurfaceRefRule(rec),
+            /* P2.1 — boundary requiredness (ENF-013/014/015/016) */
+            ...boundaryPolicyRefRule(rec, boundaryIds),
+            ...boundaryConcurrencyModelRule(rec, boundaryIds),
+            ...applicabilityRequiredRule(rec, boundaryIds),
+            ...dataScopeRequiredRule(rec, boundaryIds),
+            /* P2.2 — migration consistency (ENF-017/018) */
+            ...migrationEnforcementStageRule(rec, records),
+            ...migrationCrossPartitionRule(rec),
+            /* P3.1 — debt budget form (ENF-020) */
+            ...debtBudgetFormRule(rec),
+            /* unresolved blocking Open-Q (ENF-059) */
+            ...openQBlockingRule(rec),
+        ]) {
+            next = appendDiagnostic(next, d);
+        }
+    }
+    return next;
+}
+function looksLikePartitionFile(markdown) {
+    const firstNumberedHeading = REQUIRED_PARTITION_SECTIONS[0];
+    const re = new RegExp(`^##\\s+${firstNumberedHeading.replace(/\./g, "\\.").replace(/ /g, "\\s+")}`, "m");
+    return re.test(markdown);
+}
+export function diagnosticsByFile(report) {
+    const map = new Map();
+    for (const d of report.diagnostics) {
+        const list = map.get(d.file) ?? [];
+        list.push(d);
+        map.set(d.file, list);
+    }
+    return map;
+}

package/dist/features/lint/domain/Diagnostic.d.ts

@@ -0,0 +1 @@
+export { appendDiagnostic, emptyReport, type Diagnostic, type DiagnosticSeverity, type LintReport, } from "../../../shared/domain/LintReport.js";

package/dist/features/lint/domain/Diagnostic.js

@@ -0,0 +1,2 @@
+/* Re-export shim — content lives in src/shared/domain/LintReport.ts. */
+export { appendDiagnostic, emptyReport, } from "../../../shared/domain/LintReport.js";

package/dist/features/lint/domain/Record.d.ts

@@ -0,0 +1 @@
+export { NORMATIVE_TEMPLATES, VALID_LIFECYCLE_STATUS, type LifecycleStatus, type LintRecord, type LintTemplate, } from "../../../shared/domain/SpecRecord.js";

package/dist/features/lint/domain/Record.js

@@ -0,0 +1,5 @@
+/*
+ * INV-004 / CST-003: re-export shim over src/shared/domain/SpecRecord.ts so
+ * lint and ready share one shape without a cross-feature import. See spec.
+ */
+export { NORMATIVE_TEMPLATES, VALID_LIFECYCLE_STATUS, } from "../../../shared/domain/SpecRecord.js";

package/dist/features/lint/domain/Rules.d.ts

@@ -0,0 +1 @@
+export { applicabilityRequiredRule, approvalRecordRules, assumptionDowngradeApprovalRule, baselineVersionRequiredRule, boundaryConcurrencyModelRule, boundaryPolicyRefRule, dataScopeRequiredRule, deprecatedFieldsRequiredRule, debtBudgetFormRule, fieldTypeRules, generatedArtifactSurfaceRefRule, lifecycleStatusRules, migrationCrossPartitionRule, migrationEnforcementStageRule, NORMATIVE_SECTIONS, openQBlockingRule, partitionDefaultPolicySetRule, REQUIRED_PARTITION_SECTIONS, sectionViolations, testObligationRules, WEASEL_ABSOLUTE, WEASEL_MODAL_IN_NORMATIVE, WEASEL_WORDS, weaselFindings, type SectionViolation, type WeaselFinding, } from "../../../shared/domain/LintRules.js";

package/dist/features/lint/domain/Rules.js

@@ -0,0 +1,2 @@
+/* Re-export shim — content lives in src/shared/domain/LintRules.ts. */
+export { applicabilityRequiredRule, approvalRecordRules, assumptionDowngradeApprovalRule, baselineVersionRequiredRule, boundaryConcurrencyModelRule, boundaryPolicyRefRule, dataScopeRequiredRule, deprecatedFieldsRequiredRule, debtBudgetFormRule, fieldTypeRules, generatedArtifactSurfaceRefRule, lifecycleStatusRules, migrationCrossPartitionRule, migrationEnforcementStageRule, NORMATIVE_SECTIONS, openQBlockingRule, partitionDefaultPolicySetRule, REQUIRED_PARTITION_SECTIONS, sectionViolations, testObligationRules, WEASEL_ABSOLUTE, WEASEL_MODAL_IN_NORMATIVE, WEASEL_WORDS, weaselFindings, } from "../../../shared/domain/LintRules.js";

package/dist/features/lint/domain/SpecParser.d.ts

@@ -0,0 +1 @@
+export { lintRecordsFromMarkdown } from "../../../shared/domain/SpecRecord.js";

package/dist/features/lint/domain/SpecParser.js

@@ -0,0 +1,2 @@
+/* Re-export shim — content lives in src/shared/domain/SpecRecord.ts. */
+export { lintRecordsFromMarkdown } from "../../../shared/domain/SpecRecord.js";

package/dist/features/lint/ports/inbound/LintCommand.d.ts

@@ -0,0 +1,4 @@
+import type { CommandResult, OutputFormat } from "../../../../shared/domain/CliOutput.js";
+export interface LintCommand {
+    execute(cwd: string, format: Exclude<OutputFormat, "yaml">): Promise<CommandResult>;
+}

package/dist/features/lint/ports/inbound/LintCommand.js

@@ -0,0 +1 @@
+export {};

package/dist/features/lint/ports/outbound/LintConfigPort.d.ts

@@ -0,0 +1,4 @@
+import type { SddConfig } from "../../../../shared/domain/Config.js";
+export interface LintConfigPort {
+    config(repoRoot: string): Promise<SddConfig>;
+}

package/dist/features/lint/ports/outbound/LintConfigPort.js

@@ -0,0 +1 @@
+export {};

package/dist/features/lint/ports/outbound/LintFileReader.d.ts

@@ -0,0 +1,10 @@
+export interface SpecFileEntry {
+    /** Path relative to repoRoot. */
+    path: string;
+    /** UTF-8 markdown content. */
+    content: string;
+}
+export interface LintFileReader {
+    /** Resolve glob patterns to a deduplicated list of {path, content} entries. */
+    resolveSpecFiles(repoRoot: string, patterns: readonly string[]): Promise<SpecFileEntry[]>;
+}

package/dist/features/lint/ports/outbound/LintFileReader.js

@@ -0,0 +1 @@
+export {};

package/dist/features/plan/adapters/inbound/CliPlanShowHandler.d.ts

@@ -0,0 +1,8 @@
+import { type CommandResult, type OutputFormat } from "../../../../shared/domain/CliOutput.js";
+import { type ShowPlanPorts } from "../../application/ShowPlan.js";
+import type { PlanShowCommand, PlanShowRequest } from "../../ports/inbound/PlanShowCommand.js";
+export declare class CliPlanShowHandler implements PlanShowCommand {
+    private readonly ports;
+    constructor(ports: ShowPlanPorts);
+    execute(cwd: string, req: PlanShowRequest, format: Exclude<OutputFormat, "yaml">): Promise<CommandResult>;
+}

package/dist/features/plan/adapters/inbound/CliPlanShowHandler.js

@@ -0,0 +1,73 @@
+import { failed, ok, } from "../../../../shared/domain/CliOutput.js";
+import { CliFailure } from "../../../../shared/domain/Errors.js";
+import { showPlan } from "../../application/ShowPlan.js";
+export class CliPlanShowHandler {
+    ports;
+    constructor(ports) {
+        this.ports = ports;
+    }
+    async execute(cwd, req, format) {
+        try {
+            const lookup = await showPlan(cwd, req.planId, this.ports);
+            return renderLookup(lookup, format);
+        }
+        catch (error) {
+            if (error instanceof CliFailure) {
+                return failed(error, format);
+            }
+            throw error;
+        }
+    }
+}
+function renderLookup(lookup, format) {
+    if (lookup.kind === "found") {
+        if (format === "json") {
+            return ok(JSON.stringify({
+                format_version: 1,
+                ok: true,
+                plan: {
+                    plan_id: lookup.plan.planId,
+                    created_at: lookup.plan.createdAt,
+                    pending_attestations: lookup.plan.pendingAttestations.map((a) => ({
+                        id: a.id,
+                        owner_role: a.ownerRole,
+                        approver_identity: a.approverIdentity,
+                        timestamp: a.timestamp,
+                        change_request: a.changeRequest,
+                        scope: a.scope,
+                        target_status: a.targetStatus,
+                        ...(a.reviewedTestOracle !== undefined
+                            ? { reviewed_test_oracle: a.reviewedTestOracle }
+                            : {}),
+                    })),
+                },
+            }));
+        }
+        const lines = [];
+        lines.push(`plan_id: ${lookup.plan.planId}`);
+        lines.push(`created_at: ${lookup.plan.createdAt}`);
+        lines.push(`source: ${lookup.sourcePath}`);
+        lines.push(`pending_attestations: ${lookup.plan.pendingAttestations.length}`);
+        for (const a of lookup.plan.pendingAttestations) {
+            lines.push(`  - ${a.id} → ${a.targetStatus} (approver=${a.approverIdentity}, role=${a.ownerRole})`);
+        }
+        return ok(lines.join("\n"));
+    }
+    if (lookup.kind === "no-active-plan") {
+        return refusal({ format_version: 1, ok: false, kind: "no-active-plan" }, "no active plan", format);
+    }
+    return refusal({
+        format_version: 1,
+        ok: false,
+        kind: "invalid-plan-file",
+        plan_id: lookup.planId,
+        source: lookup.sourcePath,
+        reason: lookup.reason,
+    }, `invalid plan file at ${lookup.sourcePath}: ${lookup.reason}`, format);
+}
+function refusal(envelope, human, format) {
+    if (format === "json") {
+        return { exitCode: 2, stdout: `${JSON.stringify(envelope)}\n`, stderr: "" };
+    }
+    return { exitCode: 2, stdout: "", stderr: `plan show: ${human}\n` };
+}

package/dist/features/plan/adapters/outbound/NodePlanReader.d.ts

@@ -0,0 +1,7 @@
+import { type SddConfig } from "../../../../shared/domain/Config.js";
+import type { PlanConfigPort } from "../../ports/outbound/PlanConfigPort.js";
+import type { PlanLookup, PlanReader } from "../../ports/outbound/PlanReader.js";
+export declare class NodePlanReader implements PlanReader, PlanConfigPort {
+    config(repoRoot: string): Promise<SddConfig>;
+    read(repoRoot: string, plansDir: string, planId: string | undefined): Promise<PlanLookup>;
+}

package/dist/features/plan/adapters/outbound/NodePlanReader.js

@@ -0,0 +1,68 @@
+import { promises as fs } from "node:fs";
+import { resolve, join } from "node:path";
+import { parse as yamlParse } from "yaml";
+import { configFromJson, } from "../../../../shared/domain/Config.js";
+import { errorMessage } from "../../../../shared/domain/Errors.js";
+import { parsePlanFile } from "../../../../shared/domain/PlanFile.js";
+export class NodePlanReader {
+    async config(repoRoot) {
+        const configPath = join(repoRoot, ".sdd", "config.json");
+        const text = await fs.readFile(configPath, "utf8");
+        return configFromJson(JSON.parse(text), configPath);
+    }
+    async read(repoRoot, plansDir, planId) {
+        const dir = resolve(repoRoot, plansDir);
+        const id = planId ?? (await readActiveMarker(dir));
+        if (id === null) {
+            return { kind: "no-active-plan" };
+        }
+        const sourcePath = join(plansDir, `${id}.yaml`);
+        const absolute = resolve(repoRoot, sourcePath);
+        let raw;
+        try {
+            raw = await fs.readFile(absolute, "utf8");
+        }
+        catch {
+            return {
+                kind: "invalid-plan-file",
+                planId: id,
+                sourcePath,
+                reason: "plan file not found",
+            };
+        }
+        let parsed;
+        try {
+            parsed = yamlParse(raw);
+        }
+        catch (e) {
+            return {
+                kind: "invalid-plan-file",
+                planId: id,
+                sourcePath,
+                reason: `YAML parse error: ${errorMessage(e)}`,
+            };
+        }
+        try {
+            const plan = parsePlanFile(parsed);
+            return { kind: "found", planId: plan.planId, plan, sourcePath };
+        }
+        catch (e) {
+            return {
+                kind: "invalid-plan-file",
+                planId: id,
+                sourcePath,
+                reason: errorMessage(e),
+            };
+        }
+    }
+}
+async function readActiveMarker(dir) {
+    try {
+        const raw = await fs.readFile(join(dir, ".active"), "utf8");
+        const id = raw.trim();
+        return id.length > 0 ? id : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/features/plan/application/ShowPlan.d.ts

@@ -0,0 +1,7 @@
+import type { PlanConfigPort } from "../ports/outbound/PlanConfigPort.js";
+import type { PlanLookup, PlanReader } from "../ports/outbound/PlanReader.js";
+export interface ShowPlanPorts {
+    config: PlanConfigPort;
+    reader: PlanReader;
+}
+export declare function showPlan(cwd: string, planId: string | undefined, ports: ShowPlanPorts): Promise<PlanLookup>;

package/dist/features/plan/application/ShowPlan.js

@@ -0,0 +1,4 @@
+export async function showPlan(cwd, planId, ports) {
+    const config = await ports.config.config(cwd);
+    return ports.reader.read(cwd, config.plansDir, planId);
+}

package/dist/features/plan/ports/inbound/PlanShowCommand.d.ts

@@ -0,0 +1,7 @@
+import type { CommandResult, OutputFormat } from "../../../../shared/domain/CliOutput.js";
+export interface PlanShowRequest {
+    planId?: string;
+}
+export interface PlanShowCommand {
+    execute(cwd: string, req: PlanShowRequest, format: Exclude<OutputFormat, "yaml">): Promise<CommandResult>;
+}

package/dist/features/plan/ports/inbound/PlanShowCommand.js

@@ -0,0 +1 @@
+export {};

package/dist/features/plan/ports/outbound/PlanConfigPort.d.ts

@@ -0,0 +1,4 @@
+import type { SddConfig } from "../../../../shared/domain/Config.js";
+export interface PlanConfigPort {
+    config(repoRoot: string): Promise<SddConfig>;
+}

package/dist/features/plan/ports/outbound/PlanConfigPort.js

@@ -0,0 +1 @@
+export {};

package/dist/features/plan/ports/outbound/PlanReader.d.ts

@@ -0,0 +1,19 @@
+import type { PlanFileShape } from "../../../../shared/domain/PlanFile.js";
+export type PlanLookup = {
+    kind: "found";
+    planId: string;
+    plan: PlanFileShape;
+    sourcePath: string;
+} | {
+    kind: "no-active-plan";
+} | {
+    kind: "invalid-plan-file";
+    planId: string;
+    sourcePath: string;
+    reason: string;
+};
+export interface PlanReader {
+    /** Reads and parses the requested plan, or the active plan if `planId` is
+     *  undefined. Returns a discriminated outcome — never throws. */
+    read(repoRoot: string, plansDir: string, planId: string | undefined): Promise<PlanLookup>;
+}

package/dist/features/plan/ports/outbound/PlanReader.js

@@ -0,0 +1 @@
+export {};

package/dist/features/ready/adapters/inbound/CliReadyHandler.d.ts

@@ -0,0 +1,8 @@
+import type { CommandResult, OutputFormat } from "../../../../shared/domain/CliOutput.js";
+import { type RunReadyPorts } from "../../application/RunReady.js";
+import type { ReadyCommand } from "../../ports/inbound/ReadyCommand.js";
+export declare class CliReadyHandler implements ReadyCommand {
+    private readonly ports;
+    constructor(ports: RunReadyPorts);
+    execute(cwd: string, format: Exclude<OutputFormat, "yaml">, partition?: string, against?: string): Promise<CommandResult>;
+}

package/dist/features/ready/adapters/inbound/CliReadyHandler.js

@@ -0,0 +1,79 @@
+import { runReady, } from "../../application/RunReady.js";
+export class CliReadyHandler {
+    ports;
+    constructor(ports) {
+        this.ports = ports;
+    }
+    async execute(cwd, format, partition, against) {
+        let envelope;
+        try {
+            envelope = await runReady(cwd, { partitionFilter: partition, against }, this.ports);
+        }
+        catch (error) {
+            /*
+             * Anything not converted into a ReadyError by RunReady itself is an
+             * internal evaluate-failure (exit 2).
+             */
+            const message = error instanceof Error ? error.message : String(error);
+            envelope = {
+                ok: false,
+                error: { kind: "internal", message },
+                violations: [],
+                advisories: [],
+            };
+        }
+        const exitCode = envelope.error !== null ? 2 : envelope.violations.length > 0 ? 1 : 0;
+        if (format === "json") {
+            return { exitCode, stdout: `${JSON.stringify(envelope)}\n`, stderr: "" };
+        }
+        return humanResult(envelope, exitCode);
+    }
+}
+function humanResult(envelope, exitCode) {
+    if (envelope.error !== null) {
+        return {
+            exitCode,
+            stdout: "",
+            stderr: `${envelope.error.kind}: ${envelope.error.message}${envelope.error.file !== undefined ? ` (${envelope.error.file})` : ""}\n`,
+        };
+    }
+    const lines = [];
+    for (const v of envelope.violations) {
+        lines.push(formatViolationLine(v));
+    }
+    for (const a of envelope.advisories) {
+        lines.push(`[advisory:${a.kind}] ${a.file}:${a.line}  ${truncate(a.remediation, 200)}`);
+    }
+    if (envelope.violations.length === 0) {
+        lines.push("sdd ready: 0 violation(s).");
+        if (envelope.advisories.length > 0) {
+            lines.push(`sdd ready: ${envelope.advisories.length} advisory(ies).`);
+        }
+        return { exitCode: 0, stdout: `${lines.join("\n")}\n`, stderr: "" };
+    }
+    lines.push("");
+    lines.push(`sdd ready: ${envelope.violations.length} violation(s).`);
+    return { exitCode, stdout: `${lines.join("\n")}\n`, stderr: "" };
+}
+function formatViolationLine(v) {
+    const where = v.file !== undefined
+        ? `${v.file}${v.line !== undefined ? `:${v.line}` : ""}`
+        : "(no-file)";
+    const ctx = v.id ?? v.partition ?? "";
+    const remediation = truncate(v.remediation ?? defaultRemediation(v), 200);
+    return `[${v.kind}] ${where}  ${ctx}: ${remediation}`;
+}
+function defaultRemediation(v) {
+    if (v.kind === "removed_compat_action_mismatch" &&
+        v.expected !== undefined &&
+        v.actual !== undefined) {
+        return `expected compatibility_action=${v.expected}, found ${v.actual}`;
+    }
+    return "(see CTR-014)";
+}
+function truncate(value, max) {
+    if (value.length <= max) {
+        return value;
+    }
+    return `${value.slice(0, max - 1)}…`;
+}

package/dist/features/ready/adapters/outbound/ChildProcessReadyGit.d.ts

@@ -0,0 +1,9 @@
+import type { ReadyGitPort } from "../../ports/outbound/ReadyGitPort.js";
+export declare class ChildProcessReadyGit implements ReadyGitPort {
+    isGitRepo(cwd: string): Promise<boolean>;
+    repoRoot(cwd: string): Promise<string>;
+    treeBytes(repoRoot: string, scope: readonly string[]): Promise<Uint8Array>;
+    treePaths(repoRoot: string, scope: readonly string[]): Promise<string[]>;
+    dirtyPaths(repoRoot: string, scope: readonly string[]): Promise<string[]>;
+    readAtRef(repoRoot: string, ref: string, relativePath: string): Promise<string | null>;
+}

package/dist/features/ready/adapters/outbound/ChildProcessReadyGit.js

@@ -0,0 +1,113 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+export class ChildProcessReadyGit {
+    async isGitRepo(cwd) {
+        try {
+            const result = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+            return (result.code === 0 && result.stdout.toString("utf8").trim() === "true");
+        }
+        catch {
+            return false;
+        }
+    }
+    repoRoot(cwd) {
+        let current = resolve(cwd);
+        while (true) {
+            if (existsSync(join(current, ".git"))) {
+                return Promise.resolve(current);
+            }
+            const parent = dirname(current);
+            if (parent === current) {
+                return Promise.reject(new Error("not-a-git-repo"));
+            }
+            current = parent;
+        }
+    }
+    async treeBytes(repoRoot, scope) {
+        const result = await runGit(repoRoot, ["ls-tree", "HEAD", "--", ...scope]);
+        if (result.code !== 0) {
+            throw new Error(result.stderr.toString("utf8").trim() || "git ls-tree failed");
+        }
+        return result.stdout;
+    }
+    async treePaths(repoRoot, scope) {
+        const result = await runGit(repoRoot, [
+            "ls-tree",
+            "-r",
+            "--name-only",
+            "HEAD",
+            "--",
+            ...scope,
+        ]);
+        if (result.code !== 0) {
+            throw new Error(result.stderr.toString("utf8").trim() || "git ls-tree failed");
+        }
+        return nonEmptyLines(result.stdout.toString("utf8"));
+    }
+    async dirtyPaths(repoRoot, scope) {
+        const diffResult = await runGit(repoRoot, [
+            "diff",
+            "--quiet",
+            "HEAD",
+            "--",
+            ...scope,
+        ]);
+        if (diffResult.code !== 0 && diffResult.code !== 1) {
+            throw new Error(diffResult.stderr.toString("utf8").trim() || "git diff --quiet failed");
+        }
+        const result = await runGit(repoRoot, [
+            "status",
+            "--porcelain",
+            "--",
+            ...scope,
+        ]);
+        if (result.code !== 0) {
+            throw new Error(result.stderr.toString("utf8").trim() || "git status failed");
+        }
+        return nonEmptyLines(result.stdout.toString("utf8"))
+            .map((line) => porcelainPath(line))
+            .sort();
+    }
+    async readAtRef(repoRoot, ref, relativePath) {
+        const result = await runGit(repoRoot, ["show", `${ref}:${relativePath}`]);
+        if (result.code !== 0) {
+            return null;
+        }
+        return result.stdout.toString("utf8");
+    }
+}
+function runGit(cwd, args) {
+    return new Promise((resolvePromise, reject) => {
+        const child = spawn("git", [...args], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            if (error.code === "ENOENT") {
+                reject(new Error("git binary is not on PATH"));
+                return;
+            }
+            reject(error);
+        });
+        child.on("close", (code) => {
+            resolvePromise({
+                code: code ?? 1,
+                stdout: Buffer.concat(stdout),
+                stderr: Buffer.concat(stderr),
+            });
+        });
+    });
+}
+function nonEmptyLines(value) {
+    return value.split(/\r?\n/).filter((line) => line.length > 0);
+}
+function porcelainPath(line) {
+    const raw = line.slice(3);
+    const parts = raw.split(" -> ");
+    return parts[parts.length - 1];
+}

package/dist/features/ready/adapters/outbound/NodeReadyFileSystem.d.ts

@@ -0,0 +1,8 @@
+import { type SddConfig } from "../../../../shared/domain/Config.js";
+import type { ReadyConfigPort } from "../../ports/outbound/ReadyConfigPort.js";
+import type { ReadyFileReader, SpecFileEntry, TestFileEntry } from "../../ports/outbound/ReadyFileReader.js";
+export declare class NodeReadyFileSystem implements ReadyConfigPort, ReadyFileReader {
+    config(repoRoot: string): Promise<SddConfig>;
+    resolveSpecFiles(repoRoot: string, patterns: readonly string[]): Promise<SpecFileEntry[]>;
+    resolveTestFiles(repoRoot: string, patterns: readonly string[]): Promise<TestFileEntry[]>;
+}