@drawcall/create 0.1.3 → 0.2.1

package/dist/create.js

@@ -1,380 +0,0 @@
-import { appendFileSync, existsSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
-import { CliError, DEFAULT_HARNESS_TIMEOUT_MS, GOAL_FILE, MAX_BUILD_TURNS, PLAN_FILE, SESSION_LOG_FILE } from "./constants.js";
-import { runHarnessTurn, selectHarness } from "./harness.js";
-import { createSubprocessRunner, isCommandAvailable } from "./subprocess.js";
-import { buildSurveyAssetsPrompt, buildBuildPrompt, buildGoalPrompt, buildPlanPrompt, buildSurveyTechnologyPrompt, buildTemplatePrompt } from "./prompts.js";
-import { ProgressLog } from "./progress-log.js";
-import { commitAll, ensureBaseProjectDirectories, ensureNpmrc, ensureProjectGitignore, ensureStateReadme, generateProjectName, initGitRepo, initNpmProject, installDependencies, installSkills } from "./scaffold.js";
-// A harness turn fails for two very different reasons. A timeout means the turn ran too long — the
-// model is grinding, not flaky — so re-running it would just burn the same hours again. Every other
-// non-zero exit is, in practice, a transient provider blip: an overloaded API, a gateway 5xx, a
-// dropped/empty stream. One such blip used to abort an entire multi-hour run at whatever turn it
-// landed on. A turn is safe to re-run — think-turns rewrite their output file, build-turns re-read
-// the repo state and continue the same plan step — so a non-timeout failure retries a few times
-// with a short, lengthening backoff before it propagates. A clean exit returns on the first try.
-const HARNESS_TURN_ATTEMPTS = 3;
-const RETRY_BACKOFF_MS = 15_000;
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function runTurn(harnessRunner, prompt) {
-    let result = await runHarnessTurn(harnessRunner, prompt);
-    for (let attempt = 2; attempt <= HARNESS_TURN_ATTEMPTS && result.exitCode !== 0 && !result.timedOut; attempt += 1) {
-        const waitMs = RETRY_BACKOFF_MS * (attempt - 1);
-        // A retry is otherwise invisible: the runner just logs a second identical "$ <harness> …"
-        // invocation. Mark it so the log reads as "turn failed → retrying" rather than as a mysterious
-        // duplicate run, and so a slow build turn can be told apart from one that silently re-ran.
-        logToSession(harnessRunner.cwd, `[drawcall-create] harness turn failed (exit ${result.exitCode}); retry ${attempt}/${HARNESS_TURN_ATTEMPTS} after ${Math.round(waitMs / 1000)}s`);
-        await delay(waitMs);
-        result = await runHarnessTurn(harnessRunner, prompt);
-    }
-    return result;
-}
-function logToSession(cwd, line) {
-    try {
-        appendFileSync(join(cwd, SESSION_LOG_FILE), `${line}\n`);
-    }
-    catch {
-        // No session log on disk (e.g. a test's caller-supplied runner) — the retry proceeds anyway.
-    }
-}
-export async function createProject(prompt, options = {}) {
-    const { env = process.env, commandExists = isCommandAvailable } = options;
-    const stage = options.stage ?? "full";
-    const cwd = resolve(options.cwd ?? process.cwd());
-    const harness = await selectHarness(options.harness, env, commandExists);
-    const maxTurns = options.maxTurns ?? MAX_BUILD_TURNS;
-    const startedAt = Date.now();
-    if (!(await commandExists("git", env))) {
-        throw new CliError("git is required but was not found on PATH");
-    }
-    // "scaffold" and "full" create a fresh project directory. The other stages
-    // continue an existing repo at the current working directory.
-    const createsProjectDir = stage === "scaffold" || stage === "full";
-    const projectName = createsProjectDir
-        ? (options.projectName ?? generateProjectName())
-        : basename(cwd);
-    const projectDir = createsProjectDir ? resolve(cwd, projectName) : cwd;
-    if (createsProjectDir && existsSync(projectDir)) {
-        throw new CliError(`project directory already exists: ${projectDir}`);
-    }
-    if (!createsProjectDir && !existsSync(join(projectDir, ".git"))) {
-        throw new CliError(`the "${stage}" stage expects an existing git repo at ${projectDir}; run the scaffold stage first`);
-    }
-    // Capture every subprocess into the session-log so the terminal can stay a clean
-    // spinner. A caller-supplied runner opts out of both (it handles its own I/O).
-    const logFile = join(projectDir, SESSION_LOG_FILE);
-    const runner = options.runner ?? createSubprocessRunner({ env, logFile });
-    const progressLog = new ProgressLog({ logFile: options.runner ? undefined : logFile });
-    if (createsProjectDir) {
-        await mkdir(projectDir);
-    }
-    const harnessRunner = {
-        harness,
-        harnessArgs: options.harnessArgs ?? [],
-        timeoutMs: options.harnessTimeoutMs ?? DEFAULT_HARNESS_TIMEOUT_MS,
-        cwd: projectDir,
-        runner
-    };
-    const resultMaxTurns = stage === "full" ? maxTurns : stage === "build" ? 1 : 0;
-    progressLog.begin(projectName, harness, projectDir);
-    try {
-        if (createsProjectDir) {
-            await initGitRepo(projectDir, runner);
-        }
-        const result = await runStages(stage, harnessRunner, progressLog, prompt, projectName, {
-            maxTurns,
-            skipTemplate: options.skipTemplate === true
-        });
-        return { ...result, maxTurns: resultMaxTurns, durationMs: Date.now() - startedAt };
-    }
-    finally {
-        progressLog.stop();
-    }
-}
-/** Run the requested stage plus everything it implies, in pipeline order. */
-async function runStages(stage, harnessRunner, progressLog, prompt, projectName, options) {
-    const base = { projectDir: harnessRunner.cwd, projectName, harness: harnessRunner.harness };
-    const stopped = (exitCode, turns = 0) => ({
-        ...base,
-        exitCode,
-        turns,
-        maxTurns: 0,
-        durationMs: 0
-    });
-    if (stage === "scaffold" || stage === "full") {
-        await runScaffoldStage(harnessRunner, progressLog);
-    }
-    if (stage === "scaffold")
-        return stopped(0);
-    // A "full" run applies the template first, then surveys the applied state (assets + technology)
-    // concurrently behind one barrier — the surveys read the implementation the template installed,
-    // so they cannot run alongside it. A skip-template full run surveys a bare scaffold instead. A
-    // single-stage run does just the requested one (surveys then read whatever is already in the cwd).
-    if (stage === "full") {
-        const { exitCode } = options.skipTemplate
-            ? await runSurveyGroup(harnessRunner, progressLog, prompt)
-            : await runTemplateGroup(harnessRunner, progressLog, prompt);
-        if (exitCode !== 0)
-            return stopped(exitCode);
-    }
-    else if (stage === "template") {
-        return stopped((await runTemplateStage(harnessRunner, progressLog, prompt)).exitCode);
-    }
-    else if (stage === "survey-assets") {
-        return stopped((await runSurveyAssetsStage(harnessRunner, progressLog, prompt)).exitCode);
-    }
-    else if (stage === "survey-technology") {
-        return stopped((await runSurveyTechnologyStage(harnessRunner, progressLog, prompt)).exitCode);
-    }
-    if (stage === "goal" || stage === "full") {
-        const { exitCode } = await runGoalStage(harnessRunner, progressLog, prompt);
-        if (exitCode !== 0)
-            return stopped(exitCode);
-    }
-    if (stage === "goal")
-        return stopped(0);
-    if (stage === "plan" || stage === "full") {
-        const { exitCode } = await runPlanStage(harnessRunner, progressLog, prompt);
-        if (exitCode !== 0)
-            return stopped(exitCode);
-    }
-    if (stage === "plan")
-        return stopped(0);
-    // "build" does a single build-turn; "full" works through the whole plan.
-    const turnBudget = stage === "build" ? 1 : options.maxTurns;
-    return {
-        ...base,
-        ...(await runBuildTurns(harnessRunner, prompt, { maxTurns: turnBudget, progressLog })),
-        maxTurns: 0,
-        durationMs: 0
-    };
-}
-/** Mechanical setup of the fresh project (skills, packages, dirs). No harness turn, no README. */
-async function runScaffoldStage(harnessRunner, progressLog) {
-    const { cwd: projectDir, harness, runner } = harnessRunner;
-    progressLog.start("scaffolding");
-    try {
-        await ensureProjectGitignore(projectDir);
-        await ensureNpmrc(projectDir);
-        await ensureBaseProjectDirectories(projectDir);
-        await initNpmProject(projectDir, runner);
-        // Dependencies first: the private-repo skills are installed from their package directory under
-        // node_modules, which installDependencies creates (see installSkills / PACKAGE_SKILLS).
-        await installDependencies(projectDir, runner);
-        await installSkills(projectDir, harness, runner);
-        await commitAll(projectDir, runner, "chore: set up project scaffolding");
-        progressLog.succeed("scaffolding");
-    }
-    catch (error) {
-        progressLog.fail("scaffolding");
-        throw error;
-    }
-}
-// opencode crashes ("Unexpected error") when several of its instances run in the same project
-// dir at once — they contend over one per-project session/server. So the parallel template/survey
-// turns run sequentially for it; every other harness runs them concurrently for speed.
-const SERIAL_GROUP_HARNESSES = new Set(["opencode"]);
-async function runGroupTurns(harnessRunner, prompts) {
-    if (SERIAL_GROUP_HARNESSES.has(harnessRunner.harness)) {
-        const results = [];
-        for (const prompt of prompts) {
-            results.push(await runTurn(harnessRunner, prompt));
-        }
-        return results;
-    }
-    return Promise.all(prompts.map((prompt) => runTurn(harnessRunner, prompt)));
-}
-/** Apply a fitting Market starter, then survey assets/technology over the applied state. */
-async function runTemplateGroup(harnessRunner, progressLog, prompt) {
-    // The template runs first and commits, so the surveys that follow can read the applied
-    // implementation (its src/ and the assets it installed via Market), not race them — the
-    // whole point of the template path is to survey what is already here and modify it.
-    progressLog.start("template");
-    try {
-        const template = await runTurn(harnessRunner, buildTemplatePrompt(prompt));
-        if (template.exitCode !== 0) {
-            progressLog.fail("template");
-            return template;
-        }
-        await finishTemplate(harnessRunner);
-        progressLog.succeed("template");
-    }
-    catch (error) {
-        progressLog.fail("template");
-        throw error;
-    }
-    // The two surveys write disjoint scratch files and don't depend on each other, so they run
-    // concurrently (serially for opencode — see SERIAL_GROUP_HARNESSES).
-    progressLog.start("surveys");
-    try {
-        const results = await runGroupTurns(harnessRunner, [
-            buildSurveyAssetsPrompt(prompt),
-            buildSurveyTechnologyPrompt(prompt)
-        ]);
-        const failed = results.find((result) => result.exitCode !== 0);
-        if (failed) {
-            progressLog.fail("surveys");
-            return failed;
-        }
-        progressLog.succeed("surveys");
-        return { exitCode: 0 };
-    }
-    catch (error) {
-        progressLog.fail("surveys");
-        throw error;
-    }
-}
-/** Survey assets/technology in a full run without searching for or applying a template. */
-async function runSurveyGroup(harnessRunner, progressLog, prompt) {
-    progressLog.start("surveys");
-    try {
-        const results = await runGroupTurns(harnessRunner, [
-            buildSurveyAssetsPrompt(prompt),
-            buildSurveyTechnologyPrompt(prompt)
-        ]);
-        const failed = results.find((result) => result.exitCode !== 0);
-        if (failed) {
-            progressLog.fail("surveys");
-            return failed;
-        }
-        await finishScratchStart(harnessRunner);
-        progressLog.succeed("surveys");
-        return { exitCode: 0 };
-    }
-    catch (error) {
-        progressLog.fail("surveys");
-        throw error;
-    }
-}
-/** Apply a fitting Market starter into the current repo if one is found. */
-async function runTemplateStage(harnessRunner, progressLog, prompt) {
-    progressLog.start("template");
-    try {
-        const template = await runTurn(harnessRunner, buildTemplatePrompt(prompt));
-        if (template.exitCode !== 0) {
-            progressLog.fail("template");
-            return template;
-        }
-        await finishTemplate(harnessRunner);
-        progressLog.succeed("template");
-        return { exitCode: 0 };
-    }
-    catch (error) {
-        progressLog.fail("template");
-        throw error;
-    }
-}
-/** Ensure a state-record README exists (templates may ship their own), then commit. */
-async function finishTemplate(harnessRunner) {
-    await ensureStateReadme(harnessRunner.cwd);
-    await commitAll(harnessRunner.cwd, harnessRunner.runner, "chore: apply template");
-}
-/** Ensure the state record exists when a full run deliberately starts from scratch. */
-async function finishScratchStart(harnessRunner) {
-    await ensureStateReadme(harnessRunner.cwd);
-    await commitAll(harnessRunner.cwd, harnessRunner.runner, "chore: start from scratch");
-}
-/** Think-turn: walk the fitting Market assets into a gitignored asset-survey. */
-async function runSurveyAssetsStage(harnessRunner, progressLog, prompt) {
-    progressLog.start("survey assets");
-    try {
-        const result = await runTurn(harnessRunner, buildSurveyAssetsPrompt(prompt));
-        if (result.exitCode === 0)
-            progressLog.succeed("survey assets");
-        else
-            progressLog.fail("survey assets");
-        return result;
-    }
-    catch (error) {
-        progressLog.fail("survey assets");
-        throw error;
-    }
-}
-/** Think-turn: read the installed skills/packages into a gitignored technology-survey. */
-async function runSurveyTechnologyStage(harnessRunner, progressLog, prompt) {
-    progressLog.start("survey technology");
-    try {
-        const result = await runTurn(harnessRunner, buildSurveyTechnologyPrompt(prompt));
-        if (result.exitCode === 0)
-            progressLog.succeed("survey technology");
-        else
-            progressLog.fail("survey technology");
-        return result;
-    }
-    catch (error) {
-        progressLog.fail("survey technology");
-        throw error;
-    }
-}
-/** Think-turn: write the goal-record, grounded in the surveys and current state. */
-async function runGoalStage(harnessRunner, progressLog, prompt) {
-    progressLog.start("goal");
-    try {
-        const goal = await runTurn(harnessRunner, buildGoalPrompt(prompt));
-        if (goal.exitCode !== 0) {
-            progressLog.fail("goal");
-            return goal;
-        }
-        if (!existsSync(join(harnessRunner.cwd, GOAL_FILE))) {
-            throw new CliError(`goal harness finished without creating ${GOAL_FILE}`);
-        }
-        await commitAll(harnessRunner.cwd, harnessRunner.runner, "docs: add goal");
-        progressLog.succeed("goal");
-        return { exitCode: 0 };
-    }
-    catch (error) {
-        progressLog.fail("goal");
-        throw error;
-    }
-}
-/** Think-turn: write the plan-record from the goal, surveys, and current state. */
-async function runPlanStage(harnessRunner, progressLog, prompt) {
-    progressLog.start("plan");
-    try {
-        const plan = await runTurn(harnessRunner, buildPlanPrompt(prompt));
-        if (plan.exitCode !== 0) {
-            progressLog.fail("plan");
-            return plan;
-        }
-        if (!existsSync(join(harnessRunner.cwd, PLAN_FILE))) {
-            throw new CliError(`plan harness finished without creating ${PLAN_FILE}`);
-        }
-        await commitAll(harnessRunner.cwd, harnessRunner.runner, "docs: add plan");
-        progressLog.succeed("plan");
-        return { exitCode: 0 };
-    }
-    catch (error) {
-        progressLog.fail("plan");
-        throw error;
-    }
-}
-/** Build-stage: loop build-turns against the plan up to the build-turn-budget. */
-export async function runBuildTurns(harnessRunner, userPrompt, options = {}) {
-    const planPath = join(harnessRunner.cwd, PLAN_FILE);
-    const maxTurns = options.maxTurns ?? MAX_BUILD_TURNS;
-    const progressLog = options.progressLog;
-    for (let turn = 1; turn <= maxTurns; turn += 1) {
-        if (!existsSync(planPath))
-            return { exitCode: 0, turns: turn - 1 };
-        const label = `build ${turn}/${maxTurns}`;
-        progressLog?.start(label);
-        const result = await runTurn(harnessRunner, buildBuildPrompt(userPrompt, turn));
-        if (result.exitCode !== 0 && !result.timedOut) {
-            progressLog?.fail(label);
-            return { exitCode: result.exitCode, turns: turn };
-        }
-        if (result.timedOut) {
-            progressLog?.fail(label);
-            console.error("build turn timed out; stopping this run");
-            return { exitCode: result.exitCode, turns: turn };
-        }
-        await commitAll(harnessRunner.cwd, harnessRunner.runner, `feat: build turn ${turn}`);
-        progressLog?.succeed(label);
-    }
-    if (!existsSync(planPath))
-        return { exitCode: 0, turns: maxTurns };
-    progressLog?.stop();
-    console.log(`Reached the ${maxTurns} build-turn budget; ${PLAN_FILE} still records remaining work`);
-    return { exitCode: 0, turns: maxTurns };
-}

package/dist/progress-log.d.ts

@@ -1,31 +0,0 @@
-import type { HarnessName } from "./constants.js";
-export type ProgressLogOptions = {
-    stream?: NodeJS.WriteStream;
-    logFile?: string;
-    isTTY?: boolean;
-    now?: () => number;
-};
-/**
- * Shows one live stage line on a TTY and permanent stage result lines everywhere.
- * Notes are also mirrored into the session log so it reads as a transcript.
- */
-export declare class ProgressLog {
-    private readonly stream;
-    private readonly isTTY;
-    private readonly logFile?;
-    private readonly now;
-    private timer?;
-    private frameIndex;
-    private activeStage?;
-    constructor(options?: ProgressLogOptions);
-    begin(projectName: string, harness: HarnessName, projectDir: string): void;
-    start(label: string): void;
-    succeed(label?: string | undefined): void;
-    fail(label?: string | undefined): void;
-    stop(): void;
-    private render;
-    private finish;
-    private clearActiveLine;
-    private appendToLog;
-}
-export declare function formatDuration(ms: number): string;

package/dist/progress-log.js

@@ -1,95 +0,0 @@
-import { appendFileSync } from "node:fs";
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const SPINNER_INTERVAL_MS = 80;
-const CLEAR_LINE = "\r";
-/**
- * Shows one live stage line on a TTY and permanent stage result lines everywhere.
- * Notes are also mirrored into the session log so it reads as a transcript.
- */
-export class ProgressLog {
-    stream;
-    isTTY;
-    logFile;
-    now;
-    timer;
-    frameIndex = 0;
-    activeStage;
-    constructor(options = {}) {
-        this.stream = options.stream ?? process.stderr;
-        this.isTTY = options.isTTY ?? this.stream.isTTY === true;
-        this.logFile = options.logFile;
-        this.now = options.now ?? Date.now;
-    }
-    begin(projectName, harness, projectDir) {
-        this.stream.write(`Creating ${projectName} with ${harness}\n${projectDir}\n\n`);
-        this.appendToLog(`\n=== Creating ${projectName} with ${harness} ===\n${projectDir}\n`);
-    }
-    start(label) {
-        this.clearActiveLine();
-        this.activeStage = { label, startedAt: this.now() };
-        this.frameIndex = 0;
-        this.appendToLog(`\n=== ${label} started ===\n`);
-        if (!this.isTTY) {
-            this.stream.write(`${label} started\n`);
-            return;
-        }
-        if (this.timer === undefined) {
-            this.timer = setInterval(() => this.render(), SPINNER_INTERVAL_MS);
-            this.timer.unref();
-        }
-        this.render();
-    }
-    succeed(label = this.activeStage?.label) {
-        this.finish("done", "✓", label);
-    }
-    fail(label = this.activeStage?.label) {
-        this.finish("failed", "✕", label);
-    }
-    stop() {
-        if (this.timer !== undefined) {
-            clearInterval(this.timer);
-            this.timer = undefined;
-        }
-        this.clearActiveLine();
-    }
-    render() {
-        if (this.activeStage === undefined)
-            return;
-        const frame = SPINNER_FRAMES[this.frameIndex % SPINNER_FRAMES.length];
-        this.frameIndex += 1;
-        const elapsed = formatDuration(this.now() - this.activeStage.startedAt);
-        this.stream.write(`\r${frame} ${this.activeStage.label} ${elapsed}`);
-    }
-    finish(state, icon, label) {
-        if (label === undefined)
-            return;
-        const startedAt = this.activeStage?.label === label ? this.activeStage.startedAt : this.now();
-        const elapsed = formatDuration(this.now() - startedAt);
-        this.stop();
-        this.stream.write(`${icon} ${label} ${state} in ${elapsed}\n`);
-        this.appendToLog(`\n=== ${label} ${state} in ${elapsed} ===\n`);
-        this.activeStage = undefined;
-    }
-    clearActiveLine() {
-        if (this.isTTY && this.activeStage !== undefined)
-            this.stream.write(CLEAR_LINE);
-    }
-    appendToLog(line) {
-        if (this.logFile === undefined)
-            return;
-        try {
-            appendFileSync(this.logFile, line);
-        }
-        catch {
-            // Logging is best-effort and must never break a run.
-        }
-    }
-}
-export function formatDuration(ms) {
-    const totalSeconds = Math.max(0, Math.round(ms / 1000));
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    if (minutes === 0)
-        return `${seconds}s`;
-    return `${minutes}m ${seconds}s`;
-}

package/dist/subprocess.d.ts

@@ -1,21 +0,0 @@
-import { type SpawnOptions } from "node:child_process";
-export type CommandInvocation = {
-    command: string;
-    args: string[];
-    cwd: string;
-    timeoutMs?: number;
-};
-export type CommandResult = {
-    exitCode: number;
-    timedOut?: boolean;
-};
-export type CommandRunner = (invocation: CommandInvocation) => Promise<CommandResult>;
-export type CommandExists = (command: string, env: NodeJS.ProcessEnv) => Promise<boolean>;
-export type SubprocessRunnerOptions = Pick<SpawnOptions, "stdio" | "env"> & {
-    killGraceMs?: number;
-    logFile?: string;
-};
-export declare function createSubprocessRunner(options?: SubprocessRunnerOptions): CommandRunner;
-export declare function buildSubprocessEnv(cwd: string, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-export declare function isCommandAvailable(command: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
-export declare function assertExitCode(run: Promise<CommandResult>, message: string): Promise<void>;

package/dist/subprocess.js

@@ -1,154 +0,0 @@
-import { spawn } from "node:child_process";
-import { createWriteStream } from "node:fs";
-import { delimiter, dirname, join, resolve } from "node:path";
-import { createInterface } from "node:readline";
-import which from "which";
-import { CliError, TIMEOUT_EXIT_CODE, TIMEOUT_KILL_GRACE_MS } from "./constants.js";
-import { formatDuration } from "./progress-log.js";
-export function createSubprocessRunner(options = { stdio: "inherit" }) {
-    return (invocation) => runSubprocess(invocation, options);
-}
-function runSubprocess({ command, args, cwd, timeoutMs }, options) {
-    return new Promise((resolveResult, reject) => {
-        const startedAt = Date.now();
-        // A separate process group lets a timeout kill the whole child tree at once.
-        const detached = process.platform !== "win32";
-        // When a log file is set, capture all child output into it and keep the
-        // terminal clean for the progress note; otherwise stream straight through.
-        const logStream = openSessionLog(options.logFile, [command, ...args]);
-        const child = spawn(command, args, {
-            cwd,
-            detached,
-            env: buildSubprocessEnv(cwd, options.env ?? process.env),
-            stdio: logStream ? ["ignore", "pipe", "pipe"] : (options.stdio ?? "inherit")
-        });
-        if (logStream) {
-            // Stamp every captured line with the wall-clock time we received it instead of piping raw
-            // bytes. Reading the harness's output at our own boundary and timing it with our own clock is
-            // the one timing signal robust across every harness and version — it depends on no private
-            // session-transcript format or structured-output schema (both drift, and for backgrounded
-            // tool calls misreport durations). The gaps between timestamps are then where the wall-clock
-            // went: a long stall with no output is the model thinking or one command grinding.
-            forwardWithTimestamps(child.stdout, logStream);
-            forwardWithTimestamps(child.stderr, logStream);
-        }
-        let timedOut = false;
-        let killTimer;
-        let timeout;
-        if (timeoutMs !== undefined) {
-            timeout = setTimeout(() => {
-                timedOut = true;
-                const notice = `[drawcall-create] ${command} timed out after ${Math.ceil(timeoutMs / 1000)}s`;
-                if (logStream)
-                    logStream.write(`${notice}\n`);
-                else
-                    console.error(notice);
-                killChildProcess(child.pid, detached, "SIGTERM");
-                const grace = options.killGraceMs ?? TIMEOUT_KILL_GRACE_MS;
-                killTimer = setTimeout(() => killChildProcess(child.pid, detached, "SIGKILL"), grace);
-            }, timeoutMs);
-        }
-        // The child sits in its own process group, so terminal signals never reach it directly.
-        const forwardSignal = (signal) => {
-            killChildProcess(child.pid, detached, signal);
-            process.exit(signal === "SIGINT" ? 130 : 143);
-        };
-        process.on("SIGINT", forwardSignal);
-        process.on("SIGTERM", forwardSignal);
-        const cleanup = () => {
-            if (timeout)
-                clearTimeout(timeout);
-            if (killTimer)
-                clearTimeout(killTimer);
-            process.off("SIGINT", forwardSignal);
-            process.off("SIGTERM", forwardSignal);
-            logStream?.end();
-        };
-        child.once("error", (error) => {
-            cleanup();
-            reject(error);
-        });
-        child.once("exit", (code, signal) => {
-            const exitCode = timedOut ? TIMEOUT_EXIT_CODE : signal ? 1 : (code ?? 1);
-            // Always record how long the command ran, so the log shows where wall-clock goes (each
-            // scaffold step, and each harness turn's total) without digging into the harness's own
-            // session transcript. A non-zero exit is named on the same line so a failure is unmistakable
-            // and the boundary between a failed turn and a following retry stays legible. Timeouts
-            // already logged their own notice, so only the duration is added for them.
-            if (logStream) {
-                const elapsed = formatDuration(Date.now() - startedAt);
-                const failure = !timedOut && exitCode !== 0
-                    ? ` — exit ${exitCode}${signal ? ` (signal ${signal})` : ""}`
-                    : "";
-                logStream.write(`[drawcall-create] ${command} done in ${elapsed}${failure}\n`);
-            }
-            cleanup();
-            resolveResult({ exitCode, timedOut });
-        });
-    });
-}
-export function buildSubprocessEnv(cwd, baseEnv = process.env) {
-    const projectParent = dirname(resolve(cwd));
-    const localBin = join(resolve(cwd), "node_modules", ".bin");
-    const existingCeiling = baseEnv.GIT_CEILING_DIRECTORIES;
-    const existingPath = baseEnv.PATH;
-    return {
-        ...baseEnv,
-        PATH: existingPath ? `${localBin}${delimiter}${existingPath}` : localBin,
-        GIT_CEILING_DIRECTORIES: existingCeiling
-            ? `${projectParent}${delimiter}${existingCeiling}`
-            : projectParent
-    };
-}
-export async function isCommandAvailable(command, env = process.env) {
-    const resolved = await which(command, {
-        nothrow: true,
-        path: env.PATH,
-        pathExt: env.PATHEXT
-    });
-    return resolved !== null;
-}
-export async function assertExitCode(run, message) {
-    const { exitCode } = await run;
-    if (exitCode !== 0)
-        throw new CliError(`${message} (exit code ${exitCode})`);
-}
-function openSessionLog(logFile, command) {
-    if (logFile === undefined)
-        return undefined;
-    const stream = createWriteStream(logFile, { flags: "a" });
-    stream.write(`\n$ ${command.join(" ")}\n`);
-    return stream;
-}
-// Copy a child stream into the log a line at a time, stamping each line with the wall-clock time we
-// received it. readline does the line splitting (including a final line with no trailing newline,
-// and \r\n) so a timestamp only ever prefixes a whole line.
-function forwardWithTimestamps(source, sink) {
-    if (!source)
-        return;
-    const lines = createInterface({ input: source });
-    lines.on("line", (line) => sink.write(`${logTimestamp()} ${line}\n`));
-}
-// Absolute wall-clock HH:MM:SS.mmm so any two lines anywhere in the log — within a turn or across
-// stages — can be subtracted directly, and the gap from the last output line to the "done in"
-// footer (the idle tail before the process exits) is visible too.
-function logTimestamp() {
-    const now = new Date();
-    const pad = (value, length = 2) => String(value).padStart(length, "0");
-    return `[${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}.${pad(now.getMilliseconds(), 3)}]`;
-}
-function killChildProcess(pid, detached, signal) {
-    if (!pid)
-        return;
-    if (process.platform === "win32") {
-        // Signals only reach the direct child (often a cmd shim); taskkill tears down the tree.
-        spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" }).unref();
-        return;
-    }
-    try {
-        process.kill(detached ? -pid : pid, signal);
-    }
-    catch {
-        // The process may have exited between the timeout and kill attempt.
-    }
-}