@join-pantheon/cli 0.33.1 → 0.33.2

package/dist/client.js

@@ -7,8 +7,8 @@ import { repoName } from "./repo-route.js";
 import { signChallenge, signBytes, actPayload, goalPayload, newActId, newActNonce, canonicalJson } from "./identity.js";
 import { expectsSigs, joinedSigning, loadPins, markMemberSigns, markSigs, memberSigns, observeMembers, pinFor, pinScope, teamPinId, updatePins } from "./pins.js";
 export { joinedSigning } from "./pins.js";
-import { trusted, verifyAct, verifyGoal } from "./verify-act.js";
-import { newId } from "./protocol.js";
+import { trusted, verifyAct, verifyGoal, vouchedMove } from "./verify-act.js";
+import { newId, UPKEEP_AGENT } from "./protocol.js";
 import { VERSION } from "./version.js";
 import { describeNetError, explainNetError, noteRelayAnswered, settleSystemFallback, systemFallbackPending, trySystemFallback, wsOptions } from "./network.js";
 export class PantheonClient {
@@ -71,7 +71,9 @@ export class PantheonClient {
         this.enroll = opts?.enroll ?? null;
         this.session = opts?.session ?? newId("s");
         this.role = opts?.role ?? "interactive";
+        this.upkeep = opts?.upkeep === true && this.role === "cli";
     }
+    upkeep;
     keepRepos() {
         try {
             rememberTeamRepos({ spaceId: this.cfg.spaceId ?? this.spaceId, space: this.cfg.space, relay: this.cfg.relay }, this.repos);
@@ -227,7 +229,8 @@ export class PantheonClient {
                             session: this.session,
                             role: this.role,
                             display: this.cfg.display ?? this.cfg.member,
-                            agent: this.cfg.agent ?? "unknown",
+                            agent: this.upkeep ? UPKEEP_AGENT : (this.cfg.agent ?? "unknown"),
+                            ...(this.upkeep ? { upkeep: true } : {}),
                             pkg: VERSION,
                             ...(this.seq > 0 ? { from_seq: this.seq } : {}),
                             ...(this.cfg.repo ? { repo: this.cfg.repo, ...(this.cfg.repoOrigin ? { repo_origin: repoName(this.cfg.repoOrigin) } : {}) } : {}),
@@ -608,7 +611,8 @@ export class PantheonClient {
                 if (p.corrupt)
                     return false;
                 const before = JSON.stringify(p);
-                changes = observeMembers(p, team, this.members, { member: this.cfg.member, publicKey: this.cfg.publicKey });
+                const teams = [this.cfg.spaceId, this.spaceId, this.cfg.space];
+                changes = observeMembers(p, team, this.members, { member: this.cfg.member, publicKey: this.cfg.publicKey }, Date.now(), (m, fp, pins) => vouchedMove(m, fp, teams, (who) => pinFor(pins, team, who), (who) => !!this.members.find((x) => x.member === who)?.admitted));
                 if (this.features.includes("act-sig"))
                     markSigs(p, team);
                 return JSON.stringify(p) !== before;

package/dist/config.js

@@ -631,18 +631,32 @@ export async function resolveInviteCode(code, relays, fetchImpl = fetch) {
     const token = code.trim().replace(/^['"`]|['"`]$/g, "");
     const tried = [...new Set(relays.map((r) => r.replace(/\/+$/, "")).filter(Boolean))];
     let answered = false;
+    let nonJsonFrom;
+    const json = async (res, relay) => {
+        const text = await res.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            nonJsonFrom ??= relay;
+            return null;
+        }
+    };
     for (const relay of tried) {
         const http = relay.replace(/^ws/, "http");
         try {
             const res = await fetchImpl(`${http}/join?token=${encodeURIComponent(token)}`, { signal: AbortSignal.timeout(6_000) });
             if (res.status === 404) {
-                answered = true;
+                const j = await json(res, relay);
+                answered = (!!j && typeof j === "object") || answered;
                 continue;
             }
+            if (res.status >= 502 && res.status <= 504)
+                continue;
+            const body = await json(res, relay);
             if (!res.ok)
                 continue;
-            const body = (await res.json());
-            if (typeof body.team === "string" && body.team)
+            if (typeof body?.team === "string" && body.team)
                 return { relay, space: body.team, token };
         }
         catch { }
@@ -651,6 +665,6 @@ export async function resolveInviteCode(code, relays, fetchImpl = fetch) {
     if (answered) {
         throw new Error(`INVITE_CODE_UNKNOWN: that is an invite code, but no open invite on ${hosts} matches it — it may have been used already or expired (they last 24 hours).\n  Ask your teammate for a fresh one: pantheon invite`);
     }
-    throw new Error(`INVITE_CODE_UNREACHABLE: that looks like an invite code, but ${hosts} could not be asked which team it opens.\n  Paste the whole invite line instead:  pantheon join https://www.joinpantheon.network/join/<team>#${token}`);
+    throw Object.assign(new Error(`INVITE_CODE_UNREACHABLE: that looks like an invite code, but ${hosts} could not be asked which team it opens.\n  Paste the whole invite line instead:  pantheon join https://www.joinpantheon.network/join/<team>#${token}`), nonJsonFrom ? { nonJsonFrom } : {});
 }
 //# sourceMappingURL=config.js.map

package/dist/continued.js

@@ -25,6 +25,11 @@ export function loadContinued(space, home) {
 export function handledIn(h) {
     return [...new Set(Object.values(readAll(h)).flatMap((l) => (Array.isArray(l) ? l : [])).filter((x) => typeof x === "string" && x.startsWith("handled:")))];
 }
+export const wakeAlertedKey = (team, member, askId) => `wake-alerted:${team}|${member}|${askId}`;
+export function wakeAlerted(team, member, askId, home) {
+    const k = wakeAlertedKey(team, member, askId);
+    return Object.values(readAll(home)).some((l) => Array.isArray(l) && l.includes(k));
+}
 export function markContinued(space, id, home) {
     try {
         const p = continuedPath(home);

package/dist/desktop-app.js

@@ -0,0 +1,103 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, win32 } from "node:path";
+export const CLAUDE_BUNDLE = "com.anthropic.claudefordesktop";
+export const CLAUDE_APP_ID_ASSUMED = "Claude";
+const AUMID_RE = /^[A-Za-z0-9.-]{1,64}_[a-z0-9]{13}![A-Za-z0-9._-]{1,64}$/;
+export const AUMID_SCRIPT = "$p = Get-AppxPackage -ErrorAction SilentlyContinue | Where-Object { $_.PackageFamilyName -like 'Claude_*' } | Select-Object -First 1; " +
+    "if ($p) { $a = @((Get-AppxPackageManifest $p).Package.Applications.Application)[0]; if ($a) { \"$($p.PackageFamilyName)!$($a.Id)\" } }";
+function runPowershell(script) {
+    try {
+        const r = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { encoding: "utf8", timeout: 8_000, windowsHide: true });
+        return r.status === 0 ? (r.stdout ?? "").trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function findClaudeApp(d = {}) {
+    const os = d.os ?? process.platform;
+    const exists = d.exists ?? existsSync;
+    const home = d.home ?? homedir();
+    if (os === "darwin") {
+        return ["/Applications/Claude.app", join(home, "Applications", "Claude.app")].some((p) => exists(p)) ? { how: "bundle", bundle: CLAUDE_BUNDLE } : null;
+    }
+    if (os !== "win32")
+        return null;
+    const env = d.env ?? process.env;
+    const local = env.LOCALAPPDATA;
+    if (!local)
+        return null;
+    let families = [];
+    try {
+        families = (d.list ?? ((p) => readdirSync(p)))(win32.join(local, "Packages")).filter((f) => /^Claude_[a-z0-9]{13}$/.test(f));
+    }
+    catch {
+        families = [];
+    }
+    if (families.length) {
+        const asked = (d.powershell ?? runPowershell)(AUMID_SCRIPT)?.split(/\r?\n/).map((l) => l.trim()).find((l) => AUMID_RE.test(l));
+        if (asked)
+            return { how: "appsfolder", aumid: asked, assumed: false };
+        const guess = `${families[0]}!${CLAUDE_APP_ID_ASSUMED}`;
+        if (AUMID_RE.test(guess))
+            return { how: "appsfolder", aumid: guess, assumed: true };
+    }
+    const exe = win32.join(local, "AnthropicClaude", "claude.exe");
+    return exists(exe) ? { how: "exe", path: exe } : null;
+}
+export function openAppCommand(app) {
+    if (app.how === "appsfolder")
+        return { cmd: "explorer.exe", args: [`shell:AppsFolder\\${app.aumid}`] };
+    if (app.how === "exe")
+        return { cmd: app.path, args: [] };
+    return { cmd: "open", args: ["-b", app.bundle] };
+}
+export function clipboardCommand(os = process.platform, find = () => true) {
+    if (os === "darwin")
+        return { cmd: "pbcopy", args: [] };
+    if (os === "win32")
+        return { cmd: "powershell.exe", args: ["-NoProfile", "-NonInteractive", "-Command", "[Console]::InputEncoding = [Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())"] };
+    if (find("wl-copy"))
+        return { cmd: "wl-copy", args: [] };
+    if (find("xclip"))
+        return { cmd: "xclip", args: ["-selection", "clipboard"] };
+    return null;
+}
+function copyReal(text) {
+    const c = clipboardCommand();
+    if (!c)
+        return false;
+    try {
+        return spawnSync(c.cmd, c.args, { input: text, timeout: 8_000, windowsHide: true }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function startReal(cmd, args) {
+    try {
+        const ch = spawn(cmd, args, { detached: true, stdio: "ignore", windowsHide: false });
+        ch.on("error", () => { });
+        ch.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function explainInClaudeApp(prompt, app, d = {}) {
+    const copied = (d.copy ?? copyReal)(prompt);
+    const o = openAppCommand(app);
+    if (!(d.start ?? startReal)(o.cmd, o.args))
+        return { ok: false, says: "the Claude app could not be opened" };
+    const paste = (d.os ?? process.platform) === "darwin" ? "Cmd+V" : "Ctrl+V";
+    return {
+        ok: true,
+        says: copied
+            ? `opened the Claude app — the question is copied: paste it into a new chat (${paste})`
+            : "opened the Claude app — the question could not be copied here; it is printed below to copy",
+    };
+}
+//# sourceMappingURL=desktop-app.js.map

package/dist/doctor.js

@@ -18,10 +18,10 @@ import { PantheonClient } from "./client.js";
 import { load, resolveFor, loadAll, CONFIG_PATH } from "./config.js";
 import { fingerprint, signChallenge, verifyChallenge } from "./identity.js";
 import { approvalSummary, chosenApproval, copilotMcpConfigFile, kiroMcpConfigFile, onPath } from "./install.js";
-import { hookState, readIntent, agentHookStates } from "./notify.js";
+import { hookState, readIntent, agentHookStates, repairNote } from "./notify.js";
 import { loadPersonas } from "./persona.js";
 import { workerProc, menubarProc, notifierProc } from "./machine.js";
-import { agentById, chooseAgent, describeChoice, unattendedRefusal, skippedSummary, SANDBOXED_FOR_UNATTENDED } from "./agents.js";
+import { agentById, chooseAgent, describeChoice, detectAvailable, folderReaderLine, unattendedRefusal, skippedSummary, SANDBOXED_FOR_UNATTENDED } from "./agents.js";
 import { loginShellLookup, npmSpawn, onPathNamed, which, whichWindows } from "./which.js";
 import { VERSION } from "./version.js";
 import { realSys, serviceInstalled, servicesUnavailable } from "./service.js";
@@ -30,7 +30,7 @@ import { hasPrebuilt } from "./helpers-build.js";
 import { traySourcePath, TRAY_PREBUILT } from "./tray.js";
 import { hudSourcePath, HUD_PREBUILT } from "./notifier.js";
 import { hostEnv, platformName } from "./host-env.js";
-import { currentPlan, explainNetError, proxyEnvFor, routeFor, redactProxy } from "./network.js";
+import { checkRelayCertificate, currentPlan, explainNetError, interceptionExplanation, proxyEnvFor, relayJson, routeFor, redactProxy, worthCertificateCheck } from "./network.js";
 import { refusalOf } from "./refusal.js";
 const HOSTED_RELAY = "relay.joinpantheon.network";
 const git = (args, cwd) => {
@@ -329,9 +329,11 @@ export async function doctor(projectDir) {
             else if (fellBack)
                 add("warn", "worker agent", line, prof.agent.primary_surface === "kiro"
                     ? `you chose Kiro at setup; Kiro answers in your live sessions, and runs while you're away use ${choice.backend.label}`
-                    : surface && !SANDBOXED_FOR_UNATTENDED.has(surface.id) && !unsandboxedOk
-                        ? `you chose ${surface.label} at setup; runs while you're away use ${choice.backend.label} in its sandbox (to have ${surface.label} answer them: pantheon policy grant unsandboxed-runs)`
-                        : `you chose ${prof.agent.primary_surface} at setup; runs use ${choice.backend.label} until it is signed in again`, shareLine);
+                    : surface && !detectAvailable().some((a) => a.backend.id === surface.id)
+                        ? `you use ${surface.label}${surface.id === "claude-code" ? " (the Claude app puts no claude CLI on PATH)" : ""}, and its CLI is not installed here, so runs while you're away use ${choice.backend.label}`
+                        : surface && !SANDBOXED_FOR_UNATTENDED.has(surface.id) && !unsandboxedOk
+                            ? `you chose ${surface.label} at setup; runs while you're away use ${choice.backend.label} in its sandbox (to have ${surface.label} answer them: pantheon policy grant unsandboxed-runs)`
+                            : `you chose ${prof.agent.primary_surface} at setup; runs use ${choice.backend.label} until it is signed in again`, shareLine);
             else
                 add("pass", "worker agent", line, undefined, shareLine);
         }
@@ -395,9 +397,32 @@ export async function doctor(projectDir) {
     }
     const health = `${cfg.relay.replace(/^ws/, "http")}/health`;
     const where = hosted ? "hosted" : "self-hosted";
+    const certAsk = url.protocol === "wss:" ? checkRelayCertificate(cfg.relay).catch(() => null) : Promise.resolve(null);
+    let cert = null;
+    let certSaid = false;
+    const certRow = async (reached) => {
+        cert = await certAsk;
+        if (!cert || certSaid)
+            return cert;
+        certSaid = true;
+        if (cert.publicCa === true)
+            add("pass", "certificate", `issued by ${cert.issuer}, a public certificate authority`, undefined, "from a public CA");
+        else if (cert.publicCa === false && reached) {
+            add("pass", "certificate", `re-signed by ${cert.issuer}, not a public certificate authority: an antivirus or company proxy inspects this connection, and the relay still answers through it`, undefined, "re-signed by an inspecting proxy; relay answers");
+        }
+        else if (cert.publicCa === false) {
+            const x = interceptionExplanation(cert);
+            add("fail", "certificate", x.why, x.fix, x.share);
+        }
+        else {
+            add("warn", "certificate", `could not be verified here (${cert.error ?? "unknown error"})`, "check this machine's date and time; if it is right, try another network", "not verifiable");
+        }
+        return cert;
+    };
     try {
         const res = await fetch(health, { signal: AbortSignal.timeout(5000) });
-        const body = (await res.json());
+        const body = (await relayJson(res, health));
+        await certRow(true);
         if (!body.ok && body.storage) {
             const since = body.storage.at ? ` (since ${new Date(body.storage.at).toLocaleString()})` : "";
             add("fail", "relay", `the relay cannot write to its disk: ${body.storage.error ?? "unknown error"}${since}`, hosted ? `this is on the hosted relay's side — nothing on this machine can fix it; tell us at ${FEEDBACK_ADDRESS}` : "free space or fix permissions on the relay host's data folder, then restart the relay", `cannot write to its disk (${where})`);
@@ -429,7 +454,8 @@ export async function doctor(projectDir) {
     }
     catch (e) {
         const msg = e.message;
-        const nx = explainNetError(e, health);
+        const c = await certRow(false);
+        const nx = c?.publicCa === false && worthCertificateCheck(e) ? interceptionExplanation(c) : explainNetError(e, health);
         if (nx) {
             add("fail", "relay", `cannot reach ${health} — ${nx.why}`, nx.fix, `unreachable (${where}): ${nx.share}`);
             return out;
@@ -441,7 +467,10 @@ export async function doctor(projectDir) {
     let joined = false;
     await client.connect().then(() => { joined = true; }).catch(() => { });
     if (!joined) {
-        const nx = client.pending ? null : explainNetError(new Error(client.lastError ?? ""), cfg.relay);
+        const lastErr = new Error(client.lastError ?? "");
+        const seen = cert;
+        const nx = client.pending ? null
+            : seen?.publicCa === false && worthCertificateCheck(lastErr) ? interceptionExplanation(seen) : explainNetError(lastErr, cfg.relay);
         if (nx) {
             add("fail", "live link", `the health check got through but the live connection did not — ${nx.why}`, nx.fix, `live connection failed: ${nx.share}`);
             client.close();
@@ -538,13 +567,22 @@ export async function doctor(projectDir) {
         const f = loadAll();
         const m = f && Object.values(f.spaces ?? {}).find((x) => x.id === (client.spaceId ?? cfg.spaceId) || x.name === cfg.space);
         if (f && m) {
-            const { teamWorkspaces } = await import("./worker-fleet.js");
+            const { teamWorkspaces, unservedFolders } = await import("./worker-fleet.js");
             const ws = teamWorkspaces(f, m.id);
+            for (const u of unservedFolders(f, m.id, ws))
+                add("warn", "worker serves", `${u.path} is bound but not served: ${u.why}`, undefined, "a bound folder is not served");
             const fps = new Set(ws.map((w) => w.fp).filter(Boolean));
             const missing = (m.repos ?? []).filter((r) => !fps.has(r.fp)).map((r) => r.name);
+            if (!ws.length && !unservedFolders(f, m.id, ws).length) {
+                add("warn", "worker serves", `nothing on this machine is bound to "${cfg.space}" — teammates' requests to you wait for your live session`, "from inside the repo or docs folder: pantheon use <team> --here (the worker serves it at once, no restart)", "nothing bound to this team");
+            }
             if (ws.length) {
                 add("pass", "worker serves", `${ws.map((w) => `${w.name}${w.kind === "folder" ? " (folder)" : ""}`).join(", ")}${missing.length ? ` — not on this machine: ${missing.join(", ")}` : ""}`, missing.length ? "requests about those are told they wait for you; clone them, then: pantheon repo find" : undefined, `${ws.length} workspace${ws.length === 1 ? "" : "s"}${missing.length ? `, ${missing.length} team repo${missing.length === 1 ? "" : "s"} not here` : ""}`);
             }
+            if (ws.some((w) => w.kind === "folder")) {
+                const r = folderReaderLine(detectAvailable());
+                add(r.ok ? "pass" : "warn", "folders", r.line, undefined, r.ok ? "any agent here answers folder requests, in a copy" : "no agent here can answer folder requests");
+            }
         }
     }
     {
@@ -613,25 +651,8 @@ export async function doctor(projectDir) {
             add("pass", "alerts", "installed and running — a desktop notification when a teammate needs you", undefined, "installed and running");
         }
     }
-    if (!hookStates.length && !hook.installed) {
-        add("warn", "wake-up hook", "not installed — your agent will not notice a peer's message until you ask it to", "pantheon hook install --user (auto-detects claude / codex / cursor / copilot / kiro on PATH)", "not installed");
-    }
-    else if (!reportsActivity) {
-        add("warn", "wake-up hook", `installed (${hook.events?.join(", ")}) but predates the activity hook, so a worker cannot tell your idle editor from one you are using`, "re-run `pantheon hook install --user` to add the UserPromptSubmit half", `installed (${hook.events?.join(", ")}), predates the activity hook`);
-    }
-    else {
-        const intent = readIntent();
-        intent?.repairs
-            ? add("warn", "wake-up hook", `${hook.events?.join(", ")} (${hook.scope} scope) — but it has been removed and put back ${intent.repairs} time${intent.repairs === 1 ? "" : "s"}`, "something on this machine rewrites ~/.claude/settings.json and drops the hooks key. The worker repairs it, but only while the worker is running", `${hook.events?.join(", ")} (${hook.scope} scope), repaired ${intent.repairs} time${intent.repairs === 1 ? "" : "s"}`)
-            : add("pass", "wake-up hook", `${hook.events?.join(", ")} (${hook.scope} scope)`, undefined, `${hook.events?.join(", ")} (${hook.scope} scope)`);
-    }
-    if (hookStates.some((s) => s.agent === "codex")) {
-        add("warn", "codex hooks", "installed — but codex skips new or changed hooks until they are approved", "run /hooks inside codex once to approve them (needs codex ≥ 0.115; sessions still report presence over MCP either way)", "installed, not yet approved inside codex");
-    }
-    if (hookStates.some((s) => s.agent === "kiro")) {
-        kiroDefaultIsPantheon()
-            ? add("pass", "kiro hooks", "in the pantheon agent, which is your Kiro default — every kiro-cli chat keeps working while a teammate waits", undefined, "in the pantheon agent, the default")
-            : add("warn", "kiro hooks", "in the pantheon agent — used only when you run kiro-cli chat --agent pantheon", "kiro-cli agent set-default pantheon makes it every session; without it, Kiro sessions still report presence but end their turn with a teammate waiting", "in the pantheon agent, not the default");
+    for (const r of hookChecks({ states: hookStates, hook, reportsActivity, repairs: readIntent()?.repairs, kiroDefault: kiroDefaultIsPantheon })) {
+        add(r.level, r.name, r.detail, r.fix, r.share);
     }
     const personas = loadPersonas(projectDir);
     if (personas.length) {
@@ -651,8 +672,38 @@ export async function doctor(projectDir) {
     client.close();
     return out;
 }
+export function hookChecks(f) {
+    const out = [];
+    const add = (level, name, detail, fix, share) => out.push({ level, name, detail, ...(fix ? { fix } : {}), ...(share ? { share } : {}) });
+    const { hook } = f;
+    if (!f.states.length && !hook.installed) {
+        add("warn", "wake-up hook", "not installed — your agent will not notice a peer's message until you ask it to", "pantheon hook install --user (auto-detects claude / codex / cursor / copilot / kiro on PATH)", "not installed");
+    }
+    else if (!f.reportsActivity) {
+        add("warn", "wake-up hook", `installed (${hook.events?.join(", ")}) but predates the activity hook, so a worker cannot tell your idle editor from one you are using`, "re-run `pantheon hook install --user` to add the UserPromptSubmit half", `installed (${hook.events?.join(", ")}), predates the activity hook`);
+    }
+    else {
+        const where = `${hook.events?.join(", ")} (${hook.scope} scope)`;
+        const repaired = repairNote(f.repairs);
+        if (!repaired)
+            add("pass", "wake-up hook", where, undefined, where);
+        else if (!repaired.recurring)
+            add("info", "wake-up hook", `${where} — ${repaired.said}`, undefined, `${where}, repaired once`);
+        else
+            add("warn", "wake-up hook", `${where} — but it has been removed and put back ${f.repairs} times`, `${repaired.why}. The worker repairs it, but only while the worker is running`, `${where}, repaired ${f.repairs} times`);
+    }
+    if (f.states.some((s) => s.agent === "codex")) {
+        add("info", "codex hooks", "installed — codex runs them once they are approved inside codex, a one-time step (and again after an upgrade changes them)", "run /hooks inside codex once to approve them (needs codex ≥ 0.115; sessions still report presence over MCP either way)", "installed, approval inside codex is a one-time step");
+    }
+    if (f.states.some((s) => s.agent === "kiro")) {
+        f.kiroDefault()
+            ? add("pass", "kiro hooks", "in the pantheon agent, which is your Kiro default — every kiro-cli chat keeps working while a teammate waits", undefined, "in the pantheon agent, the default")
+            : add("info", "kiro hooks", "in the pantheon agent — every kiro-cli chat uses it once it is Kiro's default, a one-time step", "kiro-cli agent set-default pantheon makes it every session; without it, Kiro sessions still report presence but end their turn with a teammate waiting", "in the pantheon agent, not the default (a one-time step)");
+    }
+    return out;
+}
 export function render(checks) {
-    const mark = { pass: "\x1b[36m ok \x1b[0m", warn: "\x1b[33mwarn\x1b[0m", fail: "\x1b[31mFAIL\x1b[0m" };
+    const mark = { pass: "\x1b[36m ok \x1b[0m", info: "\x1b[2minfo\x1b[0m", warn: "\x1b[33mwarn\x1b[0m", fail: "\x1b[31mFAIL\x1b[0m" };
     const lines = [];
     for (const c of checks) {
         lines.push(`  ${mark[c.level]}  ${c.name.padEnd(12)} ${c.detail}`);
@@ -661,16 +712,17 @@ export function render(checks) {
     }
     const failed = checks.filter((c) => c.level === "fail").length;
     const warned = checks.filter((c) => c.level === "warn").length;
+    const noted = checks.filter((c) => c.level === "info").length;
     lines.push("");
     lines.push(failed
         ? `\x1b[31m${failed} blocking problem${failed > 1 ? "s" : ""}\x1b[0m${warned ? `, ${warned} warning${warned > 1 ? "s" : ""}` : ""} — fix the FAILs before you start`
         : warned ? `\x1b[36mno blockers\x1b[0m, ${warned} warning${warned > 1 ? "s" : ""} — readable above`
-            : `\x1b[36mall clear\x1b[0m — both machines are ready`);
+            : `\x1b[36mall clear\x1b[0m — both machines are ready${noted ? ` (${noted} note${noted > 1 ? "s" : ""} above, marked info)` : ""}`);
     lines.push(`\x1b[2mpantheon doctor --share  prints this without names or paths, to paste to ${FEEDBACK_ADDRESS}\x1b[0m`);
     return { text: lines.join("\n"), failed };
 }
 export function shareBlock(checks, now = new Date()) {
-    const mark = { pass: "ok  ", warn: "warn", fail: "FAIL" };
+    const mark = { pass: "ok  ", info: "info", warn: "warn", fail: "FAIL" };
     return [
         `pantheon ${VERSION} — doctor, ${now.toISOString().slice(0, 16).replace("T", " ")} UTC`,
         "no names, teams, paths or addresses are in this block; it is safe to paste",

package/dist/folder-guard.js

@@ -86,4 +86,16 @@ export function folderRefusalHere(dir) {
     return folderRefusal(real(dir), folderFacts());
 }
 export const isTemporaryRefusal = (r) => r?.kind === "temporary" || r?.kind === "app-scratch";
+export function projectFolderAnswer(answer, home, cwd, p = path) {
+    let a = answer.trim();
+    if (a.length >= 2 && ((a.startsWith('"') && a.endsWith('"')) || (a.startsWith("'") && a.endsWith("'"))))
+        a = a.slice(1, -1);
+    if (p.sep === "/")
+        a = a.replace(/\\([ ()&'])/g, "$1");
+    if (a === "~")
+        a = home;
+    else if (/^~[\\/]/.test(a))
+        a = p.join(home, a.slice(2));
+    return p.resolve(cwd, a);
+}
 //# sourceMappingURL=folder-guard.js.map