flanders 0.1.0 → 0.2.0

package/lib/system/ShellScriptContext.d.ts

@@ -0,0 +1,36 @@
+import type { ScriptContext, SpawnedProcess } from "../contexts";
+import type { PlatformContext } from "../workspace/Workspace";
+type SpawnOpts = Parameters<ScriptContext["spawn"]>[2];
+export interface RawSpawnedReadable {
+    on(event: "data", listener: (chunk: Buffer | string) => void): void;
+}
+export interface RawSpawnedStdin {
+    write(chunk: string): unknown;
+    end(): void;
+}
+export interface RawSpawnedChild {
+    pid: number;
+    stdout?: RawSpawnedReadable | null;
+    stderr?: RawSpawnedReadable | null;
+    stdin?: RawSpawnedStdin | null;
+    on(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
+    on(event: "error", listener: (e: unknown) => void): void;
+    kill(signal: "SIGINT" | "SIGTERM"): void;
+}
+export interface RawSpawner {
+    (command: string, args: readonly string[], options: SpawnOpts): RawSpawnedChild;
+}
+export interface KillPrimitive {
+    (pid: number, signal: "SIGINT" | "SIGTERM"): void;
+}
+export declare class ShellScriptContext implements ScriptContext {
+    private _rawSpawn;
+    private _kill;
+    private _platform;
+    constructor(_rawSpawn: RawSpawner, _kill: KillPrimitive, _platform: PlatformContext);
+    spawn(command: string, args: readonly string[], options: SpawnOpts): SpawnedProcess;
+    private _shellLaunch;
+    private _escapePosixArg;
+    private _escapeWindowsArg;
+}
+export {};

package/lib/system/ShellScriptContext.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellScriptContext = void 0;
+class ShellScriptContext {
+    constructor(_rawSpawn, _kill, _platform) {
+        this._rawSpawn = _rawSpawn;
+        this._kill = _kill;
+        this._platform = _platform;
+    }
+    spawn(command, args, options) {
+        const isWindows = this._platform.isWindows();
+        const child = this._shellLaunch(command, args, options, isWindows);
+        const pid = child.pid;
+        const proc = {
+            on(event, listener) {
+                if (event === "exit") {
+                    child.on(event, listener);
+                }
+                else {
+                    child.on(event, listener);
+                }
+            },
+            kill: (signal) => {
+                if (isWindows) {
+                    this._shellLaunch("taskkill", ["/pid", String(pid), "/t", "/f"], {}, true);
+                }
+                else {
+                    this._kill(-pid, signal);
+                }
+            },
+            stdout: child.stdout ? {
+                on(event, listener) {
+                    child.stdout.on(event, listener);
+                }
+            } : undefined,
+            stderr: child.stderr ? {
+                on(event, listener) {
+                    child.stderr.on(event, listener);
+                }
+            } : undefined,
+            stdin: child.stdin ? {
+                write(chunk) {
+                    child.stdin.write(chunk);
+                },
+                end() {
+                    child.stdin.end();
+                }
+            } : undefined
+        };
+        return proc;
+    }
+    _shellLaunch(command, args, options, isWindows) {
+        const escapedArgs = args.map(a => isWindows ? this._escapeWindowsArg(a) : this._escapePosixArg(a));
+        const commandLine = [command, ...escapedArgs].join(" ");
+        const spawnOptions = isWindows
+            ? { ...options, shell: true }
+            : { ...options, shell: true, detached: true };
+        return this._rawSpawn(commandLine, [], spawnOptions);
+    }
+    _escapePosixArg(arg) {
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+    }
+    _escapeWindowsArg(arg) {
+        let escaped = arg.replace(/(\\*)"/g, '$1$1\\"');
+        escaped = escaped.replace(/(\\*)$/, '$1$1');
+        escaped = `"${escaped}"`;
+        return escaped.replace(/[()%!^"<>&|]/g, c => `^${c}`);
+    }
+}
+exports.ShellScriptContext = ShellScriptContext;

package/lib/{fsUtils.d.ts → system/fsUtils.d.ts}

@@ -1,4 +1,4 @@
-import type { FsContext } from "./contexts";
+import type { FsContext } from "../contexts";
 export declare function listFilesRecursive(fs: FsContext, root: string): Promise<string[]>;
 export declare function joinPath(...parts: string[]): string;
 export declare function fileSize(fs: FsContext, path: string): Promise<number>;

package/lib/{wait.d.ts → system/wait.d.ts}

@@ -1,2 +1,2 @@
-import type { TimeContext } from "./contexts";
+import type { TimeContext } from "../contexts";
 export declare function wait(durationMs: number, chunkMs: number, time: TimeContext, signal: AbortSignal): Promise<void>;

package/lib/ui/BottomBlock.d.ts

@@ -1,10 +1,12 @@
 import type { TimeContext } from "../contexts";
+import type { ReviewerEntry } from "./formatters";
+export type { ReviewerEntry, ReviewerState, ReviewerTool } from "./formatters";
 export type BottomBlockIO = {
     write(text: string): void;
     columns(): number;
     onResize(listener: () => void): () => void;
 };
-export type Activity = "implementing" | "reviewing" | "building" | "testing";
+export type Activity = "preparing" | "implementing" | "reviewing" | "building" | "testing";
 export type HeaderFields = {
     indexLabel?: string | null;
     iteration?: number | null;
@@ -27,10 +29,15 @@ export type FooterState = {
     kind: "blank";
 } | {
     kind: "working";
+} | {
+    kind: "preparing";
 } | {
     kind: "waiting";
     waitKind: WaitKind;
     endTime: number;
+} | {
+    kind: "reviewing";
+    reviewers: readonly ReviewerEntry[];
 } | {
     kind: "terminal";
     label: TerminalLabel;
@@ -49,6 +56,7 @@ export declare class BottomBlock {
     private _animTimer;
     private _countdownTimer;
     private _unsubResize;
+    private _prevLineWidths;
     constructor(_io: BottomBlockIO, _time: TimeContext);
     mount(): void;
     isFinalized(): boolean;

package/lib/ui/BottomBlock.js

@@ -7,11 +7,10 @@ const WAIT_HEADINGS = {
 };
 const FRAMES = ["⣋", "⣙", "⣹", "⣸", "⣼", "⣴", "⣦", "⣧", "⣇", "⣏"];
 const FRAME_MS = 200;
-const ORANGE = "\x1b[38;5;208m";
-const RESET = "\x1b[0m";
-const CURSOR_UP_3 = "\x1b[3A";
-const CLEAR_TO_END = "\x1b[J";
+const AUTOWRAP_OFF = "\x1b[?7l";
+const AUTOWRAP_ON = "\x1b[?7h";
 const CR = "\r";
+const CLEAR_TO_END = "\x1b[J";
 class BottomBlock {
     constructor(_io, _time) {
         this._io = _io;
@@ -26,6 +25,7 @@ class BottomBlock {
         this._animTimer = null;
         this._countdownTimer = null;
         this._unsubResize = null;
+        this._prevLineWidths = null;
     }
     mount() {
         if (this._disposed)
@@ -66,7 +66,7 @@ class BottomBlock {
             return;
         this._cancelTimers();
         this._footer = state;
-        if (state.kind === "working") {
+        if (state.kind === "working" || state.kind === "preparing") {
             this._animFrame = 0;
         }
         if (this._mounted) {
@@ -125,7 +125,7 @@ class BottomBlock {
         }
     }
     _startFooterTimer() {
-        if (this._footer.kind === "working") {
+        if (this._footer.kind === "working" || this._footer.kind === "preparing") {
             this._scheduleAnimTick();
         }
         else if (this._footer.kind === "waiting") {
@@ -135,7 +135,7 @@ class BottomBlock {
     _scheduleAnimTick() {
         this._animTimer = this._time.setTimeout(() => {
             this._animTimer = null;
-            if (this._disposed || this._finalized || this._footer.kind !== "working")
+            if (this._disposed || this._finalized || (this._footer.kind !== "working" && this._footer.kind !== "preparing"))
                 return;
             this._animFrame = (this._animFrame + 1) % FRAMES.length;
             this._clearBlock();
@@ -154,15 +154,27 @@ class BottomBlock {
         }, 1000);
     }
     _clearBlock() {
-        this._io.write(CURSOR_UP_3 + CR + CLEAR_TO_END);
+        if (!this._prevLineWidths)
+            return;
+        const cols = Math.max(1, this._io.columns());
+        let rows = 0;
+        for (const w of this._prevLineWidths) {
+            rows += Math.max(1, Math.ceil(w / cols));
+        }
+        let clear = `\x1b[${rows - 1}A` + CR + CLEAR_TO_END;
+        if (rows > 4) {
+            clear += `\x1b[${rows - 4}B`;
+        }
+        this._io.write(clear);
     }
     _drawBlock() {
         const cols = Math.max(0, this._io.columns());
         const separator = formatters_1.SEPARATOR_GLYPH.repeat(cols);
         const header = this._renderHeader(cols);
         const metrics = this._renderMetrics(cols);
-        const footer = this._renderFooter();
-        this._io.write(separator + "\n" + header + "\n" + metrics + "\n" + footer);
+        const footer = this._renderFooter(cols);
+        this._io.write(AUTOWRAP_OFF + separator + "\n" + header + "\n" + metrics + "\n" + footer + AUTOWRAP_ON);
+        this._prevLineWidths = [cols, (0, formatters_1.stripAnsi)(header).length, (0, formatters_1.stripAnsi)(metrics).length, (0, formatters_1.stripAnsi)(footer).length];
     }
     _renderHeader(cols) {
         var _a, _b, _c, _d, _e;
@@ -171,20 +183,24 @@ class BottomBlock {
     _renderMetrics(cols) {
         return (0, formatters_1.formatMetricsLine)(this._metrics.task, this._metrics.plan, cols);
     }
-    _renderFooter() {
+    _renderFooter(cols) {
         switch (this._footer.kind) {
             case "blank":
                 return "";
             case "working":
-                return `${ORANGE}${FRAMES[this._animFrame]} Working${RESET}`;
+                return (0, formatters_1.formatWorkingFooter)(FRAMES[this._animFrame], cols);
+            case "preparing":
+                return (0, formatters_1.formatPreparingFooter)(FRAMES[this._animFrame], cols);
             case "waiting": {
                 const remaining = Math.max(0, this._footer.endTime - this._time.now());
                 const dateStr = (0, formatters_1.formatDateTime)(new Date(this._footer.endTime));
                 const countdown = (0, formatters_1.formatCountdown)(remaining);
-                return `${ORANGE}${WAIT_HEADINGS[this._footer.waitKind]} — ${dateStr} — ${countdown}${RESET}`;
+                return (0, formatters_1.formatWaitingFooter)(WAIT_HEADINGS[this._footer.waitKind], dateStr, countdown, cols);
             }
+            case "reviewing":
+                return (0, formatters_1.formatReviewingFooter)(this._footer.reviewers, cols);
             case "terminal":
-                return `${ORANGE}${this._footer.label}${RESET}`;
+                return `${formatters_1.ORANGE}${this._footer.label}${formatters_1.RESET}`;
         }
     }
 }

package/lib/ui/PromptHelper.d.ts

@@ -0,0 +1,12 @@
+import type { AskContext, ChoiceOption, OutputContext } from "../contexts";
+export type AskChoiceArgs = Readonly<{
+    header: string;
+    question: string;
+    options: readonly ChoiceOption[];
+}>;
+export type AskTextArgs = Readonly<{
+    question: string;
+    placeholder?: string;
+}>;
+export declare function askChoice(ask: AskContext, args: AskChoiceArgs, output?: OutputContext): Promise<ChoiceOption>;
+export declare function askText(ask: AskContext, args: AskTextArgs): Promise<string>;

package/lib/ui/PromptHelper.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askChoice = askChoice;
+exports.askText = askText;
+function abortError() {
+    const e = new Error("Aborted");
+    e.name = "AbortError";
+    return e;
+}
+async function askChoice(ask, args, output) {
+    const [answer] = await ask.askChoices([{
+            header: args.header,
+            question: args.question,
+            options: args.options,
+            multiSelect: false
+        }], output);
+    if (!answer || answer.picked.length === 0) {
+        throw abortError();
+    }
+    return answer.picked[0];
+}
+async function askText(ask, args) {
+    const prompt = args.placeholder
+        ? `${args.question} (${args.placeholder}): `
+        : `${args.question}: `;
+    try {
+        return await ask.askText(prompt);
+    }
+    catch {
+        throw abortError();
+    }
+}

package/lib/ui/TerminalSizeSource.d.ts

@@ -0,0 +1,19 @@
+import type { TimeContext } from "../contexts";
+export type TerminalSize = Readonly<{
+    columns: number;
+    rows: number;
+}>;
+export type RawTerminalSizeReader = () => TerminalSize | null;
+export type NativeResizeSubscriber = (listener: () => void) => () => void;
+export declare class TerminalSizeSource {
+    #private;
+    private _read;
+    private _subscribeNative;
+    private _time;
+    private _pollMs;
+    constructor(_read: RawTerminalSizeReader, _subscribeNative: NativeResizeSubscriber, _time: TimeContext, _pollMs: number);
+    columns(): number;
+    rows(): number;
+    onResize(listener: () => void): () => void;
+    dispose(): void;
+}

package/lib/ui/TerminalSizeSource.js

@@ -0,0 +1,77 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TerminalSizeSource_teardowns;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalSizeSource = void 0;
+const FALLBACK_COLUMNS = 80;
+const FALLBACK_ROWS = 24;
+class TerminalSizeSource {
+    constructor(_read, _subscribeNative, _time, _pollMs) {
+        this._read = _read;
+        this._subscribeNative = _subscribeNative;
+        this._time = _time;
+        this._pollMs = _pollMs;
+        _TerminalSizeSource_teardowns.set(this, new Set());
+    }
+    columns() {
+        const size = this._read();
+        return size && size.columns > 0 ? size.columns : FALLBACK_COLUMNS;
+    }
+    rows() {
+        const size = this._read();
+        return size && size.rows > 0 ? size.rows : FALLBACK_ROWS;
+    }
+    onResize(listener) {
+        const initial = this._read();
+        let lastColumns = initial ? initial.columns : FALLBACK_COLUMNS;
+        let lastRows = initial ? initial.rows : FALLBACK_ROWS;
+        let pollTimer = null;
+        let stopped = false;
+        const fireIfChanged = () => {
+            const size = this._read();
+            if (!size)
+                return;
+            if (size.columns === lastColumns && size.rows === lastRows)
+                return;
+            lastColumns = size.columns;
+            lastRows = size.rows;
+            listener();
+        };
+        const schedulePoll = () => {
+            pollTimer = this._time.setTimeout(() => {
+                pollTimer = null;
+                fireIfChanged();
+                if (!stopped)
+                    schedulePoll();
+            }, this._pollMs);
+        };
+        const unsubNative = this._subscribeNative(fireIfChanged);
+        schedulePoll();
+        const teardown = () => {
+            stopped = true;
+            if (pollTimer) {
+                pollTimer.cancel();
+                pollTimer = null;
+            }
+            unsubNative();
+        };
+        __classPrivateFieldGet(this, _TerminalSizeSource_teardowns, "f").add(teardown);
+        return () => {
+            if (!__classPrivateFieldGet(this, _TerminalSizeSource_teardowns, "f").delete(teardown))
+                return;
+            teardown();
+        };
+    }
+    dispose() {
+        for (const teardown of [...__classPrivateFieldGet(this, _TerminalSizeSource_teardowns, "f")]) {
+            teardown();
+        }
+        __classPrivateFieldGet(this, _TerminalSizeSource_teardowns, "f").clear();
+    }
+}
+exports.TerminalSizeSource = TerminalSizeSource;
+_TerminalSizeSource_teardowns = new WeakMap();

package/lib/ui/formatters.d.ts

@@ -4,9 +4,11 @@ export declare const MAGENTA = "\u001B[35m";
 export declare const GREEN = "\u001B[32m";
 export declare const BLUE = "\u001B[34m";
 export declare const DIM = "\u001B[2m";
+export declare const ORANGE = "\u001B[38;5;208m";
 export declare const RESET = "\u001B[0m";
 export declare const SEPARATOR_GLYPH = "\u2500";
 export declare function colorize(text: string, code: string): string;
+export declare function stripAnsi(s: string): string;
 export type Segment = {
     text: string;
     color?: string;
@@ -27,3 +29,15 @@ export declare function formatMetricsLine(task: MetricsPair | undefined, plan: M
 export declare function formatSnapshotHeader(indexLabel: string, iteration: number, taskNumber: string | undefined, title: string): string;
 export declare function formatSnapshotMetrics(taskTokens: number, taskSeconds: number, planTokens: number, planSeconds: number): string;
 export declare function formatSnapshotBlock(indexLabel: string, iteration: number, taskNumber: string | undefined, title: string, taskTokens: number, taskSeconds: number, planTokens: number, planSeconds: number, cols: number): string;
+export type ReviewerTool = "claude" | "codex";
+export type ReviewerState = "running" | "waiting" | "ok" | "fail";
+export type ReviewerEntry = {
+    tool: ReviewerTool;
+    model: string;
+    effort: string;
+    state: ReviewerState;
+};
+export declare function formatReviewingFooter(reviewers: readonly ReviewerEntry[], cols: number): string;
+export declare function formatWorkingFooter(frame: string, cols: number): string;
+export declare function formatPreparingFooter(frame: string, cols: number): string;
+export declare function formatWaitingFooter(heading: string, dateTime: string, countdown: string, cols: number): string;

package/lib/ui/formatters.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEPARATOR_GLYPH = exports.RESET = exports.DIM = exports.BLUE = exports.GREEN = exports.MAGENTA = exports.YELLOW = exports.CYAN = void 0;
+exports.SEPARATOR_GLYPH = exports.RESET = exports.ORANGE = exports.DIM = exports.BLUE = exports.GREEN = exports.MAGENTA = exports.YELLOW = exports.CYAN = void 0;
 exports.colorize = colorize;
+exports.stripAnsi = stripAnsi;
 exports.renderSegments = renderSegments;
 exports.renderSegmentsToWidth = renderSegmentsToWidth;
 exports.formatCountdown = formatCountdown;
@@ -14,17 +15,25 @@ exports.formatMetricsLine = formatMetricsLine;
 exports.formatSnapshotHeader = formatSnapshotHeader;
 exports.formatSnapshotMetrics = formatSnapshotMetrics;
 exports.formatSnapshotBlock = formatSnapshotBlock;
+exports.formatReviewingFooter = formatReviewingFooter;
+exports.formatWorkingFooter = formatWorkingFooter;
+exports.formatPreparingFooter = formatPreparingFooter;
+exports.formatWaitingFooter = formatWaitingFooter;
 exports.CYAN = "\x1b[36m";
 exports.YELLOW = "\x1b[33m";
 exports.MAGENTA = "\x1b[35m";
 exports.GREEN = "\x1b[32m";
 exports.BLUE = "\x1b[34m";
 exports.DIM = "\x1b[2m";
+exports.ORANGE = "\x1b[38;5;208m";
 exports.RESET = "\x1b[0m";
 exports.SEPARATOR_GLYPH = "─";
 function colorize(text, code) {
     return code + text + exports.RESET;
 }
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[?\d;]*[a-zA-Z]/g, "");
+}
 function renderSegments(segments) {
     let result = "";
     for (const seg of segments) {
@@ -105,7 +114,7 @@ function formatActiveTime(seconds) {
     const m = Math.floor((s % 3600) / 60);
     return `${h}h${pad2(m)}m${pad2(s % 60)}s`;
 }
-const LIVE_ACTIVITIES = new Set(["implementing", "reviewing", "building", "testing"]);
+const LIVE_ACTIVITIES = new Set(["preparing", "implementing", "reviewing", "building", "testing"]);
 function formatHeaderLine(indexLabel, iteration, activity, taskNumber, title, cols) {
     const segments = [];
     if (indexLabel != null) {
@@ -219,3 +228,57 @@ function formatSnapshotBlock(indexLabel, iteration, taskNumber, title, taskToken
     const metrics = formatSnapshotMetrics(taskTokens, taskSeconds, planTokens, planSeconds);
     return sep + "\n" + header + "\n" + metrics + "\n" + sep + "\n";
 }
+function reviewerEntryDescriptor(model, effort) {
+    const modelToken = model === "" ? "default" : model;
+    if (effort === model) {
+        return `(${modelToken})`;
+    }
+    const effortToken = effort === "" ? "default" : effort;
+    return `(${modelToken} ${effortToken})`;
+}
+function buildReviewingFullText(reviewers) {
+    let line = "review: ";
+    for (let i = 0; i < reviewers.length; i++) {
+        const r = reviewers[i];
+        if (i > 0)
+            line += ", ";
+        line += `${r.tool} ${reviewerEntryDescriptor(r.model, r.effort)}: ${r.state}`;
+    }
+    return line;
+}
+function buildReviewingCompactText(reviewers) {
+    let line = "review: ";
+    for (let i = 0; i < reviewers.length; i++) {
+        const r = reviewers[i];
+        if (i > 0)
+            line += ", ";
+        line += `${r.tool}: ${r.state}`;
+    }
+    return line;
+}
+function formatReviewingFooter(reviewers, cols) {
+    const fullText = buildReviewingFullText(reviewers);
+    if (fullText.length <= cols) {
+        return renderSegments([{ text: fullText, color: exports.ORANGE }]);
+    }
+    const compactText = buildReviewingCompactText(reviewers);
+    if (compactText.length <= cols) {
+        return renderSegments([{ text: compactText, color: exports.ORANGE }]);
+    }
+    return renderSegmentsToWidth([{ text: compactText, color: exports.ORANGE }], cols);
+}
+function fitOrangeFooterLine(text, cols) {
+    if (text.length <= cols) {
+        return renderSegments([{ text, color: exports.ORANGE }]);
+    }
+    return renderSegmentsToWidth([{ text, color: exports.ORANGE }], cols);
+}
+function formatWorkingFooter(frame, cols) {
+    return fitOrangeFooterLine(`${frame} Working`, cols);
+}
+function formatPreparingFooter(frame, cols) {
+    return fitOrangeFooterLine(`${frame} Preparing`, cols);
+}
+function formatWaitingFooter(heading, dateTime, countdown, cols) {
+    return fitOrangeFooterLine(`${heading} — ${dateTime} — ${countdown}`, cols);
+}

package/lib/workspace/FlandersConfig.d.ts

@@ -0,0 +1,23 @@
+import type { FsContext } from "../contexts";
+export type FlandersRole = Readonly<{
+    tool: "claude" | "codex";
+    model: string;
+    effort: string;
+}>;
+export type FlandersConfig = Readonly<{
+    worker: FlandersRole;
+    reviewers: readonly FlandersRole[];
+}>;
+type ReadArgs = Readonly<{
+    projectRoot: string;
+    homeDir: string;
+}>;
+type WriteArgs = Readonly<{
+    scope: "project" | "global";
+    projectRoot: string;
+    homeDir: string;
+    config: FlandersConfig;
+}>;
+export declare function read(fs: FsContext, args: ReadArgs): Promise<FlandersConfig | null>;
+export declare function write(fs: FsContext, args: WriteArgs): Promise<string>;
+export {};

package/lib/workspace/FlandersConfig.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.read = read;
+exports.write = write;
+const fsUtils_1 = require("../system/fsUtils");
+const CONFIG_PATH = ".flanders/config.json";
+const CONFIG_DIR = ".flanders";
+function configPath(base) {
+    return (0, fsUtils_1.joinPath)(base, CONFIG_PATH);
+}
+function configDir(base) {
+    return (0, fsUtils_1.joinPath)(base, CONFIG_DIR);
+}
+function validate(raw, filePath) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error(`Malformed config at ${filePath}: expected a JSON object`);
+    }
+    const obj = raw;
+    if (!("worker" in obj) || typeof obj["worker"] !== "object" || obj["worker"] === null || Array.isArray(obj["worker"])) {
+        throw new Error(`Malformed config at ${filePath}: missing or invalid field "worker"`);
+    }
+    if (!("reviewers" in obj) || !Array.isArray(obj["reviewers"])) {
+        throw new Error(`Malformed config at ${filePath}: missing or invalid field "reviewers"`);
+    }
+    const reviewers = obj["reviewers"];
+    if (reviewers.length === 0) {
+        throw new Error(`Malformed config at ${filePath}: field "reviewers" must be a non-empty array`);
+    }
+    validateRole(obj["worker"], "worker", filePath);
+    for (let i = 0; i < reviewers.length; i++) {
+        const entry = reviewers[i];
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            throw new Error(`Malformed config at ${filePath}: missing or invalid field "reviewers[${i}]"`);
+        }
+        validateRole(entry, `reviewers[${i}]`, filePath);
+    }
+    return raw;
+}
+function validateRole(role, name, filePath) {
+    if (!("tool" in role) || typeof role["tool"] !== "string") {
+        throw new Error(`Malformed config at ${filePath}: missing or invalid field "${name}.tool"`);
+    }
+    if (role["tool"] !== "claude" && role["tool"] !== "codex") {
+        throw new Error(`Malformed config at ${filePath}: invalid value for "${name}.tool": "${role["tool"]}"`);
+    }
+    if (!("model" in role) || typeof role["model"] !== "string") {
+        throw new Error(`Malformed config at ${filePath}: missing or invalid field "${name}.model"`);
+    }
+    if (!("effort" in role) || typeof role["effort"] !== "string") {
+        throw new Error(`Malformed config at ${filePath}: missing or invalid field "${name}.effort"`);
+    }
+}
+async function read(fs, args) {
+    const projectPath = configPath(args.projectRoot);
+    if (await fs.exists(projectPath)) {
+        const content = await fs.readFile(projectPath);
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            throw new Error(`Malformed config at ${projectPath}: invalid JSON`);
+        }
+        return validate(parsed, projectPath);
+    }
+    const globalPath = configPath(args.homeDir);
+    if (await fs.exists(globalPath)) {
+        const content = await fs.readFile(globalPath);
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch {
+            throw new Error(`Malformed config at ${globalPath}: invalid JSON`);
+        }
+        return validate(parsed, globalPath);
+    }
+    return null;
+}
+async function write(fs, args) {
+    const base = args.scope === "project" ? args.projectRoot : args.homeDir;
+    const dir = configDir(base);
+    const target = configPath(base);
+    const tmp = target + ".tmp";
+    const content = JSON.stringify(args.config, null, 2) + "\n";
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(tmp, content);
+    await fs.rename(tmp, target);
+    return target;
+}

package/lib/workspace/SpecDiscovery.d.ts

@@ -0,0 +1,12 @@
+import type { ScriptContext, TimeContext } from "../contexts";
+export type SpecLists = Readonly<{
+    contracts: readonly string[];
+    rules: readonly string[];
+    flanders: readonly string[];
+}>;
+export declare function classifySpecPaths(paths: readonly string[]): {
+    contracts: string[];
+    rules: string[];
+    flanders: string[];
+};
+export declare function discoverSpecs(script: ScriptContext, time: TimeContext, projectRoot: string): Promise<SpecLists>;