@yagni-app/code 0.1.0 → 0.2.1

package/dist/extension/initDone.js

@@ -0,0 +1,66 @@
+/**
+ * The CLI init-pass idempotency marker (Onramp Door B, spec §5B/§7).
+ *
+ * The init pass writes only to `yagni_code_decisions`, but freshness is computed
+ * from `GET /api/yagni-code/context` — which reads only Vision + active Goals.
+ * A workspace with neither (the common case for a fresh CLI-only user) therefore
+ * looks "fresh" on EVERY launch, so without a marker the init pass would re-run
+ * and accumulate duplicate decisions each time.
+ *
+ * The fix is a one-time, per-workspace marker file, dropped after the first real
+ * run. It lives in the same `~/.yagni-code` home as the run journal
+ * ({@link checkpoint.ts}), is keyed on a truncated SHA-256 of the workspace id so
+ * the filename is path-safe and reveals no identity, and holds only a timestamp
+ * (never a token or any PII). Every operation is fail-soft: a missing marker
+ * simply means "not yet run", and a write failure never breaks session start.
+ */
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { codeStateHome } from "./stateHome.js";
+/**
+ * Test seam mirroring {@link checkpoint._setCheckpointHomeForTest}: when set, the
+ * marker roots here instead of `~/.yagni-code`, so tests hit a tmpdir. Pass
+ * `null` to restore.
+ */
+let homeOverride = null;
+export function _setInitDoneHomeForTest(dir) {
+    homeOverride = dir;
+}
+function initDoneHome() {
+    return codeStateHome(homeOverride);
+}
+/**
+ * The marker path for a workspace. The id is hashed (SHA-256, first 16 hex chars)
+ * so an arbitrary/opaque workspace id is path-safe and the raw id never lands in
+ * a filename.
+ */
+export function initDoneMarkerFile(workspaceId) {
+    const hash = createHash("sha256").update(workspaceId).digest("hex").slice(0, 16);
+    return join(initDoneHome(), `init-done-${hash}`);
+}
+/** Has the init pass already run once for this workspace? Fail-soft → false. */
+export function isInitDone(workspaceId) {
+    if (!workspaceId)
+        return false;
+    try {
+        return existsSync(initDoneMarkerFile(workspaceId));
+    }
+    catch {
+        return false; // unreadable → treat as not-yet-run (the caller still guards on freshness)
+    }
+}
+/** Record that the init pass has run once for this workspace. Fail-soft (never throws). */
+export function markInitDone(workspaceId) {
+    if (!workspaceId)
+        return;
+    try {
+        mkdirSync(initDoneHome(), { recursive: true, mode: 0o700 });
+        // Content is a bare timestamp — no token, no PII (the id is hashed in the name).
+        writeFileSync(initDoneMarkerFile(workspaceId), `${new Date().toISOString()}\n`, { mode: 0o600 });
+    }
+    catch {
+        /* fail-soft: a marker write must never break session start */
+    }
+}
+//# sourceMappingURL=initDone.js.map

package/dist/extension/initPass.d.ts

@@ -0,0 +1,170 @@
+/**
+ * The CLI first-run experience (Onramp Door B, spec §5B/§7, as amended by
+ * ADR-0033: first run is a welcome, not a Team ceremony).
+ *
+ * On a FRESH workspace (an empty/thin grounding corpus, via the existing
+ * `GET /api/yagni-code/context` brief), the first interactive `yagni` run shows
+ * a short WELCOME: how to work with YAGNI in one notice, then one offer (ask
+ * @yagni what to work on next) with free text as a first-class choice.
+ * Escape/cancel land in an empty editor ready to type into, never a forced
+ * prompt. The welcome records NOTHING and reads nothing from the repo.
+ *
+ * The Team-drafting flow (repo intake -> engineering-half draft -> approve/edit
+ * -> bank the brief as ONE decision) lives behind the explicit `/setup-team`
+ * command ({@link registerTeamSetupCommand}) so onboarding can invoke it
+ * deliberately. Honesty rails are unchanged (spec §9, F2/F13): approval-gated
+ * writes, honest-when-thin (nothing fabricated), the Team is only ever a DRAFT
+ * and never created automatically, and the repo intake reads only universal
+ * signals (README, AGENTS.md/CLAUDE.md, package.json scripts) so it behaves
+ * the same on any customer repo.
+ *
+ * No new backend transport: the only writes are through the existing token-scoped
+ * `record_decision` endpoint (reused via {@link recordDecision}). Every seam is
+ * injectable so both flows are unit-testable without a network or a filesystem.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { fetchContextBrief as defaultFetchContextBrief, type ContextBrief } from "./config.js";
+import { type NextActionOption } from "./nextWorkTool.js";
+import { recordDecision as defaultRecordDecision, type RecordDecisionParams } from "./recordDecisionTool.js";
+/**
+ * Below this many non-whitespace characters (and with no sources), a returned
+ * context brief is treated as thin/empty — i.e. the corpus has not been seeded
+ * yet, so this is a fresh workspace that should run the init pass.
+ */
+export declare const FRESH_BRIEF_MIN_CHARS = 40;
+/**
+ * Is this a fresh workspace (an empty/thin grounding corpus)? A `null` brief, or
+ * a brief with only a stub of text and no sources, means nothing has grounded the
+ * workspace yet. A brief with real text OR any sources means it is already
+ * populated and the init pass must be skipped.
+ */
+export declare function isFreshWorkspace(brief: ContextBrief | null | undefined): boolean;
+/**
+ * What the repo intake could find. All fields are best-effort / optional, and
+ * every signal is a UNIVERSAL repo convention (README, agents file, package
+ * scripts) — never a house-specific layout like docs/adr, so the intake
+ * behaves the same on any customer repo.
+ */
+export interface RepoIntake {
+    /** README body (capped), when present. */
+    readme?: string;
+    /** AGENTS.md or CLAUDE.md body (capped), when present. */
+    agents?: string;
+    /** package.json `scripts` map (empty when absent/unparseable). */
+    packageScripts: Record<string, string>;
+    /** The literal test command (package.json `scripts.test`), when present. */
+    testCommand?: string;
+    /** The literal build command (package.json `scripts.build`), when present. */
+    buildCommand?: string;
+}
+/** Injectable filesystem seam so repo intake is unit-testable without disk. */
+export interface RepoIntakeFs {
+    readFile(p: string): Promise<string>;
+}
+/**
+ * Read the repo at `cwd` for the signals that seed the engineering half of the
+ * brief. Every read is best-effort; a missing file simply drops that signal.
+ */
+export declare function readRepoIntake(cwd: string, fs?: RepoIntakeFs): Promise<RepoIntake>;
+/** A proposed Engineering Team — a DRAFT that is never auto-committed. */
+export interface DraftTeam {
+    name: string;
+    mission: string;
+    responsibilities: string[];
+    playbookRules: string[];
+    testCommand?: string;
+    buildCommand?: string;
+}
+/** The drafted engineering half: the brief, seeded decisions, and a Team draft. */
+export interface EngineeringDraft {
+    /** The engineering-half brief text (honest-when-thin). */
+    brief: string;
+    /** True when the repo had no README/AGENTS — the brief says so, nothing is fabricated. */
+    thin: boolean;
+    /** Decisions to seed into the corpus. EMPTY when thin (no fabrication). */
+    decisions: RecordDecisionParams[];
+    /** The proposed Engineering Team (a draft; never auto-committed). */
+    team: DraftTeam;
+}
+/**
+ * Draft the engineering half of the brief from repo intake. PURE. Honest-when-thin:
+ * with no README/AGENTS the brief says so and NO decision is seeded.
+ */
+export declare function draftEngineering(intake: RepoIntake): EngineeringDraft;
+/** Injectable dependencies for {@link runInitPass} (the first-run welcome). */
+export interface RunInitPassDeps {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    /**
+     * A pre-fetched context brief (the caller usually already fetched it to boot
+     * grounded). When `undefined`, the pass fetches it itself. Pass `null`
+     * explicitly to signal "fetched, and it was empty".
+     */
+    brief?: ContextBrief | null;
+    fetchContextBrief?: typeof defaultFetchContextBrief;
+}
+/** The outcome of a first-run welcome attempt. The welcome never writes. */
+export type InitPassOutcome = {
+    ran: false;
+    reason: "not_fresh" | "non_interactive";
+} | {
+    ran: true;
+    /** What the user picked; `free_text` covers the typing option AND escape/cancel. */
+    chosenAction: NextActionOption["id"] | "free_text";
+};
+/** Injectable dependencies for {@link runTeamSetup} (the `/setup-team` flow). */
+export interface RunTeamSetupDeps {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+    readRepoIntake?: (cwd: string) => Promise<RepoIntake>;
+    recordDecision?: typeof defaultRecordDecision;
+}
+/** The outcome of a `/setup-team` run. */
+export type TeamSetupOutcome = {
+    ran: false;
+    reason: "non_interactive";
+} | {
+    ran: true;
+    thin: boolean;
+    decisionsRecorded: number;
+    /** The Team is NEVER created/committed automatically. Always false. */
+    teamCommitted: false;
+};
+/**
+ * Compact one-screen PREVIEW of the draft for the approve/edit dialog.
+ *
+ * Approval-gated (spec §5B/§9, F2/F13): NOTHING is written to the corpus until
+ * the human approves or corrects the draft, so this is a preview of INTENT — it
+ * states what will be recorded ON APPROVAL, and never claims a corpus was
+ * already seeded. When thin there is nothing to record (honest — nothing to
+ * fabricate). The ACTUAL recorded count is reported after the write runs (see
+ * `runInitPass`).
+ */
+export declare function summarizeDraft(draft: EngineeringDraft): string;
+/**
+ * Run the first-run welcome (ADR-0033). Guards on fresh-workspace detection
+ * (defensive — the caller also guards), shows a short how-to-work-with-YAGNI
+ * notice, and offers ONE default next action (ask @yagni what to work on next)
+ * with free text as a first-class choice. Picking "Just start typing",
+ * pressing escape, or cancelling all leave the editor untouched so the user
+ * can type whatever they want to start on. Records NOTHING, reads nothing from
+ * the repo, and is fully fail-soft (it must never break session start).
+ */
+export declare function runInitPass(pi: ExtensionAPI, ctx: ExtensionContext, deps: RunInitPassDeps): Promise<InitPassOutcome>;
+/**
+ * Run the `/setup-team` flow: read the repo's universal signals, draft the
+ * engineering half + a proposed Team, present it for approve/edit, and ONLY
+ * THEN bank the brief as one decision (approval-gated: an approve banks the
+ * draft, an edit banks the correction, a decline writes nothing). Fully
+ * fail-soft; the Team itself is never created automatically.
+ */
+export declare function runTeamSetup(pi: ExtensionAPI, ctx: ExtensionContext, deps: RunTeamSetupDeps): Promise<TeamSetupOutcome>;
+/**
+ * Register `/setup-team`: the explicit, approval-gated flow that drafts the
+ * Engineering Team + engineering brief from the repo. Deliberately NOT part of
+ * first-run (ADR-0033) — onboarding invokes it when the workspace is ready.
+ */
+export declare function registerTeamSetupCommand(pi: ExtensionAPI, opts: RunTeamSetupDeps): void;
+//# sourceMappingURL=initPass.d.ts.map

package/dist/extension/initPass.js

@@ -0,0 +1,394 @@
+/**
+ * The CLI first-run experience (Onramp Door B, spec §5B/§7, as amended by
+ * ADR-0033: first run is a welcome, not a Team ceremony).
+ *
+ * On a FRESH workspace (an empty/thin grounding corpus, via the existing
+ * `GET /api/yagni-code/context` brief), the first interactive `yagni` run shows
+ * a short WELCOME: how to work with YAGNI in one notice, then one offer (ask
+ * @yagni what to work on next) with free text as a first-class choice.
+ * Escape/cancel land in an empty editor ready to type into, never a forced
+ * prompt. The welcome records NOTHING and reads nothing from the repo.
+ *
+ * The Team-drafting flow (repo intake -> engineering-half draft -> approve/edit
+ * -> bank the brief as ONE decision) lives behind the explicit `/setup-team`
+ * command ({@link registerTeamSetupCommand}) so onboarding can invoke it
+ * deliberately. Honesty rails are unchanged (spec §9, F2/F13): approval-gated
+ * writes, honest-when-thin (nothing fabricated), the Team is only ever a DRAFT
+ * and never created automatically, and the repo intake reads only universal
+ * signals (README, AGENTS.md/CLAUDE.md, package.json scripts) so it behaves
+ * the same on any customer repo.
+ *
+ * No new backend transport: the only writes are through the existing token-scoped
+ * `record_decision` endpoint (reused via {@link recordDecision}). Every seam is
+ * injectable so both flows are unit-testable without a network or a filesystem.
+ */
+import { readFile as fsReadFile } from "node:fs/promises";
+import path from "node:path";
+import { fetchContextBrief as defaultFetchContextBrief, } from "./config.js";
+import { defaultNextAction } from "./nextWorkTool.js";
+import { recordDecision as defaultRecordDecision, } from "./recordDecisionTool.js";
+// ---------------------------------------------------------------------------
+// Fresh-workspace detection
+// ---------------------------------------------------------------------------
+/**
+ * Below this many non-whitespace characters (and with no sources), a returned
+ * context brief is treated as thin/empty — i.e. the corpus has not been seeded
+ * yet, so this is a fresh workspace that should run the init pass.
+ */
+export const FRESH_BRIEF_MIN_CHARS = 40;
+/**
+ * Is this a fresh workspace (an empty/thin grounding corpus)? A `null` brief, or
+ * a brief with only a stub of text and no sources, means nothing has grounded the
+ * workspace yet. A brief with real text OR any sources means it is already
+ * populated and the init pass must be skipped.
+ */
+export function isFreshWorkspace(brief) {
+    if (!brief)
+        return true;
+    const text = (brief.brief ?? "").trim();
+    const hasSources = Array.isArray(brief.sources) && brief.sources.length > 0;
+    return text.length < FRESH_BRIEF_MIN_CHARS && !hasSources;
+}
+/** The default fs seam: node:fs/promises, resolving to empty on any error. */
+const nodeIntakeFs = {
+    async readFile(p) {
+        try {
+            return await fsReadFile(p, "utf8");
+        }
+        catch {
+            return "";
+        }
+    },
+};
+/** Candidate filenames, tried in order; the first that reads non-empty wins. */
+const README_CANDIDATES = ["README.md", "README", "readme.md", "README.markdown"];
+const AGENTS_CANDIDATES = ["AGENTS.md", "CLAUDE.md"];
+/** Cap the amount of prose we lift so a large README never bloats the brief. */
+const MAX_DOC_CHARS = 4000;
+const MAX_SUMMARY_CHARS = 280;
+async function firstNonEmpty(fs, cwd, names) {
+    for (const name of names) {
+        const body = (await fs.readFile(path.join(cwd, name))).trim();
+        if (body)
+            return body.slice(0, MAX_DOC_CHARS);
+    }
+    return undefined;
+}
+/** Parse the `scripts` map out of a package.json body; {} on any problem. */
+function parseScripts(raw) {
+    if (!raw.trim())
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        const scripts = parsed.scripts;
+        if (!scripts || typeof scripts !== "object")
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(scripts)) {
+            if (typeof v === "string")
+                out[k] = v;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Read the repo at `cwd` for the signals that seed the engineering half of the
+ * brief. Every read is best-effort; a missing file simply drops that signal.
+ */
+export async function readRepoIntake(cwd, fs = nodeIntakeFs) {
+    const [readme, agents, pkgRaw] = await Promise.all([
+        firstNonEmpty(fs, cwd, README_CANDIDATES),
+        firstNonEmpty(fs, cwd, AGENTS_CANDIDATES),
+        fs.readFile(path.join(cwd, "package.json")),
+    ]);
+    const packageScripts = parseScripts(pkgRaw);
+    return {
+        readme,
+        agents,
+        packageScripts,
+        testCommand: packageScripts.test || undefined,
+        buildCommand: packageScripts.build || undefined,
+    };
+}
+const THIN_BRIEF = "I couldn't find a README or AGENTS.md/CLAUDE.md in this repo, so I don't " +
+    "know much about how you build yet. Tell me in a line what this repo is and how " +
+    "you build it, and I'll fill in the engineering brief.";
+const TEAM_MISSION = "Owns how we build: conventions, reviews, and test/build.";
+/** Cap `text` at `max` chars, cutting back to the last word boundary with an ellipsis. */
+function truncateAtWord(text, max) {
+    if (text.length <= max)
+        return text;
+    const cut = text.slice(0, max);
+    const lastSpace = cut.lastIndexOf(" ");
+    return `${(lastSpace > 0 ? cut.slice(0, lastSpace) : cut).trimEnd()}…`;
+}
+/** The README's first real paragraph (heading-stripped), capped at a word boundary. */
+function firstParagraph(readme) {
+    if (!readme)
+        return undefined;
+    const para = readme
+        .split(/\n\s*\n/)
+        .map((p) => p.trim())
+        .find((p) => p && !p.startsWith("#") && !/^[!\[]/.test(p));
+    if (!para)
+        return undefined;
+    return truncateAtWord(para.replace(/\s+/g, " "), MAX_SUMMARY_CHARS);
+}
+/**
+ * Draft the engineering half of the brief from repo intake. PURE. Honest-when-thin:
+ * with no README/AGENTS the brief says so and NO decision is seeded.
+ */
+export function draftEngineering(intake) {
+    const hasSubstance = Boolean(intake.readme || intake.agents);
+    const thin = !hasSubstance;
+    const team = {
+        name: "Engineering",
+        mission: TEAM_MISSION,
+        responsibilities: [],
+        playbookRules: [],
+        testCommand: intake.testCommand,
+        buildCommand: intake.buildCommand,
+    };
+    if (intake.testCommand)
+        team.playbookRules.push(`Run \`${intake.testCommand}\` before handing off a change.`);
+    if (intake.buildCommand)
+        team.playbookRules.push(`Run \`${intake.buildCommand}\` to verify the change builds.`);
+    team.playbookRules.push("Ask @yagni before guessing on anything org- or codebase-specific; record product-intent decisions as you make them.");
+    if (thin) {
+        team.responsibilities.push("Define how this team builds software (not documented yet).");
+        return { brief: THIN_BRIEF, thin: true, decisions: [], team };
+    }
+    if (intake.agents)
+        team.responsibilities.push("Uphold the conventions documented in AGENTS.md/CLAUDE.md.");
+    if (intake.testCommand || intake.buildCommand)
+        team.responsibilities.push("Keep the build and tests green.");
+    if (team.responsibilities.length === 0)
+        team.responsibilities.push("Own how this team builds software.");
+    const lines = ["How this team builds software (drafted from repo intake — a draft, editable):"];
+    const whatItIs = firstParagraph(intake.readme);
+    if (whatItIs)
+        lines.push(`- What this is: ${whatItIs}`);
+    if (intake.agents)
+        lines.push("- Conventions: documented in AGENTS.md/CLAUDE.md.");
+    if (intake.testCommand)
+        lines.push(`- Tests: \`${intake.testCommand}\``);
+    if (intake.buildCommand)
+        lines.push(`- Build: \`${intake.buildCommand}\``);
+    const brief = lines.join("\n");
+    // Seed the corpus with ONE entry so the very first /go has real ground to
+    // cite: the drafted brief itself. Repo docs stay in the repo where the agent
+    // can read them whole; regex-lifted fragments are never banked as decisions.
+    // The brief is a DRAFT (editable), never treated as immutable fact.
+    const decisions = [
+        {
+            question: "How does this team build software?",
+            decision: brief,
+            rationale: "Drafted from repo intake (README/AGENTS) during the first YAGNI Code run; a draft, editable.",
+        },
+    ];
+    return { brief, thin: false, decisions, team };
+}
+/**
+ * Compact one-screen PREVIEW of the draft for the approve/edit dialog.
+ *
+ * Approval-gated (spec §5B/§9, F2/F13): NOTHING is written to the corpus until
+ * the human approves or corrects the draft, so this is a preview of INTENT — it
+ * states what will be recorded ON APPROVAL, and never claims a corpus was
+ * already seeded. When thin there is nothing to record (honest — nothing to
+ * fabricate). The ACTUAL recorded count is reported after the write runs (see
+ * `runInitPass`).
+ */
+export function summarizeDraft(draft) {
+    const parts = [draft.brief, "", `Proposed Team: ${draft.team.name} — ${draft.team.mission}`];
+    if (draft.team.responsibilities.length) {
+        parts.push("Responsibilities:", ...draft.team.responsibilities.map((r) => `  - ${r}`));
+    }
+    if (draft.thin) {
+        parts.push("", "(Engineering context is thin — nothing to record yet; I never fabricate one.)");
+    }
+    else if (draft.decisions.length > 0) {
+        parts.push("", "On approval I'll save this brief into your grounding corpus. Nothing else is recorded.");
+    }
+    parts.push("", "This Team is a draft — it is never created automatically. You can edit it first.");
+    return parts.join("\n");
+}
+/** A permissive notify wrapper: a notice must never disrupt a flow. */
+function safeNotify(ui) {
+    return (message, type) => {
+        try {
+            ui?.notify?.(message, type);
+        }
+        catch {
+            /* swallowed */
+        }
+    };
+}
+/** The one-notice welcome shown on the very first interactive run in a repo. */
+const WELCOME_NOTICE = "First run in this repo. Just type to start working. Ask me about your company " +
+    "context (tickets, docs, decisions), or run /go <ticket> for a ticket-to-PR run.";
+/** The free-text choice: an untouched editor, ready for whatever they want to build. */
+const FREE_TEXT_LABEL = "Just start typing";
+/**
+ * Run the first-run welcome (ADR-0033). Guards on fresh-workspace detection
+ * (defensive — the caller also guards), shows a short how-to-work-with-YAGNI
+ * notice, and offers ONE default next action (ask @yagni what to work on next)
+ * with free text as a first-class choice. Picking "Just start typing",
+ * pressing escape, or cancelling all leave the editor untouched so the user
+ * can type whatever they want to start on. Records NOTHING, reads nothing from
+ * the repo, and is fully fail-soft (it must never break session start).
+ */
+export async function runInitPass(pi, ctx, deps) {
+    // 1. Fresh-workspace guard (skip when already grounded).
+    const brief = deps.brief !== undefined
+        ? deps.brief
+        : await (deps.fetchContextBrief ?? defaultFetchContextBrief)({
+            baseUrl: deps.baseUrl,
+            getToken: deps.getToken,
+            fetchImpl: deps.fetchImpl,
+        }).catch(() => null);
+    if (!isFreshWorkspace(brief))
+        return { ran: false, reason: "not_fresh" };
+    // In non-interactive / print (`-p`) / no-UI mode there is no one to welcome;
+    // skip WITHOUT marking init-done so the first interactive run still gets it.
+    const ui = (ctx.hasUI ? ctx.ui : undefined);
+    if (!ui)
+        return { ran: false, reason: "non_interactive" };
+    const notify = safeNotify(ui);
+    notify(WELCOME_NOTICE, "info");
+    // 2. Offer the ONE default next action (spec §7.3: defaults over choices),
+    //    with free text as a first-class door. Everything here is best-effort:
+    //    whatever happens, the user ends at a prompt they can just type into.
+    let chosenAction = "free_text";
+    try {
+        const next = defaultNextAction();
+        const review = next.escapeHatches.find((h) => h.id === "review");
+        if (typeof ui.select === "function") {
+            const options = [next.primary, ...(review ? [review] : [])];
+            const labels = [next.primary.label, FREE_TEXT_LABEL, ...(review ? [review.label] : [])];
+            const picked = await ui.select("What next?", labels);
+            const chosen = options.find((o) => o.label === picked);
+            // "Just start typing", escape, and cancel all leave the editor alone —
+            // a first run must never force a prompt on the user.
+            if (chosen) {
+                chosenAction = chosen.id;
+                ui.setEditorText?.(chosen.prompt);
+            }
+        }
+    }
+    catch {
+        /* the offer is best-effort; free text always works */
+    }
+    return { ran: true, chosenAction };
+}
+/**
+ * Run the `/setup-team` flow: read the repo's universal signals, draft the
+ * engineering half + a proposed Team, present it for approve/edit, and ONLY
+ * THEN bank the brief as one decision (approval-gated: an approve banks the
+ * draft, an edit banks the correction, a decline writes nothing). Fully
+ * fail-soft; the Team itself is never created automatically.
+ */
+export async function runTeamSetup(pi, ctx, deps) {
+    const recordDecisionFn = deps.recordDecision ?? defaultRecordDecision;
+    const readIntake = deps.readRepoIntake ?? ((cwd) => readRepoIntake(cwd));
+    const decisionOpts = {
+        baseUrl: deps.baseUrl,
+        getToken: deps.getToken,
+        fetchImpl: deps.fetchImpl,
+    };
+    // Approval-gated writes (spec §5B/§9 — captured-judgment beat): a decision
+    // only earns its place when a human can see and approve/edit the draft. With
+    // no UI there is no one to approve, so we NEVER write.
+    const ui = (ctx.hasUI ? ctx.ui : undefined);
+    if (!ui)
+        return { ran: false, reason: "non_interactive" };
+    const notify = safeNotify(ui);
+    notify("Reading the repo to draft your Engineering Team…", "info");
+    // 1. Read the repo + draft the engineering half.
+    let intake;
+    try {
+        intake = await readIntake(ctx.cwd ?? process.cwd());
+    }
+    catch {
+        intake = { packageScripts: {} };
+    }
+    const draft = draftEngineering(intake);
+    // 2. Present the draft for approve/edit BEFORE any durable write (F2/F13).
+    //    In a UI without a `confirm` capability there is no way to obtain
+    //    approval, so (consistent with the no-UI guard above) we write nothing.
+    let decisionsRecorded = 0;
+    try {
+        let approved = false;
+        let correctedBrief;
+        if (typeof ui.confirm === "function") {
+            approved = await ui.confirm("Your draft Engineering Team", summarizeDraft(draft));
+            if (!approved && typeof ui.editor === "function") {
+                const edited = await ui.editor("Edit the engineering brief", draft.brief);
+                if (edited && edited.trim() && edited.trim() !== draft.brief.trim()) {
+                    correctedBrief = edited.trim();
+                }
+            }
+        }
+        // 3. Approval-gated corpus writes. APPROVE → bank the drafted brief
+        //    decision. REJECT-then-correct → bank ONLY the correction (the
+        //    rejected auto-draft is never written). REJECT without an edit (or no
+        //    approval UI) → write NOTHING. Best-effort throughout: a failed write
+        //    is swallowed and the recorded count stays honest (F13).
+        if (approved) {
+            for (const decision of draft.decisions) {
+                try {
+                    const result = await recordDecisionFn(decisionOpts, decision, ctx.signal);
+                    if (!result.spooled)
+                        decisionsRecorded += 1;
+                }
+                catch {
+                    /* fail-soft: recording is best-effort */
+                }
+            }
+        }
+        else if (correctedBrief) {
+            // The edit is a captured-judgment beat: bank the correction so the next
+            // run inherits the steer.
+            try {
+                const result = await recordDecisionFn(decisionOpts, {
+                    question: "How does this team build software?",
+                    decision: correctedBrief,
+                    rationale: "The user edited the drafted engineering brief during team setup.",
+                }, ctx.signal);
+                if (!result.spooled)
+                    decisionsRecorded += 1;
+            }
+            catch {
+                /* fail-soft */
+            }
+        }
+        // Report the ACTUAL recorded count once the write has run (never the
+        // intended count) so the receipt is honest even on a partial/failed write.
+        if (decisionsRecorded > 0) {
+            notify("Saved your engineering brief into the grounding corpus.", "info");
+        }
+        else if (!draft.thin) {
+            notify("Nothing recorded.", "info");
+        }
+    }
+    catch {
+        /* the presentation is best-effort */
+    }
+    return { ran: true, thin: draft.thin, decisionsRecorded, teamCommitted: false };
+}
+/**
+ * Register `/setup-team`: the explicit, approval-gated flow that drafts the
+ * Engineering Team + engineering brief from the repo. Deliberately NOT part of
+ * first-run (ADR-0033) — onboarding invokes it when the workspace is ready.
+ */
+export function registerTeamSetupCommand(pi, opts) {
+    pi.registerCommand("setup-team", {
+        description: "Draft an Engineering Team + engineering brief from this repo; nothing is saved without your approval.",
+        handler: async (_args, ctx) => {
+            await runTeamSetup(pi, ctx, opts);
+        },
+    });
+}
+//# sourceMappingURL=initPass.js.map