@drawcall/create 0.0.0

package/dist/create.js

@@ -0,0 +1,348 @@
+import { 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) {
+        await delay(RETRY_BACKOFF_MS * (attempt - 1));
+        result = await runHarnessTurn(harnessRunner, prompt);
+    }
+    return result;
+}
+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);
+    // template, survey-assets, and survey-technology are independent (disjoint outputs, no git,
+    // surveys don't depend on the template). A "full" run does all three concurrently behind one
+    // barrier; a single-stage run does just the requested one.
+    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);
+        await installSkills(projectDir, harness, runner);
+        await installDependencies(projectDir, 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 and survey assets/technology concurrently, then commit. */
+async function runTemplateGroup(harnessRunner, progressLog, prompt) {
+    progressLog.start("template/surveys");
+    try {
+        // Array order is the call order: each runner pushes synchronously before its first await.
+        const results = await runGroupTurns(harnessRunner, [
+            buildTemplatePrompt(prompt),
+            buildSurveyAssetsPrompt(prompt),
+            buildSurveyTechnologyPrompt(prompt)
+        ]);
+        const failed = results.find((result) => result.exitCode !== 0);
+        if (failed) {
+            progressLog.fail("template/surveys");
+            return failed;
+        }
+        await finishTemplate(harnessRunner);
+        progressLog.succeed("template/surveys");
+        return { exitCode: 0 };
+    }
+    catch (error) {
+        progressLog.fail("template/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/harness.d.ts

@@ -0,0 +1,13 @@
+import { type HarnessName } from "./constants.js";
+import type { CommandExists, CommandInvocation, CommandResult, CommandRunner } from "./subprocess.js";
+export type HarnessRunner = {
+    harness: HarnessName;
+    harnessArgs: string[];
+    timeoutMs: number;
+    cwd: string;
+    runner: CommandRunner;
+};
+export declare function selectHarness(requested: HarnessName | undefined, env: NodeJS.ProcessEnv, commandExists: CommandExists): Promise<HarnessName>;
+export declare function harnessInvocation(harness: HarnessName, prompt: string, cwd: string, harnessArgs?: string[]): CommandInvocation;
+/** Run one harness-turn: build the harness-command and hand it to the command-runner. */
+export declare function runHarnessTurn(harnessRunner: HarnessRunner, prompt: string): Promise<CommandResult>;

package/dist/harness.js

@@ -0,0 +1,81 @@
+import { CliError, HARNESS_NAMES } from "./constants.js";
+export async function selectHarness(requested, env, commandExists) {
+    if (requested) {
+        if (await commandExists(requested, env))
+            return requested;
+        throw new CliError(`requested harness "${requested}" was not found on PATH`);
+    }
+    for (const harness of HARNESS_NAMES) {
+        if (await commandExists(harness, env))
+            return harness;
+    }
+    throw new CliError(`no supported harness found. Checked: ${HARNESS_NAMES.join(", ")}`);
+}
+export function harnessInvocation(harness, prompt, cwd, harnessArgs = []) {
+    switch (harness) {
+        case "opencode":
+            // "--dangerously-skip-permissions" auto-approves tool calls; without it opencode gates
+            // writes/commands in a headless run (no user to approve), so file writes get rejected and
+            // stages like goal finish without producing their output file. Matches claude/gemini/grok.
+            // "--dir <cwd>" pins opencode's project directory to the spawned cwd. opencode otherwise
+            // resolves its own project root by walking up to a git root, and the
+            // GIT_CEILING_DIRECTORIES=<parent> env that buildSubprocessEnv injects perturbs that walk
+            // so writes land in the PARENT of the project dir — it reports "Patch 1 file / Created X"
+            // but the file is written one level up, so create's existsSync(GOAL.md) check then fails.
+            return {
+                command: "opencode",
+                args: ["run", "--dangerously-skip-permissions", "--dir", cwd, ...harnessArgs, prompt],
+                cwd
+            };
+        case "codex":
+            return {
+                command: "codex",
+                args: ["exec", "--skip-git-repo-check", ...harnessArgs, prompt],
+                cwd
+            };
+        case "claude":
+            // The harness must run commands autonomously (Market searches, npm, vitexec proof checks,
+            // uikitml convert). "acceptEdits" only auto-approves file edits and gates every command,
+            // which deadlocks headless --print runs; bypassPermissions auto-approves commands too.
+            return {
+                command: "claude",
+                args: ["--print", "--permission-mode", "bypassPermissions", ...harnessArgs, prompt],
+                cwd
+            };
+        case "pi":
+            return { command: "pi", args: [...harnessArgs, "-p", prompt], cwd };
+        case "gemini":
+            // "yolo" auto-approves commands too; "auto_edit" would gate them like claude's acceptEdits.
+            // Hardcoded flags come before harnessArgs so users can override them, matching claude.
+            // "--skip-trust" is required for headless runs: in an untrusted folder Gemini silently
+            // downgrades "yolo" back to "default" (gating every tool) and then errors out, so the turn
+            // dies in ~1s without doing anything.
+            return {
+                command: "gemini",
+                args: ["--approval-mode", "yolo", "--skip-trust", ...harnessArgs, "--prompt", prompt],
+                cwd
+            };
+        case "grok":
+            // Headless single-turn: "-p" prints to stdout and exits; "--always-approve" auto-runs the
+            // commands/edits the build needs (npm, vitexec, file writes), matching claude/gemini's yolo.
+            return {
+                command: "grok",
+                args: ["--always-approve", "--output-format", "plain", ...harnessArgs, "-p", prompt],
+                cwd
+            };
+        case "forge":
+            // "-p <prompt>" runs one command non-interactively and exits; in this mode forge auto-runs
+            // its tools (no approve/yolo flag exists or is needed — verified it writes files unattended).
+            // "-C <cwd>" pins forge's working directory. forge otherwise blocks waiting on stdin, but
+            // create's runner spawns with stdin ignored, so the turn proceeds. The model and reasoning
+            // effort come from forge's own config (the configured Opus 4.8 high), not a CLI flag.
+            return { command: "forge", args: ["-C", cwd, ...harnessArgs, "-p", prompt], cwd };
+    }
+}
+/** Run one harness-turn: build the harness-command and hand it to the command-runner. */
+export async function runHarnessTurn(harnessRunner, prompt) {
+    return harnessRunner.runner({
+        ...harnessInvocation(harnessRunner.harness, prompt, harnessRunner.cwd, harnessRunner.harnessArgs),
+        timeoutMs: harnessRunner.timeoutMs
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./constants.js";
+export * from "./prompts.js";
+export * from "./subprocess.js";
+export * from "./progress-log.js";
+export * from "./harness.js";
+export * from "./scaffold.js";
+export * from "./create.js";
+export * from "./command.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./constants.js";
+export * from "./prompts.js";
+export * from "./subprocess.js";
+export * from "./progress-log.js";
+export * from "./harness.js";
+export * from "./scaffold.js";
+export * from "./create.js";
+export * from "./command.js";

package/dist/progress-log.d.ts

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,95 @@
+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/prompts.d.ts

@@ -0,0 +1,6 @@
+export declare function buildTemplatePrompt(userPrompt: string): string;
+export declare function buildSurveyAssetsPrompt(userPrompt: string): string;
+export declare function buildSurveyTechnologyPrompt(userPrompt: string): string;
+export declare function buildGoalPrompt(userPrompt: string): string;
+export declare function buildPlanPrompt(userPrompt: string): string;
+export declare function buildBuildPrompt(userPrompt: string, turn: number): string;