@memfork/cli 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * @memfork/cli — entry point
+ *
+ * Usage:
+ *   memfork init                          — first-run interactive setup
+ *   memfork doctor                        — verify the full setup
+ *   memfork install cursor|codex          — install IDE plugin
+ *
+ *   memfork status                        — tree status
+ *   memfork log [--branch <b>] [-n <n>]   — commit log
+ *   memfork recall <query> [--branch <b>] — semantic recall
+ *   memfork commit -m <msg> --facts <...> — write facts on-chain
+ *   memfork merge <from> <into> --resolver <id>  — propose merge
+ *   memfork proposals                     — list open proposals
+ *   memfork ui                            — open DAG visualizer
+ *
+ * Config API re-exported for use by other packages:
+ *   import { resolveConfig, toClientConfig } from "@memfork/cli"
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * @memfork/cli — entry point
+ *
+ * Usage:
+ *   memfork init                          — first-run interactive setup
+ *   memfork doctor                        — verify the full setup
+ *   memfork install cursor|codex          — install IDE plugin
+ *
+ *   memfork status                        — tree status
+ *   memfork log [--branch <b>] [-n <n>]   — commit log
+ *   memfork recall <query> [--branch <b>] — semantic recall
+ *   memfork commit -m <msg> --facts <...> — write facts on-chain
+ *   memfork merge <from> <into> --resolver <id>  — propose merge
+ *   memfork proposals                     — list open proposals
+ *   memfork ui                            — open DAG visualizer
+ *
+ * Config API re-exported for use by other packages:
+ *   import { resolveConfig, toClientConfig } from "@memfork/cli"
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import { cmdInit } from "./commands/init.js";
+import { cmdDoctor } from "./commands/doctor.js";
+import { cmdInstall } from "./commands/install.js";
+import { cmdStatus, cmdLog, cmdRecall, cmdCommit, cmdMerge, cmdProposals, cmdUi, cmdShow, cmdDiff, cmdDelegates, cmdGrant, cmdGrantMemwal, cmdRevoke, cmdBranch, cmdCheckout, } from "./commands/ops.js";
+import { cmdJoin } from "./commands/join.js";
+const program = new Command();
+program
+    .name("memfork")
+    .description("MemForks CLI — on-chain, branch-aware agent memory")
+    .version("0.1.0");
+// ─── Setup ────────────────────────────────────────────────────────────────────
+program
+    .command("init")
+    .description("interactive first-run setup — create or link a memory tree")
+    .option("-q, --quick", "auto-provision: keygen → faucet → MemWal account → tree (no copy-paste needed)")
+    .action(wrap((opts) => cmdInit({ quick: opts.quick })));
+program
+    .command("doctor")
+    .description("verify config, credentials, Sui connection, and MemWal")
+    .action(wrap(cmdDoctor));
+program
+    .command("join")
+    .description("onboard to an existing tree (team member setup)")
+    .action(wrap(cmdJoin));
+program
+    .command("install <target>")
+    .description("install an IDE plugin: cursor | codex")
+    .action((target) => cmdInstall(target));
+// ─── Operations ───────────────────────────────────────────────────────────────
+program
+    .command("branch <name>")
+    .description("create a new branch from the current (or specified) branch")
+    .option("-f, --from <branch>", "source branch (default: current branch)")
+    .action(wrap((name, opts) => cmdBranch(name, opts)));
+program
+    .command("checkout <name>")
+    .description("switch the active branch")
+    .action(wrap((name) => cmdCheckout(name)));
+program
+    .command("status")
+    .description("show current tree, network, branch, and signer")
+    .action(wrap(cmdStatus));
+program
+    .command("log")
+    .description("show recent commits on a branch")
+    .option("-b, --branch <name>", "branch name (default: current git branch)")
+    .option("-n, --limit <n>", "number of commits", parseInt, 20)
+    .action(wrap((opts) => cmdLog(opts)));
+program
+    .command("recall [query]")
+    .description("semantic recall from branch memory")
+    .option("-b, --branch <name>", "branch to recall from")
+    .option("-n, --limit <n>", "max results", parseInt, 5)
+    .option("--json", "output as JSON (used by plugin hooks)")
+    .action(wrap((query, opts) => cmdRecall(query ?? "", opts)));
+program
+    .command("commit")
+    .description("commit facts to the current branch")
+    .requiredOption("-m, --message <msg>", "commit message")
+    .option("-b, --branch <name>", "branch (default: current git branch)")
+    .option("-f, --facts <facts...>", "one or more fact strings")
+    .option("--from-response <text>", "extract facts from a full response text")
+    .option("--auto-extract", "use LLM to extract durable facts (requires --from-response)")
+    .action(wrap((opts) => cmdCommit(opts)));
+program
+    .command("merge <from> <into>")
+    .description("propose a merge from one branch into another")
+    .requiredOption("-r, --resolver <id>", "ResolverRef object ID")
+    .option("--ttl <ms>", "TTL in milliseconds", parseInt, 86_400_000)
+    .action(wrap((from, into, opts) => cmdMerge(from, into, opts)));
+program
+    .command("proposals")
+    .description("list open merge proposals")
+    .action(wrap(cmdProposals));
+program
+    .command("ui")
+    .description("open the MemForks DAG visualizer")
+    .option("--share", "build and publish to a Walrus Site (shareable URL)")
+    .option("-p, --port <n>", "local server port", (v) => parseInt(v, 10), 4242)
+    .action(wrap((opts) => cmdUi(opts)));
+program
+    .command("show <commitId>")
+    .description("show details of a single commit")
+    .action(wrap((commitId) => cmdShow(commitId)));
+program
+    .command("diff <from> <to>")
+    .description("show fact differences between two branches or commits")
+    .action(wrap((from, to) => cmdDiff(from, to)));
+// ─── ACL ─────────────────────────────────────────────────────────────────────
+program
+    .command("delegates")
+    .description("list all delegates for the current tree")
+    .action(wrap(cmdDelegates));
+program
+    .command("grant <address>")
+    .description("grant a delegate key write access to the tree")
+    .option("-p, --permissions <hex>", "permission bitmask in hex (default: 0xFF = all)", "0xFF")
+    .option("--expiry <ms>", "expiry timestamp in epoch ms (default: never)", parseInt)
+    .option("-b, --branches <names...>", "restrict to specific branches")
+    .action(wrap((address, opts) => cmdGrant({ address, ...opts })));
+program
+    .command("grant-memwal <address>")
+    .description("register a team member's MemWal key (run by the owner after `memfork join`)")
+    .requiredOption("--pubkey <hex>", "MemWal delegate public key (hex) — printed by `memfork join`")
+    .action(wrap((address, opts) => cmdGrantMemwal({ agent: address, pubkey: opts.pubkey })));
+program
+    .command("revoke <address>")
+    .description("revoke a delegate key")
+    .action(wrap((address) => cmdRevoke(address)));
+// ─── Error handling ───────────────────────────────────────────────────────────
+program.configureOutput({
+    writeErr: (str) => process.stderr.write(chalk.red(str)),
+});
+program.parseAsync(process.argv).catch((e) => {
+    console.error(chalk.red("Error: " + String(e)));
+    process.exit(1);
+});
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function wrap(fn) {
+    return (...args) => {
+        fn(...args).catch((e) => {
+            if (e.name === "ConfigError") {
+                console.error(chalk.red("\n  " + String(e.message)));
+                console.error(chalk.cyan("  → Run `memfork init` to configure.\n"));
+            }
+            else {
+                console.error(chalk.red("\nError: " + String(e)));
+            }
+            process.exit(1);
+        });
+    };
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `memfork doctor`
+ *
+ * Verifies the full setup end-to-end:
+ *   ✓ / ✗  .memfork/config.json exists
+ *   ✓ / ✗  credentials file exists and is chmod 600
+ *   ✓ / ✗  Sui RPC reachable
+ *   ✓ / ✗  MemoryTree object found on-chain
+ *   ✓ / ✗  Signer address matches tree owner (or has delegate)
+ *   ✓ / ✗  MemWal account reachable
+ */
+export declare function cmdDoctor(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,170 @@
+/**
+ * `memfork doctor`
+ *
+ * Verifies the full setup end-to-end:
+ *   ✓ / ✗  .memfork/config.json exists
+ *   ✓ / ✗  credentials file exists and is chmod 600
+ *   ✓ / ✗  Sui RPC reachable
+ *   ✓ / ✗  MemoryTree object found on-chain
+ *   ✓ / ✗  Signer address matches tree owner (or has delegate)
+ *   ✓ / ✗  MemWal account reachable
+ */
+import chalk from "chalk";
+import fs from "node:fs";
+import { resolveConfig, readProjectConfig, credentialsPath, } from "../config.js";
+import { MemForksClient } from "@memfork/core";
+function icon(s) {
+    return { ok: chalk.green("✓"), fail: chalk.red("✗"), warn: chalk.yellow("⚠"), skip: chalk.dim("·") }[s];
+}
+function printCheck(c) {
+    console.log(`  ${icon(c.status)}  ${c.label}` + (c.detail ? chalk.dim("  — " + c.detail) : ""));
+    if (c.fix && c.status !== "ok" && c.status !== "skip") {
+        console.log(`      ${chalk.cyan("→")} ${c.fix}`);
+    }
+}
+export async function cmdDoctor() {
+    console.log("");
+    console.log(chalk.bold("memfork doctor"));
+    console.log("");
+    const checks = [];
+    let cfg;
+    // ── 1. Project config ──────────────────────────────────────────────────────
+    const project = readProjectConfig();
+    checks.push({
+        label: ".memfork/config.json",
+        status: project ? "ok" : "warn",
+        detail: project ? `tree: ${project.treeId?.slice(0, 10)}…` : "not found (credentials-only mode)",
+        fix: project ? undefined : "Run `memfork init` from the project root to create it",
+    });
+    // ── 2. Credentials file ─────────────────────────────────────────────────────
+    const credsPath = credentialsPath();
+    const credsExists = fs.existsSync(credsPath);
+    let credsPerms = "skip";
+    if (credsExists) {
+        const mode = fs.statSync(credsPath).mode & 0o777;
+        credsPerms = (mode === 0o600) ? "ok" : "warn";
+    }
+    checks.push({
+        label: "~/.memfork/credentials.json",
+        status: credsExists ? (credsPerms === "ok" ? "ok" : "warn") : "fail",
+        detail: credsExists ? (credsPerms === "ok" ? "chmod 600 ✓" : "permissions too open") : "not found",
+        fix: credsExists
+            ? "Run: chmod 600 ~/.memfork/credentials.json"
+            : "Run `memfork init` to create it",
+    });
+    // ── 3. Config resolution ────────────────────────────────────────────────────
+    try {
+        cfg = resolveConfig();
+        checks.push({
+            label: "Config resolution",
+            status: "ok",
+            detail: `tree ${cfg.treeId.slice(0, 10)}… / ${cfg.network}`,
+        });
+    }
+    catch (e) {
+        checks.push({
+            label: "Config resolution",
+            status: "fail",
+            detail: e.message,
+            fix: "Run `memfork init`",
+        });
+        checks.forEach(printCheck);
+        console.log("");
+        console.log(chalk.red("  Setup incomplete. Run `memfork init` to fix."));
+        console.log("");
+        process.exit(1);
+    }
+    // ── 4. Sui RPC reachable ────────────────────────────────────────────────────
+    let client;
+    try {
+        client = await MemForksClient.connect({
+            treeId: cfg.treeId,
+            signer: cfg.privateKey,
+            network: cfg.network,
+            rpcUrl: cfg.rpcUrl,
+            packageId: cfg.packageId,
+        });
+        // Quick liveness ping — getChainIdentifier is cheap.
+        await client.suiClient.getChainIdentifier();
+        checks.push({ label: "Sui RPC", status: "ok", detail: cfg.rpcUrl ?? `${cfg.network} default` });
+    }
+    catch (e) {
+        checks.push({
+            label: "Sui RPC",
+            status: "fail",
+            detail: String(e),
+            fix: "Check your network connection or set a custom MEMFORK_RPC_URL",
+        });
+        checks.forEach(printCheck);
+        console.log("");
+        process.exit(1);
+    }
+    // ── 5. MemoryTree on-chain ──────────────────────────────────────────────────
+    try {
+        const tree = await client.getTree();
+        checks.push({
+            label: "MemoryTree on-chain",
+            status: "ok",
+            detail: `default branch: ${tree.default_branch}`,
+        });
+    }
+    catch (e) {
+        checks.push({
+            label: "MemoryTree on-chain",
+            status: "fail",
+            detail: `object not found: ${cfg.treeId.slice(0, 10)}…`,
+            fix: "Check the treeId in .memfork/config.json or run `memfork init`",
+        });
+    }
+    // ── 6. Signer balance (warn if low) ─────────────────────────────────────────
+    try {
+        const addr = client.keypair.toSuiAddress();
+        const balance = await client.suiClient.getBalance({ owner: addr });
+        const sui = Number(balance.totalBalance) / 1e9;
+        const low = sui < 0.1;
+        checks.push({
+            label: "Signer balance",
+            status: low ? "warn" : "ok",
+            detail: `${sui.toFixed(4)} SUI  (${addr.slice(0, 10)}…)`,
+            fix: low ? (cfg.network === "mainnet" ? "Gas is sponsored — no SUI needed. If you need a balance, send SUI to the address above." : "Fund via faucet: sui client faucet  or https://faucet.testnet.sui.io") : undefined,
+        });
+    }
+    catch {
+        checks.push({ label: "Signer balance", status: "skip", detail: "could not fetch" });
+    }
+    // ── 7. MemWal reachable ──────────────────────────────────────────────────────
+    try {
+        const resp = await fetch(cfg.memwalRelayer + "/health", { signal: AbortSignal.timeout(5000) });
+        checks.push({
+            label: "MemWal relayer",
+            status: resp.ok ? "ok" : "warn",
+            detail: resp.ok ? cfg.memwalRelayer : `HTTP ${resp.status}`,
+            fix: resp.ok ? undefined : "Check MEMFORK_MEMWAL_RELAYER or try again",
+        });
+    }
+    catch {
+        checks.push({
+            label: "MemWal relayer",
+            status: "warn",
+            detail: "could not reach " + cfg.memwalRelayer,
+            fix: "Check your network. MemWal read/write will be unavailable.",
+        });
+    }
+    // ── Print all checks ─────────────────────────────────────────────────────────
+    console.log("");
+    checks.forEach(printCheck);
+    console.log("");
+    const failed = checks.filter((c) => c.status === "fail").length;
+    const warned = checks.filter((c) => c.status === "warn").length;
+    if (failed > 0) {
+        console.log(chalk.red(`  ${failed} check(s) failed. Run \`memfork init\` to fix.`));
+        process.exit(1);
+    }
+    else if (warned > 0) {
+        console.log(chalk.yellow(`  ${warned} warning(s). Setup is functional but review the items above.`));
+    }
+    else {
+        console.log(chalk.green("  Everything looks good."));
+    }
+    console.log("");
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `memfork init`
+ *
+ * Interactive first-run setup. Writes:
+ *   .memfork/config.json        — committable project config (treeId, network, branch)
+ *   ~/.memfork/credentials.json — secrets, chmod 600 (privateKey, memwalKey, etc.)
+ *
+ * Idempotent: re-running updates values without destroying existing ones.
+ */
+export declare function cmdInit(opts?: {
+    quick?: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,286 @@
+/**
+ * `memfork init`
+ *
+ * Interactive first-run setup. Writes:
+ *   .memfork/config.json        — committable project config (treeId, network, branch)
+ *   ~/.memfork/credentials.json — secrets, chmod 600 (privateKey, memwalKey, etc.)
+ *
+ * Idempotent: re-running updates values without destroying existing ones.
+ */
+import { input, select, password, confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import fs from "node:fs";
+import path from "node:path";
+import { readProjectConfig, readCredentials, writeProjectConfig, upsertCredential, credentialsPath, } from "../config.js";
+import { MemForksClient } from "@memfork/core";
+import { autoProvision } from "./provision.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function dim(s) { return chalk.dim(s); }
+function ok(s) { return chalk.green("✓") + " " + s; }
+function err(s) { return chalk.red("✗") + " " + chalk.red(s); }
+function tip(s) { return chalk.cyan("→") + " " + s; }
+// ─── Command ──────────────────────────────────────────────────────────────────
+export async function cmdInit(opts = {}) {
+    console.log("");
+    console.log(chalk.bold("MemForks init") + "  " + dim("configure your memory tree"));
+    console.log("");
+    // ── Mode selection ──────────────────────────────────────────────────────────
+    const mode = opts.quick
+        ? "quick"
+        : await select({
+            message: "How do you want to set up?",
+            choices: [
+                {
+                    value: "quick",
+                    name: "Quick setup  " + chalk.dim("— auto-provision: keygen → faucet → MemWal → tree  (recommended)"),
+                },
+                {
+                    value: "manual",
+                    name: "Manual setup  " + chalk.dim("— paste existing keys & IDs"),
+                },
+            ],
+        });
+    if (mode === "quick") {
+        await cmdInitQuick();
+    }
+    else {
+        await cmdInitManual();
+    }
+}
+// ─── Quick path ───────────────────────────────────────────────────────────────
+async function cmdInitQuick() {
+    console.log("");
+    console.log(dim("  We'll generate a fresh keypair, fund it from the faucet,"));
+    console.log(dim("  create your MemWal account and memory tree automatically."));
+    console.log(dim("  Nothing to copy-paste."));
+    console.log("");
+    const network = await select({
+        message: "Sui network",
+        choices: [
+            { value: "mainnet", name: "mainnet  (recommended — gas sponsored by MemForks)" },
+            { value: "testnet", name: "testnet  (free gas via faucet)" },
+        ],
+    });
+    const existingKey = readProjectConfig()
+        ? (await confirm({
+            message: "Reuse your existing Sui key instead of generating a new one?",
+            default: false,
+        }))
+            ? await password({
+                message: "Sui private key  (suiprivkey1… or 64-char hex)",
+                mask: "*",
+            })
+            : undefined
+        : undefined;
+    console.log("");
+    try {
+        const result = await autoProvision({
+            network,
+            existingKey: existingKey || undefined,
+        });
+        // Persist
+        writeProjectConfig({
+            treeId: result.treeId,
+            network: result.network,
+            defaultBranch: "main",
+        });
+        upsertCredential(result.treeId, {
+            privateKey: result.privateKey,
+            memwalAccountId: result.memwalAccountId,
+            memwalKey: result.memwalKey,
+        });
+        ensureGitignore();
+        console.log("");
+        console.log(chalk.green.bold("  Setup complete!"));
+        console.log("");
+        console.log(ok(`Tree ID:     ${chalk.bold(result.treeId)}`));
+        console.log(ok(`Address:     ${chalk.dim("(saved to credentials)")}`));
+        console.log(ok(`Project cfg: ${chalk.bold(".memfork/config.json")}  ${dim("(safe to commit)")}`));
+        console.log(ok(`Credentials: ${chalk.bold(credentialsPath())}  ${dim("(chmod 600, gitignored)")}`));
+        printNextSteps();
+    }
+    catch (e) {
+        console.log("");
+        console.log(err(String(e)));
+        process.exit(1);
+    }
+}
+// ─── Manual path ──────────────────────────────────────────────────────────────
+async function cmdInitManual() {
+    const existing = readProjectConfig();
+    const creds = readCredentials();
+    // ── Step 1: network ──────────────────────────────────────────────────────────
+    const network = await select({
+        message: "Sui network",
+        default: existing?.network ?? "mainnet",
+        choices: [
+            { value: "mainnet", name: "mainnet  (recommended — gas sponsored by MemForks)" },
+            { value: "testnet", name: "testnet  (free gas via faucet)" },
+            { value: "devnet", name: "devnet" },
+            { value: "localnet", name: "localnet" },
+        ],
+    });
+    // ── Step 2: tree ID ──────────────────────────────────────────────────────────
+    const treeMode = await select({
+        message: "MemoryTree",
+        choices: [
+            { value: "existing", name: "Use an existing tree  (paste the object ID)" },
+            { value: "new", name: "Create a new tree now" },
+        ],
+    });
+    let treeId = "";
+    if (treeMode === "existing") {
+        treeId = (await input({
+            message: "Tree object ID (0x…)",
+            default: existing?.treeId,
+            validate: (v) => /^0x[0-9a-fA-F]{64}$/.test(v.trim()) ? true : "Must be a 64-char hex address starting with 0x",
+        })).trim();
+    }
+    // ── Step 3: Sui private key ───────────────────────────────────────────────────
+    const storedKey = treeMode === "existing" ? creds.trees[treeId]?.privateKey : undefined;
+    const privateKeyInput = await password({
+        message: storedKey
+            ? "Sui private key  (suiprivkey1… or hex — enter to keep existing)"
+            : "Sui private key  (suiprivkey1… bech32 or 64-char hex)",
+        mask: "*",
+        validate: (v) => {
+            if (storedKey && v === "")
+                return true;
+            if (v.startsWith("suiprivkey"))
+                return true;
+            if (/^[0-9a-fA-F]{64}$/.test(v))
+                return true;
+            return "Expected suiprivkey1… (Sui CLI format) or 64-char hex";
+        },
+    });
+    const resolvedKey = privateKeyInput === "" && storedKey ? storedKey : privateKeyInput;
+    // ── Step 4: create tree if needed ─────────────────────────────────────────────
+    if (treeMode === "new") {
+        console.log("");
+        const defaultBranch = await input({ message: "Default branch name", default: "main" });
+        const memwalAccId = (await input({
+            message: "MemWal account ID  (0x…)",
+            validate: (v) => /^0x[0-9a-fA-F]{64}$/.test(v.trim()) ? true : "Must be 0x… address",
+        })).trim();
+        process.stdout.write(chalk.dim("  Creating MemoryTree on " + network + "…  "));
+        try {
+            const tempClient = await MemForksClient.connect({
+                treeId: "0x" + "0".repeat(64),
+                signer: resolvedKey,
+                network,
+            });
+            const { treeId: newId, digest } = await tempClient.initTree(memwalAccId, defaultBranch);
+            treeId = newId;
+            console.log(chalk.green("done"));
+            console.log(ok(`Tree created: ${chalk.bold(treeId)}`));
+            console.log(dim(`  tx: ${digest}`));
+        }
+        catch (e) {
+            console.log(chalk.red("failed"));
+            console.error(err(String(e)));
+            process.exit(1);
+        }
+    }
+    // ── Step 5: MemWal credentials ────────────────────────────────────────────────
+    console.log("");
+    console.log(dim("  MemWal — decentralised blob storage for memory contents."));
+    console.log("");
+    const storedCred = creds.trees[treeId];
+    const memwalAccountId = (await input({
+        message: "MemWal account ID (0x…)",
+        default: storedCred?.memwalAccountId,
+        validate: (v) => /^0x[0-9a-fA-F]{64}$/.test(v.trim()) ? true : "Must be 0x… address",
+    })).trim();
+    const memwalKeyInput = await password({
+        message: storedCred?.memwalKey
+            ? "MemWal delegate key  (enter to keep existing)"
+            : "MemWal delegate key  (64-char hex)",
+        mask: "*",
+        validate: (v) => {
+            if (storedCred?.memwalKey && v === "")
+                return true;
+            if (/^[0-9a-fA-F]{64}$/.test(v))
+                return true;
+            return "Expected 64-char hex";
+        },
+    });
+    const resolvedMemwalKey = memwalKeyInput === "" && storedCred?.memwalKey
+        ? storedCred.memwalKey
+        : memwalKeyInput;
+    // ── Step 6: optional overrides ────────────────────────────────────────────────
+    const advanced = await confirm({
+        message: "Configure advanced options (RPC URL, package ID override)?",
+        default: false,
+    });
+    let rpcUrl;
+    let packageId;
+    let defaultBranch = existing?.defaultBranch ?? "main";
+    if (advanced) {
+        rpcUrl = (await input({ message: "Custom RPC URL  (leave blank for default)" })).trim() || undefined;
+        packageId = (await input({ message: "Package ID override  (leave blank for default)" })).trim() || undefined;
+        defaultBranch = await input({ message: "Default branch", default: defaultBranch });
+    }
+    // ── Write ──────────────────────────────────────────────────────────────────────
+    writeProjectConfig({
+        treeId,
+        network: network ?? "testnet",
+        defaultBranch,
+        ...(rpcUrl ? { rpcUrl } : {}),
+        ...(packageId ? { packageId } : {}),
+    });
+    upsertCredential(treeId, {
+        privateKey: resolvedKey,
+        memwalAccountId,
+        memwalKey: resolvedMemwalKey,
+    });
+    ensureGitignore();
+    console.log("");
+    console.log(ok(`Project config written to ${chalk.bold(".memfork/config.json")}  ${dim("(safe to commit)")}`));
+    console.log(ok(`Credentials stored in ${chalk.bold(credentialsPath())}  ${dim("(chmod 600, gitignored)")}`));
+    console.log("");
+    // ── Verify ────────────────────────────────────────────────────────────────────
+    process.stdout.write(chalk.dim("  Verifying connection to Sui…  "));
+    try {
+        const client = await MemForksClient.connect({
+            treeId,
+            signer: resolvedKey,
+            network: network ?? "testnet",
+            ...(rpcUrl ? { rpcUrl } : {}),
+            ...(packageId ? { packageId } : {}),
+        });
+        await client.getTree();
+        console.log(chalk.green("ok"));
+    }
+    catch {
+        console.log(chalk.yellow("failed"));
+        console.log(chalk.yellow("  ⚠ Could not reach tree — run `memfork doctor` to diagnose."));
+    }
+    printNextSteps();
+}
+// ─── Shared footer ─────────────────────────────────────────────────────────────
+function printNextSteps() {
+    console.log("");
+    console.log(chalk.bold("Next steps:"));
+    console.log(tip("memfork doctor           — verify the full setup"));
+    console.log(tip("memfork install cursor   — install the Cursor plugin"));
+    console.log(tip("memfork install codex    — install the Codex plugin"));
+    console.log(tip("memfork status           — show tree status"));
+    console.log("");
+}
+// ─── .gitignore helper ────────────────────────────────────────────────────────
+function ensureGitignore(cwd = process.cwd()) {
+    const lines = [
+        ".memfork/credentials.json",
+        ".memfork/*.local.json",
+    ];
+    const gitignorePath = path.join(cwd, ".gitignore");
+    let existing = "";
+    if (fs.existsSync(gitignorePath)) {
+        existing = fs.readFileSync(gitignorePath, "utf8");
+    }
+    const toAdd = lines.filter((l) => !existing.includes(l));
+    if (toAdd.length === 0)
+        return;
+    const block = "\n# MemForks — never commit private keys\n" + toAdd.join("\n") + "\n";
+    fs.appendFileSync(gitignorePath, block, "utf8");
+}