@credibledata/cred-cli 0.0.103 → 0.0.105

package/dist/setup-core/flow.spec.js

@@ -0,0 +1,1348 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const briefing_1 = require("./briefing");
+const credstore_1 = require("./credstore");
+const flow_1 = require("./flow");
+const folderconfig_1 = require("./folderconfig");
+const host_1 = require("./host");
+const ports_1 = require("./ports");
+const publisherversion_1 = require("./publisherversion");
+const liveness = __importStar(require("./liveness"));
+const supervisor_1 = require("./supervisor");
+/** A Host that answers scripted values and records what it was asked. */
+function fakeHost(answers = {}) {
+    const logs = [];
+    const asked = [];
+    return {
+        logs,
+        asked,
+        select(message, choices) {
+            return __awaiter(this, void 0, void 0, function* () {
+                asked.push(message);
+                if (message in answers)
+                    return answers[message];
+                const first = choices.find((choice) => !choice.disabled);
+                if (!first)
+                    throw new Error(`nothing selectable for "${message}"`);
+                return first.value;
+            });
+        },
+        selectMany(message, choices) {
+            return __awaiter(this, void 0, void 0, function* () {
+                asked.push(message);
+                if (message in answers)
+                    return answers[message];
+                return choices
+                    .filter((choice) => !choice.disabled)
+                    .map((choice) => choice.value);
+            });
+        },
+        confirm(message) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                asked.push(message);
+                return Boolean((_a = answers[message]) !== null && _a !== void 0 ? _a : true);
+            });
+        },
+        log(level, message) {
+            logs.push(`${level}: ${message}`);
+        },
+        write(chunk) {
+            logs.push(`raw: ${chunk}`);
+        },
+        openUrl(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logs.push(`open: ${url}`);
+            });
+        },
+    };
+}
+/** Where the supervisor records the running publisher's pid, beside its config. */
+function pidFile(configPath) {
+    return path_1.default.join(path_1.default.dirname(configPath), supervisor_1.SESSION_PID_FILE);
+}
+/** Run git in a directory, for building the repository states under test. */
+function git(args, cwd) {
+    (0, child_process_1.execFileSync)("git", args, { cwd, stdio: "ignore" });
+}
+function jwt(claims) {
+    const part = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
+    return `${part({ alg: "HS256" })}.${part(claims)}.sig`;
+}
+describe("joinNames", () => {
+    it("joins one, two and three names the way a sentence would", () => {
+        (0, chai_1.expect)((0, flow_1.joinNames)(["a"])).to.equal("a");
+        (0, chai_1.expect)((0, flow_1.joinNames)(["a", "b"])).to.equal("a and b");
+        (0, chai_1.expect)((0, flow_1.joinNames)(["a", "b", "c"])).to.equal("a, b and c");
+    });
+});
+describe("setup flow", () => {
+    let workDir;
+    let homeDir;
+    let homeStub;
+    beforeEach(() => {
+        workDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "flow-"));
+        // Session directories go under the home directory. Without this every
+        // run left one per test in the developer's real ~/.credible/sessions.
+        // Its own directory, not inside `workDir`: a session directory inside
+        // the modeling directory is exactly what one test asserts never happens.
+        homeDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "flow-home-"));
+        homeStub = sinon_1.default.stub(os_1.default, "homedir").returns(homeDir);
+    });
+    afterEach(() => {
+        homeStub.restore();
+        fs_1.default.rmSync(workDir, { recursive: true, force: true });
+        fs_1.default.rmSync(homeDir, { recursive: true, force: true });
+    });
+    /** A credential store on disk, already "logged in" to acme/prod-bars. */
+    function loggedInStore() {
+        const credPath = path_1.default.join(workDir, ".cred");
+        fs_1.default.writeFileSync(credPath, JSON.stringify({
+            configPerEnvironment: {
+                production: {
+                    organization: "acme",
+                    project: "prod-bars",
+                    jwtAccessToken: jwt({
+                        aud: "https://ms2data.us.auth0.com/api/v2/",
+                        exp: Math.floor(Date.now() / 1000) + 3600,
+                    }),
+                },
+            },
+            activeEnvironment: "production",
+        }));
+        return new credstore_1.ClientConfiguration(credPath);
+    }
+    function context(host, credStore) {
+        return {
+            host,
+            credStore,
+            deployment: "production",
+            publisherVersion: publisherversion_1.PUBLISHER_VERSION,
+            cwd: workDir,
+            listConnections: () => __awaiter(this, void 0, void 0, function* () { return [{ name: "warehouse" }]; }),
+        };
+    }
+    // Without a terminal a question exits 2. It used to be asked after the
+    // environment was created, so an agent that stopped there left an empty
+    // environment behind. Every case here must throw before anything exists.
+    describe("refusing unanswerable questions before writing", () => {
+        function withWarehouse() {
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "publisher.config.json"), JSON.stringify({
+                environments: [
+                    {
+                        name: "default",
+                        connections: [
+                            {
+                                name: "warehouse",
+                                type: "postgres",
+                                postgresConnection: { host: "db" },
+                            },
+                            { name: "local", type: "duckdb", duckdbConnection: {} },
+                        ],
+                    },
+                ],
+            }));
+        }
+        const nothingWritten = () => (0, chai_1.expect)(fs_1.default.readdirSync(workDir).sort()).to.eql([
+            "publisher.config.json",
+        ]);
+        it("refuses a missing --connections, naming the importable ones", () => {
+            withWarehouse();
+            const error = (() => {
+                try {
+                    (0, flow_1.refuseUnanswerable)(workDir, {}, false);
+                }
+                catch (e) {
+                    return e;
+                }
+            })();
+            (0, chai_1.expect)(error).to.be.instanceOf(host_1.NeedsInputError);
+            (0, chai_1.expect)(error.message).to.equal('Cannot ask "Which connections should Credible test? Ticking one sends it to Credible for a reachability test; nothing is saved yet." without a terminal. Pass --connections <all|none|name,name>. Options: warehouse.');
+            nothingWritten();
+        });
+        it("refuses a misspelled connection name, with or without a terminal", () => {
+            withWarehouse();
+            for (const interactive of [false, true]) {
+                (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, { connections: ["warehous"] }, interactive))
+                    .to.throw(host_1.SetupError)
+                    .with.property("message")
+                    .that.contains("No connection named 'warehous'");
+            }
+            nothingWritten();
+        });
+        // `findLocalPublisherConfig` reads a missing file and a malformed one
+        // alike as "nothing to offer", so a named selection went unchecked and
+        // setup exited 0 having imported nothing.
+        it("refuses named connections when there is no file to find them in", () => {
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, { connections: ["warehouse"] }, true))
+                .to.throw(host_1.SetupError)
+                .with.property("message")
+                .that.contains(`There is no ${path_1.default.join(workDir, "publisher.config.json")}.`);
+        });
+        it("says so when the file is there but is not JSON", () => {
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "publisher.config.json"), "{ not json");
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, { connections: ["warehouse"] }, true))
+                .to.throw(host_1.SetupError)
+                .with.property("message")
+                .that.contains("is not valid JSON");
+        });
+        it("lets a named, all or none selection through", () => {
+            withWarehouse();
+            for (const connections of [["warehouse"], "all", "none"]) {
+                (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, { connections: connections }, false)).not.to.throw();
+            }
+        });
+        it("refuses a missing --skills when skills cred did not install are present", () => {
+            fs_1.default.mkdirSync(path_1.default.join(workDir, ".claude/skills/eval-answer"), {
+                recursive: true,
+            });
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, {}, false))
+                .to.throw(host_1.NeedsInputError)
+                .with.property("message")
+                .that.contains("Pass --skills <replace|keep|none>.");
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, { skills: "replace" }, false)).not.to.throw();
+        });
+        it("asks nothing up front at a terminal, where the pickers can run", () => {
+            withWarehouse();
+            fs_1.default.mkdirSync(path_1.default.join(workDir, ".claude/skills/eval-answer"), {
+                recursive: true,
+            });
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, {}, true)).not.to.throw();
+        });
+    });
+    // The "I already run a publisher" journey: the user's own server is up on
+    // 4000/4040, started from this directory. Moving to a derived pair rewrote
+    // `.mcp.json` away from the one server the agent could reach.
+    describe("another publisher on the default ports", () => {
+        let serving;
+        beforeEach(() => {
+            serving = sinon_1.default
+                .stub(liveness, "isPublisherServing")
+                .callsFake((port) => __awaiter(void 0, void 0, void 0, function* () { return port === 4000; }));
+            // The journey: this directory has its own publisher config.
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "publisher.config.json"), JSON.stringify({ environments: [] }));
+        });
+        afterEach(() => serving.restore());
+        // Two cred directories: the first one's `cred dev` holds 4000/4040.
+        // A second directory with no publisher config of its own is not the
+        // journey this check is for, and gets a derived pair as ports.ts
+        // intends, not a refusal or a pin onto the first one's server.
+        it("leaves a directory without its own publisher config to the derived pair", () => __awaiter(void 0, void 0, void 0, function* () {
+            fs_1.default.rmSync(path_1.default.join(workDir, "publisher.config.json"));
+            const host = fakeHost();
+            const wired = yield (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                // `wireDirectory` only wires; `start` is what makes the check
+                // refuse, and nothing is spawned here.
+                start: true,
+                open: false,
+            }).catch((e) => e);
+            (0, chai_1.expect)(wired).to.not.be.instanceOf(host_1.SetupError);
+            (0, chai_1.expect)(host.logs.join("\n")).to.not.contain("Another Publisher");
+        }));
+        it("keeps this directory on 4000/4040 with --no-start, and says to stop the other one", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = fakeHost();
+            const wired = yield (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)([wired.uiPort, wired.mcpPort]).to.eql([4000, 4040]);
+            const mcp = JSON.parse(fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8"));
+            (0, chai_1.expect)(mcp.mcpServers.malloy.url).to.equal("http://127.0.0.1:4040/mcp");
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("stop that one before `cred dev`");
+            const free = yield (0, ports_1.suggestFreePair)(workDir);
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain(`Or keep it running and move this directory: re-run with --port ${free.uiPort}`);
+        }));
+        it("refuses to start beside it, before importing anything", () => __awaiter(void 0, void 0, void 0, function* () {
+            const created = [];
+            const error = yield (0, flow_1.wireDirectory)(Object.assign(Object.assign({}, context(fakeHost(), loggedInStore())), { createConnection: (connection) => __awaiter(void 0, void 0, void 0, function* () {
+                    created.push(String(connection.name));
+                    return { ok: true };
+                }) }), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: true,
+                open: false,
+            }).catch((e) => e);
+            (0, chai_1.expect)(error).to.be.instanceOf(host_1.SetupError);
+            (0, chai_1.expect)(error.message).to.contain("Another Publisher, not one this directory's cred session started, is running on ports 4000/4040.");
+            // The way out names a pair that is free now, so an agent can re-run
+            // without probing ports itself.
+            const free = yield (0, ports_1.suggestFreePair)(workDir);
+            (0, chai_1.expect)(error.fix).to.contain(`re-run with --port ${free.uiPort} (free now; MCP takes ${free.mcpPort}).`);
+            (0, chai_1.expect)(created).to.eql([]);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".mcp.json"))).to.equal(false);
+        }));
+        it("serves on the --port pair beside it, and remembers it", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const free = (yield (0, ports_1.suggestFreePair)(workDir));
+            const host = fakeHost();
+            const wired = yield (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                port: free.uiPort,
+                start: true,
+                open: false,
+            });
+            (0, chai_1.expect)([wired.uiPort, wired.mcpPort]).to.eql([
+                free.uiPort,
+                free.mcpPort,
+            ]);
+            (0, chai_1.expect)((_a = (0, folderconfig_1.findFolderConfig)(workDir)) === null || _a === void 0 ? void 0 : _a.config.ports).to.eql(free);
+            const mcp = JSON.parse(fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8"));
+            (0, chai_1.expect)(mcp.mcpServers.malloy.url).to.equal(`http://127.0.0.1:${free.mcpPort}/mcp`);
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain(`This directory now uses ports ${free.uiPort}/${free.mcpPort}, and will keep doing so.`);
+        }));
+        it("refuses a busy --port pair before login, in the early guard", () => __awaiter(void 0, void 0, void 0, function* () {
+            const taken = (yield (0, ports_1.suggestFreePair)(workDir));
+            const holder = http_1.default.createServer();
+            yield new Promise((resolve) => holder.listen(taken.uiPort, "127.0.0.1", resolve));
+            try {
+                const error = yield (0, flow_1.refuseBesideOtherPublisher)(workDir, taken.uiPort).catch((e) => e);
+                (0, chai_1.expect)(error).to.be.instanceOf(host_1.SetupError);
+                const free = (yield (0, ports_1.suggestFreePair)(workDir));
+                (0, chai_1.expect)(error.message).to.equal(`Ports ${taken.uiPort}/${taken.mcpPort}, from --port ${taken.uiPort}, are in use. Fix: re-run with --port ${free.uiPort} (free now; MCP takes ${free.mcpPort}). cred remembers it and points .mcp.json there.`);
+            }
+            finally {
+                holder.close();
+            }
+        }));
+        it("refuses a --port pair something else holds, and names a free one", () => __awaiter(void 0, void 0, void 0, function* () {
+            const taken = (yield (0, ports_1.suggestFreePair)(workDir));
+            const holder = http_1.default.createServer();
+            yield new Promise((resolve) => holder.listen(taken.mcpPort, "127.0.0.1", resolve));
+            try {
+                const error = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                    directory: workDir,
+                    organization: "acme",
+                    credibleEnvironment: "prod-bars",
+                    port: taken.uiPort,
+                    start: true,
+                    open: false,
+                }).catch((e) => e);
+                (0, chai_1.expect)(error).to.be.instanceOf(host_1.SetupError);
+                (0, chai_1.expect)(error.message).to.contain(`Ports ${taken.uiPort}/${taken.mcpPort}, from --port ${taken.uiPort}, are in use.`);
+                const free = (yield (0, ports_1.suggestFreePair)(workDir));
+                (0, chai_1.expect)(free.uiPort).to.not.equal(taken.uiPort);
+                (0, chai_1.expect)(error.fix).to.contain(`re-run with --port ${free.uiPort}`);
+                (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".mcp.json"))).to.equal(false);
+            }
+            finally {
+                holder.close();
+            }
+        }));
+    });
+    describe("wireDirectory", () => {
+        it("warns on screen when the Credible environment has no connections", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = fakeHost();
+            yield (0, flow_1.wireDirectory)(Object.assign(Object.assign({}, context(host, loggedInStore())), { listConnections: () => __awaiter(void 0, void 0, void 0, function* () { return []; }) }), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("The Credible environment 'prod-bars' has no connections, so the local Publisher will have nothing to query. To fix it, add one with `cred add connection`, then restart `cred dev`.");
+        }));
+        it("does not warn when it has some", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = fakeHost();
+            yield (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(host.logs.join("\n")).to.not.contain("has no connections");
+        }));
+        it("leaves a complete, self-consistent directory on disk", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = fakeHost();
+            const wired = yield (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            // publisher.config.json is NOT written by wiring — the supervisor
+            // writes it at spawn, because that is when a token can be stamped.
+            // And it is never written into the modeling directory at all: it
+            // carries a live warehouse token, so it must not be somewhere
+            // `git add -A` can reach. See `sessionConfigPath`.
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, "publisher.config.json")), "a token-bearing config must never land in the modeling directory").to.equal(false);
+            (0, chai_1.expect)(wired.configPath.startsWith(workDir)).to.equal(false);
+            (0, chai_1.expect)(wired.configPath).to.equal(path_1.default.join(wired.serverRoot, "publisher.config.json"));
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".mcp.json"))).to.equal(true);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, "CLAUDE.md"))).to.equal(true);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, "AGENTS.md"))).to.equal(true);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".credible", "config.json"))).to.equal(true);
+            // Named after the Credible environment it proxies to, so the two names
+            // read as a pair. It was `default`, and an agent passed `prod-bars` to
+            // the local tools and got "Resource not found".
+            (0, chai_1.expect)(wired.config.environments[0].name).to.equal("prod-bars-local");
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, "CLAUDE.md"), "utf-8")).to.contain("- Local environment: `prod-bars-local`");
+            // The port in .mcp.json must be the port the pin remembers, or a later
+            // `cred dev` would bind one port and the agent would dial another.
+            const mcp = JSON.parse(fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8"));
+            const pin = (0, folderconfig_1.findFolderConfig)(workDir).config;
+            (0, chai_1.expect)(mcp.mcpServers.malloy.url).to.contain(String(pin.ports.mcpPort));
+            (0, chai_1.expect)(wired.mcpPort).to.equal(pin.ports.mcpPort);
+            // The manifest has to be one `cred publish` can send: a version is
+            // the package's version id, and without one the server 500s.
+            (0, chai_1.expect)(JSON.parse(fs_1.default.readFileSync(path_1.default.join(workDir, "publisher.json"), "utf-8"))).to.eql({
+                name: path_1.default.basename(workDir),
+                version: "0.0.1",
+                description: "",
+            });
+        }));
+        // Leaving production out of the pin made the directory follow the global
+        // deployment, so a production directory used staging's credentials once
+        // `~/.cred` moved to staging.
+        it("pins the deployment, production included", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.deployment).to.equal("production");
+        }));
+        it("re-pins a directory that moves from staging back to production", () => __awaiter(void 0, void 0, void 0, function* () {
+            const options = {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            };
+            yield (0, flow_1.wireDirectory)(Object.assign(Object.assign({}, context(fakeHost(), loggedInStore())), { deployment: "staging" }), options);
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.deployment).to.equal("staging");
+            yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), options);
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.deployment).to.equal("production");
+            // Only that key: the merge still has to preserve everything else.
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.organization).to.equal("acme");
+        }));
+        it("keeps a directory's ports when it is named by a relative path", () => __awaiter(void 0, void 0, void 0, function* () {
+            // `directory` reaches three hash/compare sites — the session directory,
+            // the derived port pair, and `findFolderConfig`'s always-absolute
+            // `root` — so an unresolved `--directory` was a different identity at
+            // each. `cred init -d sub` re-derived its ports every run and rewrote
+            // `.mcp.json` with a URL the agent's saved config no longer matched.
+            const relative = path_1.default.relative(process.cwd(), workDir);
+            const options = {
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            };
+            const first = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), Object.assign(Object.assign({}, options), { directory: workDir }));
+            const second = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), Object.assign(Object.assign({}, options), { directory: relative }));
+            (0, chai_1.expect)(second.directory).to.equal(workDir);
+            (0, chai_1.expect)(second.uiPort).to.equal(first.uiPort);
+            (0, chai_1.expect)(second.mcpPort).to.equal(first.mcpPort);
+            (0, chai_1.expect)(second.serverRoot).to.equal(first.serverRoot);
+            (0, chai_1.expect)(second.config.environments[0].packages[0].location).to.equal(workDir);
+        }));
+        it("refuses with an actionable message when no environment is selected", () => __awaiter(void 0, void 0, void 0, function* () {
+            let thrown;
+            try {
+                yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                    directory: workDir,
+                    organization: "acme",
+                    credibleEnvironment: "",
+                    start: false,
+                    open: false,
+                });
+            }
+            catch (error) {
+                thrown = error;
+            }
+            (0, chai_1.expect)(thrown).to.be.instanceOf(host_1.SetupError);
+            (0, chai_1.expect)(thrown.message).to.contain("cred set environment");
+        }));
+        // A second `cred dev` found the pinned ports busy — held by the first —
+        // moved to another pair, rewrote `.mcp.json` and started a second server,
+        // leaving the first serving on the URL an open agent still had.
+        it("refuses to start a second session while this directory's publisher is running", () => __awaiter(void 0, void 0, void 0, function* () {
+            const server = http_1.default.createServer((_request, response) => {
+                response.writeHead(200).end("[]");
+            });
+            yield new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+            const uiPort = server.address().port;
+            const store = loggedInStore();
+            const base = {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                open: false,
+            };
+            const wired = yield (0, flow_1.wireDirectory)(context(fakeHost(), store), Object.assign(Object.assign({}, base), { start: false }));
+            (0, folderconfig_1.writeFolderConfig)(workDir, { ports: { uiPort, mcpPort: uiPort + 1 } });
+            // The running session's config and pid: present only while one runs.
+            fs_1.default.writeFileSync(wired.configPath, "{}");
+            fs_1.default.writeFileSync(pidFile(wired.configPath), String(process.pid));
+            try {
+                yield (0, flow_1.wireDirectory)(context(fakeHost(), store), Object.assign(Object.assign({}, base), { start: true }));
+                chai_1.expect.fail("expected a refusal");
+            }
+            catch (error) {
+                (0, chai_1.expect)(error.message).to.equal(`A local Publisher for this directory is already running at http://localhost:${uiPort}. Fix: use that one (\`cred status --json\` reports it), or stop it — Ctrl-C in its terminal — and run this again.`);
+            }
+            finally {
+                fs_1.default.rmSync(wired.configPath, { force: true });
+                server.close();
+            }
+            // Wiring without starting is still allowed: it starts nothing.
+            yield (0, flow_1.wireDirectory)(context(fakeHost(), store), Object.assign(Object.assign({}, base), { start: false }));
+        }));
+        // A `kill -9` or a reboot leaves the session files behind. With another
+        // directory's publisher on the same pinned port, that read as this
+        // directory's session, and `cred dev` refused to start.
+        it("does not take leftover session files and another publisher for its own session", () => __awaiter(void 0, void 0, void 0, function* () {
+            const server = http_1.default.createServer((_request, response) => {
+                response.writeHead(200).end("[]");
+            });
+            yield new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+            const uiPort = server.address().port;
+            try {
+                const wired = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                    directory: workDir,
+                    organization: "acme",
+                    credibleEnvironment: "prod-bars",
+                    open: false,
+                    start: false,
+                });
+                fs_1.default.writeFileSync(wired.configPath, "{}");
+                // A pid nothing runs as.
+                fs_1.default.writeFileSync(pidFile(wired.configPath), "2147483646");
+                (0, chai_1.expect)(yield (0, flow_1.isOwnSessionRunning)(workDir, uiPort)).to.equal(false);
+                fs_1.default.writeFileSync(pidFile(wired.configPath), String(process.pid));
+                (0, chai_1.expect)(yield (0, flow_1.isOwnSessionRunning)(workDir, uiPort)).to.equal(true);
+                // The same live pid, but in a file written before the last boot:
+                // after a reboot that pid can be some other process.
+                const beforeBoot = new Date(Date.now() - os_1.default.uptime() * 1000 - 60000);
+                fs_1.default.utimesSync(pidFile(wired.configPath), beforeBoot, beforeBoot);
+                (0, chai_1.expect)(yield (0, flow_1.isOwnSessionRunning)(workDir, uiPort)).to.equal(false);
+            }
+            finally {
+                server.close();
+            }
+        }));
+        // With the session holding the pinned ports, probing found them busy
+        // and moved `.mcp.json` to a pair nothing was listening on.
+        it("keeps the running session's ports when wiring without starting", () => __awaiter(void 0, void 0, void 0, function* () {
+            const server = http_1.default.createServer((_request, response) => {
+                response.writeHead(200).end("[]");
+            });
+            yield new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+            const uiPort = server.address().port;
+            const mcp = http_1.default.createServer();
+            yield new Promise((resolve) => mcp.listen(uiPort + 1, "127.0.0.1", resolve));
+            const store = loggedInStore();
+            const base = {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                open: false,
+                start: false,
+            };
+            const wired = yield (0, flow_1.wireDirectory)(context(fakeHost(), store), base);
+            (0, folderconfig_1.writeFolderConfig)(workDir, { ports: { uiPort, mcpPort: uiPort + 1 } });
+            fs_1.default.writeFileSync(wired.configPath, "{}");
+            fs_1.default.writeFileSync(pidFile(wired.configPath), String(process.pid));
+            try {
+                const rewired = yield (0, flow_1.wireDirectory)(context(fakeHost(), store), base);
+                (0, chai_1.expect)(rewired.uiPort).to.equal(uiPort);
+                (0, chai_1.expect)(rewired.mcpPort).to.equal(uiPort + 1);
+                (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8")).to.contain(`:${uiPort + 1}/mcp`);
+            }
+            finally {
+                fs_1.default.rmSync(wired.configPath, { force: true });
+                server.close();
+                mcp.close();
+            }
+        }));
+        // Moving the pin and .mcp.json off the pair the live session serves
+        // left the agent's URL pointing at nothing, and the next ownership
+        // check then missed the running server.
+        it("refuses a different --port while this directory's session is running", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const server = http_1.default.createServer((_request, response) => {
+                response.writeHead(200).end("[]");
+            });
+            // A pair `--port` can name, so the same-pair case below is one.
+            const pair = (yield (0, ports_1.suggestFreePair)(workDir));
+            const { uiPort, mcpPort } = pair;
+            yield new Promise((resolve) => server.listen(uiPort, "127.0.0.1", resolve));
+            const store = loggedInStore();
+            const base = {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                open: false,
+                start: false,
+            };
+            const wired = yield (0, flow_1.wireDirectory)(context(fakeHost(), store), base);
+            (0, folderconfig_1.writeFolderConfig)(workDir, { ports: pair });
+            const mcpBefore = fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8");
+            fs_1.default.writeFileSync(wired.configPath, "{}");
+            fs_1.default.writeFileSync(pidFile(wired.configPath), String(process.pid));
+            try {
+                const other = uiPort === 4100 ? 4200 : 4100;
+                for (const attempt of [
+                    () => (0, flow_1.refuseBesideOtherPublisher)(workDir, other),
+                    () => (0, flow_1.wireDirectory)(context(fakeHost(), store), Object.assign(Object.assign({}, base), { port: other })),
+                ]) {
+                    const error = yield attempt().catch((e) => e);
+                    (0, chai_1.expect)(error).to.be.instanceOf(host_1.SetupError);
+                    (0, chai_1.expect)(error.message).to.equal(`This directory's local Publisher is running on ${uiPort}/${mcpPort}, so --port ${other} cannot move it. Fix: stop that session (Ctrl-C in its terminal), then run this again with --port ${other}.`);
+                }
+                (0, chai_1.expect)((_a = (0, folderconfig_1.findFolderConfig)(workDir)) === null || _a === void 0 ? void 0 : _a.config.ports).to.eql(pair);
+                (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8")).to.equal(mcpBefore);
+                // The same pair is not a move, so --no-start beside it still works.
+                const same = yield (0, flow_1.wireDirectory)(context(fakeHost(), store), Object.assign(Object.assign({}, base), { port: uiPort }));
+                (0, chai_1.expect)(same.uiPort).to.equal(uiPort);
+            }
+            finally {
+                fs_1.default.rmSync(wired.configPath, { force: true });
+                server.close();
+            }
+        }));
+        it("re-running is idempotent", () => __awaiter(void 0, void 0, void 0, function* () {
+            const options = {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            };
+            const first = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), options);
+            const mcpAfterFirst = fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8");
+            const claudeAfterFirst = fs_1.default.readFileSync(path_1.default.join(workDir, "CLAUDE.md"), "utf-8");
+            const second = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), options);
+            (0, chai_1.expect)(second.mcpPort).to.equal(first.mcpPort);
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".mcp.json"), "utf-8")).to.equal(mcpAfterFirst);
+            // Notably NOT duplicated: the managed section is replaced in place.
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, "CLAUDE.md"), "utf-8")).to.equal(claudeAfterFirst);
+        }));
+        it("carries the retrieval settings from this directory's publisher.config.json into the config it serves", () => __awaiter(void 0, void 0, void 0, function* () {
+            const retrieval = { llm: { provider: "anthropic", model: "m" } };
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "publisher.config.json"), JSON.stringify({ retrieval }));
+            const host = fakeHost();
+            const wired = yield (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(wired.config.retrieval).to.eql(retrieval);
+            // A file holding only retrieval settings is not a package listing:
+            // the directory is still the package it serves.
+            (0, chai_1.expect)(wired.packageDir).to.equal(workDir);
+            (0, chai_1.expect)(host.logs).to.include("info: Using the retrieval settings in this directory's publisher.config.json.");
+        }));
+        it("serves without a retrieval that is not an object, and says why", () => __awaiter(void 0, void 0, void 0, function* () {
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "publisher.config.json"), JSON.stringify({ retrieval: "anthropic" }));
+            const host = fakeHost();
+            const wired = yield (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(wired.config).to.not.have.property("retrieval");
+            (0, chai_1.expect)(host.logs.some((line) => line.startsWith("warn: Invalid retrieval in " +
+                path_1.default.join(workDir, "publisher.config.json") +
+                ': expected an object, got "anthropic".')), host.logs.join("\n")).to.equal(true);
+        }));
+    });
+    describe("briefing", () => {
+        const facts = {
+            organization: "acme",
+            credibleEnvironment: "prod-bars",
+            localEnvironment: "default",
+            connectionNames: ["warehouse"],
+            publisherUrl: "http://localhost:4000",
+        };
+        // The local publisher serves under its own environment name. An agent
+        // that only saw `prod-bars` passed it to the local tools and got
+        // "Resource not found: prod-bars/...".
+        it("names the environment each server takes", () => {
+            const text = (0, briefing_1.renderBriefing)(facts);
+            (0, chai_1.expect)(text).to.contain("- Credible environment: `prod-bars` (for the `credible` server)");
+            (0, chai_1.expect)(text).to.contain("- Local environment: `default` (for the `malloy` server)");
+        });
+        // In the "I already run a publisher" journey its config, with the key in
+        // it, is still here; "no credentials live on this machine" was false.
+        it("says a local publisher.config.json can hold credentials, only when there is one", () => {
+            // Credentials entered in Credible: none on this machine, said plainly.
+            (0, chai_1.expect)((0, briefing_1.renderBriefing)(facts)).to.not.contain("publisher.config.json");
+            (0, chai_1.expect)((0, briefing_1.renderBriefing)(facts)).to.contain("no warehouse credentials live on this machine");
+            const withLocal = (0, briefing_1.renderBriefing)(Object.assign(Object.assign({}, facts), { localConfigHasConnections: true }));
+            (0, chai_1.expect)(withLocal).to.contain("`publisher.config.json` in this directory is the config your own Publisher");
+            (0, chai_1.expect)(withLocal).to.contain("the credentials do not need to stay in it, if you no longer run that Publisher.");
+            (0, chai_1.expect)(withLocal).to.contain("`cred publish` never uploads it");
+            (0, chai_1.expect)(withLocal).to.not.contain("no warehouse credentials live");
+        });
+        it("says the remote server signs in separately from cred login", () => {
+            (0, chai_1.expect)((0, briefing_1.renderBriefing)(facts)).to.contain("It signs in on its own, separately from `cred login`");
+        });
+        it("states the local-vs-remote rule, which is the easiest thing to get wrong", () => {
+            const text = (0, briefing_1.renderBriefing)(facts);
+            (0, chai_1.expect)(text).to.contain("Iterate locally; evaluate against the published");
+        });
+        it("names the recovery for a refused local tool call", () => {
+            (0, chai_1.expect)((0, briefing_1.renderBriefing)(facts)).to.contain("cred dev");
+        });
+        // An environment with no connections looked like success: the briefing
+        // still told the agent queries go to "your real warehouse".
+        it("says there is nothing to query, and the fix, when there are no connections", () => {
+            const text = (0, briefing_1.renderBriefing)(Object.assign(Object.assign({}, facts), { connectionNames: [] }));
+            (0, chai_1.expect)(text).to.contain("- Connections: none yet, so there is nothing to query — add one with `cred add connection`, then restart `cred dev`");
+            (0, chai_1.expect)(text).to.not.contain("proxies queries to your real warehouse");
+            (0, chai_1.expect)((0, briefing_1.renderBriefing)(facts)).to.contain("proxies queries to your real warehouse");
+        });
+        it("tells a VS Code workspace to use the command, not the CLI", () => {
+            (0, chai_1.expect)((0, briefing_1.renderBriefing)(Object.assign(Object.assign({}, facts), { host: "vscode" }))).to.contain("Credible: Start Publisher");
+        });
+        it("says that git push publishes nothing when the directory pushes somewhere", () => {
+            (0, chai_1.expect)((0, briefing_1.renderBriefing)(Object.assign(Object.assign({}, facts), { gitRemote: "git@github.com:acme/m.git" }))).to.contain("git push");
+        });
+        // This line is the one an agent acts on, and it used to be decided by the
+        // setup prompt's "where did the code come from?" answer. That answer
+        // described how setup obtained the code, not whether the result pushes
+        // anywhere, so the commonest case got it backwards: a user who cloned
+        // their repo by hand and ran setup inside it answered "this directory" and
+        // was told the directory "is not wired to push anywhere". These drive the
+        // real `wireDirectory` against real directories, because the value now has
+        // to be observed from one.
+        it("tells a working copy that git push publishes nothing on its own", () => __awaiter(void 0, void 0, void 0, function* () {
+            const repo = path_1.default.join(workDir, "repo");
+            fs_1.default.mkdirSync(repo, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(repo, "model.malloy"), "// a model\n");
+            git(["init", "--quiet"], repo);
+            git(["remote", "add", "origin", "https://example.invalid/a.git"], repo);
+            const wired = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: repo,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            const briefing = fs_1.default.readFileSync(path_1.default.join(wired.directory, "CLAUDE.md"), "utf-8");
+            (0, chai_1.expect)(briefing).to.contain("git push");
+            (0, chai_1.expect)(briefing).to.not.contain("not wired to push anywhere");
+        }));
+        it("tells a directory with no remote that it is not wired to push anywhere", () => __awaiter(void 0, void 0, void 0, function* () {
+            // A repository is not enough: `git init` with no remote pushes nowhere,
+            // so keying off "is this a git repo" would produce the same wrong
+            // sentence the prompt did.
+            const local = path_1.default.join(workDir, "local");
+            fs_1.default.mkdirSync(local, { recursive: true });
+            git(["init", "--quiet"], local);
+            const wired = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: local,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(wired.directory, "CLAUDE.md"), "utf-8")).to.contain("not wired to push anywhere");
+        }));
+        it("preserves a user's own notes above the managed section", () => {
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "CLAUDE.md"), "# My project\n\nDo not delete this.\n");
+            (0, briefing_1.writeBriefing)(workDir, facts);
+            const text = fs_1.default.readFileSync(path_1.default.join(workDir, "CLAUDE.md"), "utf-8");
+            (0, chai_1.expect)(text).to.contain("Do not delete this.");
+            (0, chai_1.expect)(text).to.contain("## Credible");
+        });
+        it("replaces the managed section rather than appending a second one", () => {
+            (0, briefing_1.writeBriefing)(workDir, facts);
+            (0, briefing_1.writeBriefing)(workDir, Object.assign(Object.assign({}, facts), { credibleEnvironment: "staging-x" }));
+            const text = fs_1.default.readFileSync(path_1.default.join(workDir, "CLAUDE.md"), "utf-8");
+            (0, chai_1.expect)(text.match(/BEGIN Credible managed section/g)).to.have.length(1);
+            (0, chai_1.expect)(text).to.contain("staging-x");
+            (0, chai_1.expect)(text).to.not.contain("prod-bars");
+        });
+    });
+    describe("identity resolution", () => {
+        // The bug this exists to stop: the pin was written and never read, so two
+        // directories pinned to different environments both followed whatever
+        // ~/.cred held. Nothing looked wrong until a query hit the wrong warehouse.
+        it("prefers the directory pin over the global value", () => {
+            const resolved = (0, folderconfig_1.resolveIdentity)({
+                folder: { organization: "acme", environment: "env-B" },
+                global: { organization: "acme", environment: "env-A" },
+            });
+            (0, chai_1.expect)(resolved.environment.value).to.equal("env-B");
+            (0, chai_1.expect)(resolved.environment.from).to.equal("folder");
+        });
+        it("prefers a flag over the pin, so a switch is a switch", () => {
+            const resolved = (0, folderconfig_1.resolveIdentity)({
+                flag: { environment: "staging" },
+                folder: { organization: "acme", environment: "env-B" },
+                global: { organization: "acme", environment: "env-A" },
+            });
+            (0, chai_1.expect)(resolved.environment.value).to.equal("staging");
+            (0, chai_1.expect)(resolved.environment.from).to.equal("flag");
+            // Resolved per field: the flag named only an environment, so the
+            // organization still comes from the pin.
+            (0, chai_1.expect)(resolved.organization.value).to.equal("acme");
+            (0, chai_1.expect)(resolved.organization.from).to.equal("folder");
+        });
+        it("falls back to the global value when nothing else says", () => {
+            const resolved = (0, folderconfig_1.resolveIdentity)({
+                global: { organization: "acme", environment: "env-A" },
+            });
+            (0, chai_1.expect)(resolved.environment.from).to.equal("global");
+        });
+    });
+    describe("keeping the pin out of commits", () => {
+        it("adds .credible/ to .gitignore in a repository", () => __awaiter(void 0, void 0, void 0, function* () {
+            git(["init", "--quiet"], workDir);
+            yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".gitignore"), "utf-8")).to.contain(".credible/");
+        }));
+        it("appends rather than replacing, because the file is the user's", () => __awaiter(void 0, void 0, void 0, function* () {
+            git(["init", "--quiet"], workDir);
+            fs_1.default.writeFileSync(path_1.default.join(workDir, ".gitignore"), "node_modules\n");
+            yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            const text = fs_1.default.readFileSync(path_1.default.join(workDir, ".gitignore"), "utf-8");
+            (0, chai_1.expect)(text).to.contain("node_modules");
+            (0, chai_1.expect)(text).to.contain(".credible/");
+        }));
+        it("writes nothing when git already ignores it", () => __awaiter(void 0, void 0, void 0, function* () {
+            // A rule inherited from a parent .gitignore, .git/info/exclude, or the
+            // user's global excludes counts. Re-adding would be a duplicate rule in
+            // a file we do not own.
+            git(["init", "--quiet"], workDir);
+            fs_1.default.writeFileSync(path_1.default.join(workDir, ".gitignore"), ".credible/\n");
+            yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".gitignore"), "utf-8")).to.equal(".credible/\n");
+        }));
+        it("does not invent a .gitignore outside a repository", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+            });
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".gitignore"))).to.equal(false);
+        }));
+    });
+    describe("folder config", () => {
+        it("walks up from a subdirectory, like .nvmrc", () => {
+            var _a;
+            (0, folderconfig_1.writeFolderConfig)(workDir, { organization: "acme" });
+            const nested = path_1.default.join(workDir, "a", "b");
+            fs_1.default.mkdirSync(nested, { recursive: true });
+            (0, chai_1.expect)((_a = (0, folderconfig_1.findFolderConfig)(nested)) === null || _a === void 0 ? void 0 : _a.root).to.equal(workDir);
+        });
+        it("merges rather than replacing, so a pin keeps its other fields", () => {
+            (0, folderconfig_1.writeFolderConfig)(workDir, { organization: "acme" });
+            (0, folderconfig_1.writeFolderConfig)(workDir, { ports: { uiPort: 5000, mcpPort: 5040 } });
+            const config = (0, folderconfig_1.findFolderConfig)(workDir).config;
+            (0, chai_1.expect)(config.organization).to.equal("acme");
+            (0, chai_1.expect)(config.ports).to.eql({ uiPort: 5000, mcpPort: 5040 });
+        });
+        it("ignores an unreadable pin instead of failing the command", () => {
+            fs_1.default.mkdirSync(path_1.default.join(workDir, ".credible"), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(workDir, ".credible", "config.json"), "{ not json");
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir)).to.equal(undefined);
+        });
+        describe("resolveDeployment precedence", () => {
+            it("puts the flag above the global default", () => {
+                (0, chai_1.expect)((0, folderconfig_1.resolveDeployment)({
+                    cwd: workDir,
+                    globalDefault: "production",
+                    flag: "staging",
+                })).to.eql({ deployment: "staging", from: "flag" });
+            });
+            it("puts the flag above the folder pin", () => {
+                (0, folderconfig_1.writeFolderConfig)(workDir, { deployment: "dev" });
+                (0, chai_1.expect)((0, folderconfig_1.resolveDeployment)({
+                    cwd: workDir,
+                    globalDefault: "production",
+                    flag: "staging",
+                })).to.eql({ deployment: "staging", from: "flag" });
+            });
+            it("puts the folder pin above the global default", () => {
+                (0, folderconfig_1.writeFolderConfig)(workDir, { deployment: "staging" });
+                (0, chai_1.expect)((0, folderconfig_1.resolveDeployment)({ cwd: workDir, globalDefault: "production" })).to.eql({ deployment: "staging", from: "folder" });
+            });
+            it("falls back to the global default with no pin", () => {
+                (0, chai_1.expect)((0, folderconfig_1.resolveDeployment)({ cwd: workDir, globalDefault: "production" })).to.eql({ deployment: "production", from: "global" });
+            });
+            // Earlier builds wrote no `deployment` for production. Following the
+            // global value there paired a production organization with staging's
+            // credentials once `~/.cred` moved.
+            it("reads an initialized pin with no deployment as production", () => {
+                (0, folderconfig_1.writeFolderConfig)(workDir, {
+                    organization: "acme",
+                    environment: "prod-bars",
+                });
+                (0, chai_1.expect)((0, folderconfig_1.resolveDeployment)({ cwd: workDir, globalDefault: "staging" })).to.eql({ deployment: "production", from: "folder" });
+            });
+            it("still falls back to the global default for a deployment it does not know", () => {
+                fs_1.default.mkdirSync(path_1.default.join(workDir, ".credible"), { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(workDir, ".credible", "config.json"), JSON.stringify({ deployment: "mars", organization: "acme" }));
+                (0, chai_1.expect)((0, folderconfig_1.resolveDeployment)({ cwd: workDir, globalDefault: "staging" })).to.eql({ deployment: "staging", from: "global" });
+            });
+            it("does not let an invalid folder pin drive the deployment", () => {
+                fs_1.default.mkdirSync(path_1.default.join(workDir, ".credible"), { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(workDir, ".credible", "config.json"), JSON.stringify({ deployment: "nonsense" }));
+                (0, chai_1.expect)((0, folderconfig_1.resolveDeployment)({ cwd: workDir, globalDefault: "production" })).to.eql({ deployment: "production", from: "global" });
+            });
+        });
+        describe("reading a config written by another version", () => {
+            it("keeps a key it does not understand when writing", () => {
+                const filePath = path_1.default.join(workDir, ".credible", "config.json");
+                fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+                fs_1.default.writeFileSync(filePath, JSON.stringify({ somethingNewer: { a: 1 } }));
+                (0, folderconfig_1.writeFolderConfig)(workDir, { organization: "acme" });
+                const onDisk = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+                (0, chai_1.expect)(onDisk.organization).to.equal("acme");
+                (0, chai_1.expect)(onDisk.somethingNewer).to.eql({ a: 1 });
+            });
+            it("drops a ports value of the wrong shape rather than passing it on", () => {
+                const filePath = path_1.default.join(workDir, ".credible", "config.json");
+                fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+                fs_1.default.writeFileSync(filePath, JSON.stringify({ ports: "4000/4040", organization: "acme" }));
+                const found = (0, folderconfig_1.findFolderConfig)(workDir);
+                (0, chai_1.expect)(found === null || found === void 0 ? void 0 : found.config.ports).to.equal(undefined);
+                // The fields that ARE valid still come through.
+                (0, chai_1.expect)(found === null || found === void 0 ? void 0 : found.config.organization).to.equal("acme");
+            });
+            it("drops a non-integer port pair", () => {
+                var _a;
+                const filePath = path_1.default.join(workDir, ".credible", "config.json");
+                fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+                fs_1.default.writeFileSync(filePath, JSON.stringify({ ports: { uiPort: 4000, mcpPort: "4040" } }));
+                (0, chai_1.expect)((_a = (0, folderconfig_1.findFolderConfig)(workDir)) === null || _a === void 0 ? void 0 : _a.config.ports).to.equal(undefined);
+            });
+        });
+    });
+    describe("telling an already-running agent to restart", () => {
+        const wire = (host) => (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+            directory: workDir,
+            organization: "acme",
+            credibleEnvironment: "prod-bars",
+            start: false,
+            open: false,
+        });
+        it("says so when .mcp.json changed", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = fakeHost();
+            yield wire(host);
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("will not see the new MCP servers until it restarts");
+        }));
+        it("stays quiet when a later run rewrote nothing", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield wire(fakeHost());
+            const host = fakeHost();
+            yield wire(host);
+            (0, chai_1.expect)(host.logs.join("\n")).to.not.contain("until it restarts");
+        }));
+    });
+    describe("a Publisher server directory (create-malloy-package layout)", () => {
+        function scaffold(...packages) {
+            for (const name of packages) {
+                fs_1.default.mkdirSync(path_1.default.join(workDir, name), { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(workDir, name, "publisher.json"), JSON.stringify({ name }));
+                fs_1.default.writeFileSync(path_1.default.join(workDir, name, `${name}.malloy`), "");
+            }
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "publisher.config.json"), JSON.stringify({
+                environments: [
+                    {
+                        name: "default",
+                        packages: packages.map((name) => ({
+                            name,
+                            location: `./${name}`,
+                        })),
+                        connections: [],
+                    },
+                ],
+            }));
+        }
+        const wire = (host) => (0, flow_1.wireDirectory)(context(host, loggedInStore()), {
+            directory: workDir,
+            organization: "acme",
+            credibleEnvironment: "prod-bars",
+            start: false,
+            open: false,
+        });
+        it("serves the package the config lists, and keeps the workspace files at the top", () => __awaiter(void 0, void 0, void 0, function* () {
+            scaffold("shop");
+            const host = fakeHost();
+            const wired = yield wire(host);
+            (0, chai_1.expect)(wired.directory).to.equal(workDir);
+            (0, chai_1.expect)(wired.packageDir).to.equal(path_1.default.join(workDir, "shop"));
+            (0, chai_1.expect)(wired.config.environments[0].packages[0]).to.eql({
+                name: "shop",
+                location: path_1.default.join(workDir, "shop"),
+            });
+            // No second manifest at the top: the top is the workspace, not a package.
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, "publisher.json"))).to.equal(false);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".mcp.json"))).to.equal(true);
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, "CLAUDE.md"), "utf-8")).to.contain("`shop/`");
+        }));
+        it("warns once when the package's own manifest has no version, and leaves it alone", () => __awaiter(void 0, void 0, void 0, function* () {
+            scaffold("shop"); // the scaffolder writes { "name": "shop" } only
+            const host = fakeHost();
+            yield wire(host);
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain('shop/publisher.json has no "version"');
+            (0, chai_1.expect)(JSON.parse(fs_1.default.readFileSync(path_1.default.join(workDir, "shop/publisher.json"), "utf-8"))).to.eql({ name: "shop" });
+        }));
+        it("asks which package when the config lists several, naming --package as the flag", () => __awaiter(void 0, void 0, void 0, function* () {
+            scaffold("shop", "warehouse");
+            const hints = [];
+            const host = Object.assign(Object.assign({}, fakeHost()), { select(_message, choices, hint) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        hints.push(hint);
+                        return choices[1].value;
+                    });
+                } });
+            const wired = yield wire(host);
+            (0, chai_1.expect)(wired.packageDir).to.equal(path_1.default.join(workDir, "warehouse"));
+            (0, chai_1.expect)(hints).to.eql([
+                { flag: "--package <dir>", options: ["shop", "warehouse"] },
+            ]);
+        }));
+        // Asked after login and the environment, an agent that stopped at the
+        // exit 2 had already written ~/.cred and maybe created an environment.
+        it("refuses the package question up front without a terminal, and a --package it does not list", () => {
+            scaffold("shop", "warehouse");
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, {}, false))
+                .to.throw(host_1.NeedsInputError)
+                .with.property("message")
+                .that.contains("Pass --package <dir>. Options: shop, warehouse.");
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, { package: "shop" }, false)).not.to.throw();
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, { package: "shp" }, true))
+                .to.throw(host_1.SetupError)
+                .with.property("message")
+                .that.contains("--package shp is not a package");
+        });
+        // The non-interactive answer to that question has to do what the picker
+        // does: serve the subdirectory and keep the workspace files at the top.
+        // `-d` used to be the named answer, and it moves the whole workspace.
+        it("--package serves the named package, keeps the workspace at the top, and is remembered", () => __awaiter(void 0, void 0, void 0, function* () {
+            scaffold("shop", "warehouse");
+            const wired = yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+                package: "warehouse",
+            });
+            (0, chai_1.expect)(wired.directory).to.equal(workDir);
+            (0, chai_1.expect)(wired.packageDir).to.equal(path_1.default.join(workDir, "warehouse"));
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".mcp.json"))).to.equal(true);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, "warehouse", ".mcp.json"))).to.equal(false);
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.package).to.equal("warehouse");
+            // `cred dev` on a later day: no flag, no question.
+            const later = fakeHost();
+            const rewired = yield wire(later);
+            (0, chai_1.expect)(rewired.packageDir).to.equal(path_1.default.join(workDir, "warehouse"));
+            (0, chai_1.expect)(later.asked.some((q) => q.includes("several packages"))).to.equal(false);
+        }));
+        it("refuses a --package the config does not list, naming the ones it does", () => __awaiter(void 0, void 0, void 0, function* () {
+            scaffold("shop", "warehouse");
+            try {
+                yield (0, flow_1.wireDirectory)(context(fakeHost(), loggedInStore()), {
+                    directory: workDir,
+                    organization: "acme",
+                    credibleEnvironment: "prod-bars",
+                    start: false,
+                    open: false,
+                    package: "shp",
+                });
+                chai_1.expect.fail("expected a refusal");
+            }
+            catch (error) {
+                (0, chai_1.expect)(error).to.be.instanceOf(host_1.SetupError);
+                (0, chai_1.expect)(error.message).to.equal("--package shp is not a package this directory's publisher.config.json lists. Fix: pass one of: shop, warehouse.");
+            }
+        }));
+        it("a directory with its own manifest is the package, whatever the config says", () => __awaiter(void 0, void 0, void 0, function* () {
+            scaffold("shop");
+            fs_1.default.writeFileSync(path_1.default.join(workDir, "publisher.json"), JSON.stringify({ name: "top", version: "1.0.0" }));
+            const wired = yield wire(fakeHost());
+            (0, chai_1.expect)(wired.packageDir).to.equal(workDir);
+        }));
+    });
+    describe("the skills step", () => {
+        const ASK_SKILLS = "Found 1 skill already in .claude/skills/ that cred did not install (malloy-getting-started). What should happen to them?";
+        const skills = {
+            manifest: "modeling-ide",
+            version: "v1",
+            trigger_hint: "When modeling",
+            auto_discovered: [
+                {
+                    name: "malloy-modeling",
+                    files: [{ relative_filepath: "SKILL.md", file_contents: "m" }],
+                },
+            ],
+            supporting: [],
+        };
+        const wire = (host, fetchSkills) => (0, flow_1.wireDirectory)(Object.assign(Object.assign({}, context(host, loggedInStore())), { fetchSkills }), {
+            directory: workDir,
+            organization: "acme",
+            credibleEnvironment: "prod-bars",
+            start: false,
+            open: false,
+        });
+        it("installs the skills, records them in the pin, and tells the briefing", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = fakeHost();
+            yield wire(host, () => __awaiter(void 0, void 0, void 0, function* () { return skills; }));
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-modeling/SKILL.md"))).to.equal(true);
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.skills).to.deep.include({
+                manifest: "modeling-ide",
+                version: "v1",
+            });
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, "CLAUDE.md"), "utf-8")).to.contain(".claude/skills/");
+        }));
+        it("records the malloy skills version in the pin, and reads it back", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield wire(fakeHost(), () => __awaiter(void 0, void 0, void 0, function* () {
+                return (Object.assign(Object.assign({}, skills), { publisher_skills_version: "0.1.30" }));
+            }));
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.skills).to.deep.include({
+                version: "v1",
+                publisherVersion: "0.1.30",
+            });
+        }));
+        it("adds the skill directories to .gitignore in a repository", () => __awaiter(void 0, void 0, void 0, function* () {
+            git(["init", "-q"], workDir);
+            yield wire(fakeHost(), () => __awaiter(void 0, void 0, void 0, function* () { return skills; }));
+            const text = fs_1.default.readFileSync(path_1.default.join(workDir, ".gitignore"), "utf-8");
+            (0, chai_1.expect)(text).to.contain(".claude/skills/malloy-modeling/");
+            (0, chai_1.expect)(text).to.contain(".agents/skills/malloy-modeling/");
+            (0, chai_1.expect)(text).to.contain(".claude/rules/credible-modeling.md");
+        }));
+        it("skips quietly when the server has no skills endpoint", () => __awaiter(void 0, void 0, void 0, function* () {
+            const host = fakeHost();
+            yield wire(host, () => __awaiter(void 0, void 0, void 0, function* () { return undefined; }));
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude"))).to.equal(false);
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.skills).to.equal(undefined);
+            (0, chai_1.expect)(host.logs.join("\n")).to.not.contain("skills");
+        }));
+        it("warns and continues when the fetch fails, keeping the previous record", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            yield wire(fakeHost(), () => __awaiter(void 0, void 0, void 0, function* () { return skills; }));
+            const host = fakeHost();
+            yield wire(host, () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error("code-assist is down");
+            }));
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("code-assist is down");
+            // Setup still completed, and the earlier install is still recorded.
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".mcp.json"))).to.equal(true);
+            (0, chai_1.expect)((_a = (0, folderconfig_1.findFolderConfig)(workDir).config.skills) === null || _a === void 0 ? void 0 : _a.version).to.equal("v1");
+        }));
+        /** The scaffolder's leftovers: a skill we did not install. */
+        function plantForeign(name = "malloy-getting-started") {
+            const dir = path_1.default.join(workDir, ".claude/skills", name);
+            fs_1.default.mkdirSync(dir, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(dir, "SKILL.md"), "theirs");
+        }
+        const wireWith = (host, skillsPolicy) => (0, flow_1.wireDirectory)(Object.assign(Object.assign({}, context(host, loggedInStore())), { fetchSkills: () => __awaiter(void 0, void 0, void 0, function* () { return skills; }) }), {
+            directory: workDir,
+            organization: "acme",
+            credibleEnvironment: "prod-bars",
+            start: false,
+            open: false,
+            skills: skillsPolicy,
+        });
+        it("asks what to do with skills it did not install, naming the flag", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            const host = fakeHost({ [ASK_SKILLS]: "keep" });
+            yield wireWith(host);
+            const question = host.asked.find((q) => q.includes("did not install"));
+            (0, chai_1.expect)(question).to.contain("malloy-getting-started");
+        }));
+        it("replace moves them aside, not away, and installs ours", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            const host = fakeHost();
+            yield wireWith(host, "replace");
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-getting-started"))).to.equal(false);
+            const moved = fs_1.default.readdirSync(path_1.default.join(workDir, ".credible/replaced-skills"));
+            (0, chai_1.expect)(moved).to.have.length(1);
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".credible/replaced-skills", moved[0], ".claude/skills/malloy-getting-started/SKILL.md"), "utf-8")).to.equal("theirs");
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain(`Moved 1 skill that cred did not install to .credible/replaced-skills/${moved[0]}/`);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-modeling/SKILL.md"))).to.equal(true);
+        }));
+        it("keep leaves them and installs ours beside them", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            yield wireWith(fakeHost(), "keep");
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".claude/skills/malloy-getting-started/SKILL.md"), "utf-8")).to.equal("theirs");
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-modeling/SKILL.md"))).to.equal(true);
+        }));
+        it("keep moves aside one with the same name as ours, rather than overwriting it", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            plantForeign("malloy-modeling");
+            const host = fakeHost();
+            yield wireWith(host, "keep");
+            // The other one stays where it was.
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".claude/skills/malloy-getting-started/SKILL.md"), "utf-8")).to.equal("theirs");
+            // Ours is installed under the shared name.
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".claude/skills/malloy-modeling/SKILL.md"), "utf-8")).to.equal("m");
+            // And theirs is kept, aside, not overwritten.
+            const moved = fs_1.default.readdirSync(path_1.default.join(workDir, ".credible/replaced-skills"));
+            (0, chai_1.expect)(moved).to.have.length(1);
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".credible/replaced-skills", moved[0], ".claude/skills/malloy-modeling/SKILL.md"), "utf-8")).to.equal("theirs");
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain(`Kept your existing skills. malloy-modeling had the same name as Credible's, so yours was moved to .credible/replaced-skills/${moved[0]}/.`);
+        }));
+        it("keep moves aside one with the same name as a supporting skill of ours", () => __awaiter(void 0, void 0, void 0, function* () {
+            // writeSkillFiles writes the supporting skills too, so they collide the same way.
+            plantForeign("malloy-queries");
+            const host = fakeHost();
+            yield (0, flow_1.wireDirectory)(Object.assign(Object.assign({}, context(host, loggedInStore())), { fetchSkills: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return (Object.assign(Object.assign({}, skills), { supporting: [
+                            {
+                                name: "malloy-queries",
+                                files: [
+                                    {
+                                        relative_filepath: "SKILL.md",
+                                        file_contents: "q",
+                                    },
+                                ],
+                            },
+                        ] }));
+                }) }), {
+                directory: workDir,
+                organization: "acme",
+                credibleEnvironment: "prod-bars",
+                start: false,
+                open: false,
+                skills: "keep",
+            });
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".claude/skills/malloy-queries/SKILL.md"), "utf-8")).to.equal("q");
+            const moved = fs_1.default.readdirSync(path_1.default.join(workDir, ".credible/replaced-skills"));
+            (0, chai_1.expect)(moved).to.have.length(1);
+            (0, chai_1.expect)(fs_1.default.readFileSync(path_1.default.join(workDir, ".credible/replaced-skills", moved[0], ".claude/skills/malloy-queries/SKILL.md"), "utf-8")).to.equal("theirs");
+            (0, chai_1.expect)(host.logs.join("\n")).to.contain("Kept your existing skills. malloy-queries had the same name as Credible's, so yours was moved to");
+        }));
+        it("none installs nothing and touches nothing", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            yield wireWith(fakeHost(), "none");
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-modeling"))).to.equal(false);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-getting-started"))).to.equal(true);
+        }));
+        // Recorded as a decision in the pin, apart from the installed-files
+        // record. Without it the next `cred dev` asked again (exit 2 without a
+        // terminal) or, with no foreign skills, installed the declined set.
+        it("remembers --skills none, so a later run neither asks nor installs", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            yield wireWith(fakeHost(), "none");
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.skillsPolicy).to.equal("none");
+            const host = fakeHost();
+            yield wireWith(host);
+            (0, chai_1.expect)(host.asked.some((q) => q.includes("did not install"))).to.equal(false);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-modeling"))).to.equal(false);
+            (0, chai_1.expect)(() => (0, flow_1.refuseUnanswerable)(workDir, {}, false)).not.to.throw();
+        }));
+        it("remembers the picker's 'Do not install skills' the same way", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            yield wireWith(fakeHost({ [ASK_SKILLS]: "none" }));
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.skillsPolicy).to.equal("none");
+        }));
+        it("installs, and forgets the refusal, when a later run passes keep", () => __awaiter(void 0, void 0, void 0, function* () {
+            plantForeign();
+            yield wireWith(fakeHost(), "none");
+            yield wireWith(fakeHost(), "keep");
+            (0, chai_1.expect)((0, folderconfig_1.findFolderConfig)(workDir).config.skillsPolicy).to.equal(undefined);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/malloy-modeling/SKILL.md"))).to.equal(true);
+        }));
+        it("does not ask on a later run — the user's own skills are not ours to question", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield wireWith(fakeHost());
+            plantForeign("my-own");
+            const host = fakeHost();
+            yield wireWith(host);
+            (0, chai_1.expect)(host.asked.some((q) => q.includes("did not install"))).to.equal(false);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude/skills/my-own/SKILL.md"))).to.equal(true);
+        }));
+        it("does nothing when the front door cannot fetch skills", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield wire(fakeHost(), undefined);
+            (0, chai_1.expect)(fs_1.default.existsSync(path_1.default.join(workDir, ".claude"))).to.equal(false);
+        }));
+    });
+});
+//# sourceMappingURL=flow.spec.js.map