peer-ai 1.0.0-next.0 → 1.0.0-next.2

package/README.md

@@ -27,6 +27,7 @@ npm install --save-dev peer-ai
 | Command | What it does |
 |---------|--------------|
 | [`peer-ai init`](#peer-ai-init) | Sets up Peer AI in a repository: one config file, from what it detects |
+| [`peer-ai migrate`](#peer-ai-migrate) | Moves a project from its copy of v0 onto Peer AI 1.0 |
 | [`peer-ai assess`](#peer-ai-assess) | Maps what the project has and what its stage still needs |
 | [`peer-ai render`](#peer-ai-render) | Connects each AI tool: instructions, the MCP server and the skills |
 | [`peer-ai doctor`](#peer-ai-doctor) | Checks the setup and says how to fix what isn't right |
@@ -76,6 +77,45 @@ It never overwrites an existing `peer-ai.config.json`, and it never assumes anyt
 
 `0` success, `1` refused (a config already exists) or cancelled, `2` a usage error.
 
+## `peer-ai migrate`
+
+Moves a project from v0, when Peer AI was a playbook copied into a `peer-ai/` folder, onto the package ([RFC 0008](../../rfcs/0008-moving-a-v0-project-onto-1-0.md)).
+
+In the project's folder:
+
+1. **Commit or stash any work in progress.** `migrate` won't start with uncommitted changes, so the move is a change of its own.
+2. **Make a branch:** `git switch -c peer-ai-1.0`
+3. **See the plan, changing nothing:** `npx peer-ai migrate --dry-run`
+4. **Migrate:** `npx peer-ai migrate`. It asks the same few questions as `init`, already filled in from what it found.
+5. **Review the change, commit it, and open a pull request.** To undo it instead: `git stash --include-untracked`.
+6. **In your next session,** your AI tool brings up each decision `migrate` left in `docs/peer-ai-migration.md`. Go through them together, then delete the file.
+7. **On GitHub,** make `peer-ai check` a required check, so nothing merges without the gate.
+
+It converts what it can read with certainty:
+
+| From v0 | Into |
+|---------|------|
+| The Project settings table in the workflow driver | `commands.verify`, `tracker`, `repo.branchNaming`, `repo.mergePolicy` and `design.reference` |
+| `phase-config.json` | `models`, each skill's add-ons and notes, and each activity's notes. A phase that says a part is dormant marks it `dormant`. |
+| Markdown files in `docs/standards/` | `standards.documents`, as standards or an addendum, each scoped to its part |
+| `.peer-ai-state.json` | A work item for each ticket in progress. The tracker keeps the rest. |
+
+Then it deletes the `peer-ai/` folder and the state file, takes v0's text out of `CLAUDE.md`, `AGENTS.md` and the other instruction files, maps the project and sets up the AI tools, as `assess` and `render` do.
+
+Nothing is dropped silently. Whatever needs judgement, it copies word for word into `docs/peer-ai-migration.md`: the files the project edited in `peer-ai/`, the text it took out of the instruction files, the settings it couldn't place, and anything it left alone that still names v0. A work item, `migrate-v0`, points there, so your AI tool brings each decision up in the next session.
+
+It tells the files the project changed from v0's own by their fingerprints: a list of every file in every v0 version, which ships with the package.
+
+It never commits. It won't start with uncommitted changes, so the migration is a change of its own: review it, commit it on a branch, and open a pull request. `git stash --include-untracked` undoes it all. It deletes only files git can bring back, leaves files git ignores where they are, and refuses to write outside the project.
+
+### Options
+
+The same as `init`. With `--dry-run`, it prints what it would convert, rewrite, delete and leave for a decision, and changes nothing.
+
+### Exit codes
+
+`0` success, `1` refused (a config already exists, there is no v0 copy, the project isn't in git or has uncommitted changes) or cancelled, `2` a usage error.
+
 ## `peer-ai assess`
 
 Maps what a project already has, and what its stage still needs. Run it on any project, at any point: a brief with no code, a prototype, or a product in production with no documents at all.
@@ -165,7 +205,19 @@ npx peer-ai render
 
 `AGENTS.md` gets the block whenever a tool other than Claude Code is listed, when it already exists, or when `CLAUDE.md` imports it.
 
-The instructions are short: how to work through the MCP server, the project's parts, its commands, its compliance packs and its own rules. The server serves the detail when it's needed, rather than every rule on every turn.
+### The CI gate
+
+Render sets up `peer-ai check` in the project's CI, so no one has to remember to ([RFC 0009](../../rfcs/0009-the-ci-gate-set-up-by-render.md)):
+
+- **On GitHub Actions,** it writes `.github/workflows/peer-ai.yml`: one job, `peer-ai check`, that installs Node 24 and runs the exact version of Peer AI render ran as, so it works with or without a `package.json`. Its actions are pinned to commits. Render keeps the file up to date while it's as render left it, and leaves it alone once someone changes it by hand; `doctor` then checks it still runs the gate. A version bump updates it.
+- **On any other CI,** it prints the step to add.
+- **When a workflow of the project's own already runs `peer-ai check`,** it adds nothing.
+
+Make `peer-ai check` a required check in the repository's settings, so nothing merges without it. To run the gate some other way, set `"delivery": { "gate": false }`.
+
+### Instructions
+
+The instructions are short: how to work through the MCP server, the project's parts, its commands, its compliance packs and its own rules, and the project's settings for models, skills and activities when it has any: the models to use, the add-ons, checklists and notes for each skill, and the files to read and notes for each activity. The server serves the detail when it's needed, rather than every rule on every turn.
 
 ### Skills
 
@@ -245,6 +297,7 @@ npx peer-ai doctor
 | AI tools | A tool set up in the repository, such as a `CLAUDE.md` or `.cursor/`, that the config doesn't list |
 | What render writes | Instructions or MCP registrations that no longer match the config, or skills that are missing or out of date |
 | CI | A config that says there is no CI when the repository has a pipeline, which would lead Peer AI to add a second one |
+| The CI gate | A pipeline that doesn't run `peer-ai check`, or a gate workflow that's out of date or no longer runs it. Through `next_work`, the AI tool hears about it in every session. |
 | The project map | Missing, not valid, or out of date. It runs a fresh assessment and lists every item whose status has changed since `.peer-ai/map.json` was written. |
 | Work items | A file in `.peer-ai/work/` that isn't valid, isn't named after its id, or names a track the config doesn't have |
 | Git | A folder that isn't a git repository, or a `.gitignore` that hides Peer AI's files from the team and CI |
@@ -302,11 +355,7 @@ A review's result is worked out from its report when it is recorded, so an open
 
 ### In CI
 
-Run it after the project's own checks:
-
-```yaml
-- run: npx peer-ai check
-```
+`render` sets it up: see [the CI gate](#the-ci-gate). By hand, it's a step after the project's own checks that runs, with Node 24, `npx -y peer-ai@<version> check`.
 
 ### Options
 

package/dist/cli.js

@@ -13,6 +13,7 @@ import { runDoctor } from "./doctor.js";
 import { runFeedback } from "./feedback.js";
 import { serveStdio } from "./mcp.js";
 import { runInit } from "./init.js";
+import { runMigrate } from "./migrate.js";
 import { VERSION } from "./package-info.js";
 import { createTerminalPrompter } from "./prompter.js";
 import { formatReport } from "./report.js";
@@ -23,6 +24,7 @@ const HELP = `peer-ai: from a brief to a shipped product, with any AI tool
 
 Usage:
   peer-ai init [options]      Set up Peer AI in this repository
+  peer-ai migrate [options]   Move a project from its copy of v0 onto Peer AI 1.0
   peer-ai assess [options]    Map what the project has and what its stage still needs
   peer-ai render [options]    Set up each AI tool in the config: instructions and the MCP server
   peer-ai doctor [options]    Check that Peer AI is set up correctly, and how to fix it
@@ -47,6 +49,9 @@ Options for init:
       --tool <tool>           An AI tool you use; repeat for several
                               (${TOOL_IDS.join(", ")})
 
+Options for migrate: the same as init. It never commits, and it won't start on
+uncommitted changes. --dry-run prints what it would do, changing nothing.
+
 Options for assess:
       --target <stage>        Assess against a stage other than the project's own,
                               for example production before a launch
@@ -79,7 +84,8 @@ function oneOf(value, allowed, flag) {
         return value;
     throw new Error(`${flag} must be one of: ${allowed.join(", ")}`);
 }
-async function init(args, io) {
+/** The options init and migrate share. */
+function initOptions(args, io) {
     const { values } = parseArgs({
         args,
         strict: true,
@@ -95,7 +101,7 @@ async function init(args, io) {
     const stage = values.stage === undefined ? undefined : oneOf(values.stage, STAGES, "--stage");
     const team = values.team === undefined ? undefined : oneOf(values.team, ["solo", "team"], "--team");
     const tools = values.tool?.map((tool) => oneOf(tool, TOOL_IDS, "--tool"));
-    return runInit({
+    return {
         cwd: io.cwd,
         yes: values.yes === true,
         dryRun: values["dry-run"] === true,
@@ -103,7 +109,13 @@ async function init(args, io) {
         ...(stage === undefined ? {} : { stage }),
         ...(team === undefined ? {} : { team }),
         ...(tools === undefined ? {} : { tools }),
-    }, io.prompter, io.out);
+    };
+}
+function init(args, io) {
+    return runInit(initOptions(args, io), io.prompter, io.out);
+}
+function migrate(args, io) {
+    return runMigrate(initOptions(args, io), io.prompter, io.out);
 }
 function assess(args, io) {
     const { values } = parseArgs({
@@ -175,6 +187,7 @@ async function mcp(args, io) {
 }
 const COMMANDS = {
     init,
+    migrate,
     assess,
     render,
     doctor,

package/dist/doctor.js

@@ -10,6 +10,7 @@ import { DOMAINS } from "peer-ai-workflow";
 import { LEGACY_MARKERS, MAP_FILE, assess, loadConfig } from "./assess.js";
 import { count, fail, formatChecks, ok, plural, skip, warn } from "./checks.js";
 import { checkEnforcers, checkProfiles } from "./enforcers.js";
+import { GATE_FILE, checkGate } from "./gate.js";
 import { WORKFLOW_FILE } from "./pipeline.js";
 import { RUFF_FILE } from "./ruff.js";
 import { CONFIG_FILE, detectDelivery, detectName, detectTools, detectTracks } from "./detect.js";
@@ -105,7 +106,8 @@ function checkTools(root, config) {
     return ok("tools", `AI tools: ${listed.join(", ")}`);
 }
 /** What render writes for the AI tools still matches the config. */
-const ENFORCER_FILES = [WORKFLOW_FILE, RUFF_FILE];
+/** Files with a check of their own: the enforcers, and the CI gate. */
+const ENFORCER_FILES = [WORKFLOW_FILE, RUFF_FILE, GATE_FILE];
 function checkRendered(root, config, skills) {
     const plan = planRender(root, config);
     const withSkills = skills || config.skills?.commit === true;
@@ -240,9 +242,11 @@ function checkGit(root) {
 function checkLegacy(root) {
     if (!LEGACY_MARKERS.some((marker) => existsSync(join(root, marker))))
         return [];
-    return [
-        warn("legacy", "The peer-ai/ folder is a copy of the v0 playbook, which Peer AI 1.0 doesn't read.", `Move any changes your project made to it into ${CONFIG_FILE}, then remove it with: git rm -r peer-ai`),
-    ];
+    // migrate builds the config itself, so it only runs before there is one.
+    const fix = existsSync(join(root, CONFIG_FILE))
+        ? `Move any changes your project made to it into ${CONFIG_FILE}, then remove it with: git rm -r peer-ai`
+        : "Run npx peer-ai migrate. It moves what your project changed into the config, and removes the folder.";
+    return [warn("legacy", "The peer-ai/ folder is a copy of the v0 playbook, which Peer AI 1.0 doesn't read.", fix)];
 }
 export function diagnose(root, nodeVersion = process.versions.node, today = new Date(), options = {}) {
     const { check: configCheck, config } = checkConfig(root);
@@ -257,6 +261,7 @@ export function diagnose(root, nodeVersion = process.versions.node, today = new
             ? needsConfig("render", "What render writes")
             : [checkRendered(root, config, options.skills ?? true)]),
         ...(config === undefined ? needsConfig("delivery", "CI") : [checkDelivery(root, config)]),
+        ...(config === undefined ? needsConfig("gate", "The CI gate") : checkGate(root, config)),
         ...(config === undefined
             ? needsConfig("standards", "Rules set aside")
             : checkStandards(config, today.toISOString().slice(0, 10))),

package/dist/gate.d.ts

@@ -0,0 +1,29 @@
+import type { PeerAiConfig } from "peer-ai-workflow";
+import { type Check } from "./checks.ts";
+export declare const GATE_FILE = ".github/workflows/peer-ai.yml";
+/** The gate's command, with the exact version render runs as, so CI needs no package.json. */
+export declare const gateCommand: () => string;
+/** The workflow render writes for the gate: Node 24 and the exact version, so any project can run it. */
+export declare function gateWorkflow(config: PeerAiConfig): string;
+export interface Gate {
+    /** What render does to the gate's workflow, on GitHub Actions. */
+    planned?: {
+        path: string;
+        action: "create" | "update" | "unchanged" | "kept";
+        content?: string;
+        note?: string;
+    };
+    /** The step to add by hand, for any other CI. */
+    manual?: string;
+    /** Where the gate runs already, when it does. */
+    runsIn?: string;
+}
+/** Whether the project's CI is GitHub Actions: workflows of its own, or the gate render wrote. */
+export declare function onGitHubActions(root: string): boolean;
+/** Where the gate stands, and what render does about it. */
+export declare function planGate(root: string, config: PeerAiConfig): Gate;
+/**
+ * peer-ai doctor's check: CI runs the gate, unless the config turns it off. With no CI yet there is
+ * nothing to say; the delivery check reports that already.
+ */
+export declare function checkGate(root: string, config: PeerAiConfig): Check[];

package/dist/gate.js

@@ -0,0 +1,141 @@
+// The CI gate (RFC 0009): CI runs peer-ai check on every change, so work is held to its record
+// without anyone having to remember to set that up. On GitHub Actions, render writes a workflow of
+// its own for it, owned the way the security workflow is: rewritten while it's as render left it,
+// and left alone once someone changes it by hand. For any other CI, render prints the step to add.
+// peer-ai doctor warns while nothing runs it, so the AI tool hears about it in every session.
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { ok, skip, warn } from "./checks.js";
+import { detectDelivery } from "./detect.js";
+import { VERSION } from "./package-info.js";
+import { CHECKOUT, SETUP_NODE, WORKFLOW_FILE, sameFile, unchangedSinceRender, withHash } from "./pipeline.js";
+export const GATE_FILE = ".github/workflows/peer-ai.yml";
+const WORKFLOWS = ".github/workflows";
+/** Workflows Peer AI writes for itself, which on their own aren't a project's CI. */
+const OWN = [GATE_FILE, WORKFLOW_FILE, `${WORKFLOWS}/copilot-setup-steps.yml`];
+/** A command that runs the gate: peer-ai check, with or without a version. */
+const GATE_COMMAND = /\bpeer-ai(@\S+)?\s+check\b/;
+/** Whether a CI file runs the gate: a line with the command, not a comment or a job's name. */
+const runsGate = (text) => text.split(/\r?\n/).some((line) => !/^\s*#/.test(line) && !/^\s*-?\s*name:/.test(line) && GATE_COMMAND.test(line));
+/** The gate's command, with the exact version render runs as, so CI needs no package.json. */
+export const gateCommand = () => `npx -y peer-ai@${VERSION} check`;
+const read = (root, path) => {
+    const full = join(root, path);
+    return existsSync(full) && statSync(full).isFile() ? readFileSync(full, "utf8") : undefined;
+};
+/** The files of a pipeline: a folder's YAML files, or the file itself. */
+function filesOf(root, pipeline) {
+    if (!pipeline.endsWith("/"))
+        return [pipeline];
+    const dir = join(root, pipeline);
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+        return [];
+    return readdirSync(dir)
+        .filter((name) => /\.ya?ml$/.test(name))
+        .sort()
+        .map((name) => `${pipeline}${name}`);
+}
+/** The workflow render writes for the gate: Node 24 and the exact version, so any project can run it. */
+export function gateWorkflow(config) {
+    const branch = config.repo?.defaultBranch;
+    const body = [
+        "name: Peer AI",
+        "on:",
+        "  pull_request:",
+        // With no default branch in the config, changes are checked in their pull requests.
+        ...(branch === undefined ? [] : ["  push:", `    branches: [${branch}]`]),
+        "permissions:",
+        "  contents: read",
+        "jobs:",
+        "  peer-ai-check:",
+        "    name: peer-ai check",
+        "    runs-on: ubuntu-latest",
+        "    timeout-minutes: 10",
+        "    steps:",
+        `      - uses: ${CHECKOUT}`,
+        "        with:",
+        "          persist-credentials: false",
+        `      - uses: ${SETUP_NODE}`,
+        "        with:",
+        "          node-version: 24",
+        `      - run: ${gateCommand()}`,
+        "",
+    ].join("\n");
+    return withHash([
+        "# Generated by peer-ai render from peer-ai.config.json: the gate, peer-ai check (RFC 0009).",
+        "# Change the config, not this file. Render writes it again while it's as render left it, and leaves",
+        "# it alone once someone changes it by hand. Make the job a required check: its name never changes.",
+    ], body);
+}
+/** Whether the project's CI is GitHub Actions: workflows of its own, or the gate render wrote. */
+export function onGitHubActions(root) {
+    return read(root, GATE_FILE) !== undefined || filesOf(root, `${WORKFLOWS}/`).some((path) => !OWN.includes(path));
+}
+/** Where the gate stands, and what render does about it. */
+export function planGate(root, config) {
+    if (config.delivery?.gate === false)
+        return {};
+    const existing = read(root, GATE_FILE);
+    const others = filesOf(root, `${WORKFLOWS}/`).filter((path) => path !== GATE_FILE);
+    const onActions = onGitHubActions(root) || (config.delivery?.pipeline ?? "").startsWith(WORKFLOWS);
+    if (onActions) {
+        if (existing === undefined) {
+            // A gate someone added to a workflow of their own is enough: there is never a second one.
+            const elsewhere = others.find((path) => runsGate(read(root, path) ?? ""));
+            if (elsewhere !== undefined)
+                return { runsIn: elsewhere };
+            return { planned: { path: GATE_FILE, action: "create", content: gateWorkflow(config) } };
+        }
+        if (unchangedSinceRender(existing)) {
+            const content = gateWorkflow(config);
+            const same = sameFile(existing, content);
+            return {
+                planned: { path: GATE_FILE, action: same ? "unchanged" : "update", ...(same ? {} : { content }) },
+                runsIn: GATE_FILE,
+            };
+        }
+        return {
+            planned: {
+                path: GATE_FILE,
+                action: "kept",
+                note: "It was changed by hand, so keeping it up to date is yours now; peer-ai doctor checks it still runs peer-ai check. Delete it to have render write Peer AI's again.",
+            },
+            ...(runsGate(existing) ? { runsIn: GATE_FILE } : {}),
+        };
+    }
+    const pipeline = detectDelivery(root)?.pipeline ?? (config.delivery?.ci === "existing" ? config.delivery.pipeline : undefined);
+    // A workflows folder that holds only Peer AI's own files isn't the project's CI.
+    if (pipeline === undefined || pipeline.startsWith(WORKFLOWS))
+        return {};
+    const runs = filesOf(root, pipeline).find((path) => runsGate(read(root, path) ?? ""));
+    if (runs !== undefined)
+        return { runsIn: runs };
+    return {
+        manual: `Your CI, ${pipeline}, doesn't run Peer AI's gate. Add a step that runs, with Node 24, after the project's own checks: ${gateCommand()}`,
+    };
+}
+const NOT_GATED = "No CI runs peer-ai check, so nothing holds work to its record in CI.";
+/**
+ * peer-ai doctor's check: CI runs the gate, unless the config turns it off. With no CI yet there is
+ * nothing to say; the delivery check reports that already.
+ */
+export function checkGate(root, config) {
+    if (config.delivery?.gate === false)
+        return [skip("gate", "The CI gate is off: delivery.gate is false.")];
+    const gate = planGate(root, config);
+    const action = gate.planned?.action;
+    if (action === "create")
+        return [warn("gate", NOT_GATED, `Run npx peer-ai render. It writes ${GATE_FILE}.`)];
+    if (action === "update")
+        return [warn("gate", `${GATE_FILE} is out of date.`, "Run npx peer-ai render.")];
+    if (action === "kept" && gate.runsIn === undefined) {
+        return [
+            warn("gate", `${GATE_FILE} was changed by hand, and no longer runs peer-ai check.`, `Put the step back: - run: ${gateCommand()}`),
+        ];
+    }
+    if (gate.runsIn !== undefined)
+        return [ok("gate", `CI runs peer-ai check: ${gate.runsIn}`)];
+    if (gate.manual !== undefined)
+        return [warn("gate", NOT_GATED, gate.manual)];
+    return [];
+}

package/dist/init.d.ts

@@ -17,7 +17,7 @@ export interface Output {
     log: (line: string) => void;
     error: (line: string) => void;
 }
-interface Answers {
+export interface Answers {
     name: string;
     description: string;
     tracks: DetectedTrack[];
@@ -26,6 +26,7 @@ interface Answers {
     tools: ToolId[];
 }
 export declare function describeTrack(track: DetectedTrack): string;
+export declare function ask(detected: Detected, prompter: Prompter, title?: string): Promise<Answers>;
+export declare function defaults(detected: Detected, options: InitOptions): Answers;
 export declare function buildConfig(detected: Detected, answers: Answers): Record<string, unknown>;
 export declare function runInit(options: InitOptions, prompter: Prompter | undefined, out: Output): Promise<number>;
-export {};

package/dist/init.js

@@ -42,8 +42,8 @@ function parseStack(text) {
         .map((part) => part.trim().toLowerCase())
         .filter((part) => part !== "");
 }
-async function ask(detected, prompter) {
-    prompter.intro("peer-ai init");
+export async function ask(detected, prompter, title = "peer-ai init") {
+    prompter.intro(title);
     if (detected.tracks.length > 0) {
         prompter.note(detected.tracks.map(describeTrack).join("\n"), "Found in this repository");
     }
@@ -75,7 +75,7 @@ async function ask(detected, prompter) {
     }
     return { name, description, tracks, team, stage, tools };
 }
-function defaults(detected, options) {
+export function defaults(detected, options) {
     return {
         name: options.name ?? detected.name,
         description: detected.description ?? "",

package/dist/migrate.d.ts

@@ -0,0 +1,95 @@
+import { type ActivityId } from "peer-ai-workflow";
+import { type Detected } from "./detect.ts";
+import { type Answers, type InitOptions, type Output } from "./init.ts";
+import { type Prompter } from "./prompter.ts";
+import { type Converted, type Copy, type Fingerprints } from "./v0.ts";
+export declare const NOTES_FILE = "docs/peer-ai-migration.md";
+export declare const MIGRATION_ITEM = "migrate-v0";
+export interface MigrateOptions extends InitOptions {
+    now?: Date;
+    /** The v0 fingerprints to compare against. Tests pass their own. */
+    fingerprints?: Fingerprints;
+}
+/** What git knows about the project, read once before anything changes. */
+export interface RepoState {
+    /** The copy's files git tracks, which it can bring back after they're deleted. */
+    tracked: string[];
+    /** The copy's files git ignores, which migrate leaves where they are. */
+    ignored: string[];
+    /** The commit before the migration, so the notes can point at the files as they were. */
+    base?: string;
+}
+interface Decision {
+    title: string;
+    body: string[];
+}
+interface PlannedItem {
+    id?: string;
+    title: string;
+    stage: "prepare" | "build" | "verify";
+    track?: string;
+    position?: {
+        activity: ActivityId;
+        step: number;
+    };
+    next: string;
+}
+export interface Plan {
+    config: Record<string, unknown>;
+    copy: Copy;
+    converted: Converted[];
+    /** Files rewritten: instructions without v0's text, package.json without v0's scripts. */
+    edits: {
+        path: string;
+        text: string;
+    }[];
+    /** Files deleted outside the copy, each quoted in the notes or rebuilt from git. */
+    removals: string[];
+    /** The copy's tracked files, deleted one by one; its ignored files stay. */
+    copyFiles: string[];
+    decisions: Decision[];
+    /** Whole files kept in the notes as v0 had them, for reference. */
+    kept: {
+        path: string;
+        text: string;
+        info: string;
+    }[];
+    items: PlannedItem[];
+    base?: string;
+}
+/** A fenced block that holds any text, with a fence longer than any inside it. */
+export declare function fenced(text: string, info?: string): string[];
+/** Inline code that holds any text, even text with backticks of its own. */
+export declare function code(text: string): string;
+/** A work item id for a v0 ticket: PROJ-14 stays, #12 becomes PREFIX-12 or ITEM-12. */
+export declare function ticketId(ticket: string, prefix: string | undefined): string | undefined;
+export interface Scripts {
+    text: string;
+    removed: {
+        name: string;
+        command: string;
+    }[];
+}
+/**
+ * package.json without the scripts that only run v0's files. A script that does anything else as
+ * well stays as it is, and is listed for a person.
+ */
+export declare function packageScripts(text: string): {
+    edit?: Scripts;
+    mentions: {
+        name: string;
+        command: string;
+    }[];
+};
+/** Works out everything migrate will do, without changing anything. */
+export declare function planMigration(root: string, detected: Detected, answers: Answers, fingerprints: Fingerprints, repo: RepoState): Plan;
+/** docs/peer-ai-migration.md: what migrate did, and every decision it left. */
+export declare function notesDocument(plan: Plan, today: string): string;
+/** A path that leads outside the project, through a symbolic link on the way or at the end. */
+export declare function escapes(root: string, path: string): boolean;
+/**
+ * Exit code 0 when migrated, or with --dry-run; 1 when it refuses, or when the migration was applied
+ * but a step after it didn't finish; 2 on a usage error.
+ */
+export declare function runMigrate(options: MigrateOptions, prompter: Prompter | undefined, out: Output): Promise<number>;
+export {};