@join-pantheon/cli 0.20.0 → 0.21.1

package/dist/config.js

@@ -153,6 +153,20 @@ export function resolveFor(cwd = process.cwd(), opts = {}) {
     }
     return { cfg: null, reason: "unbound", memberships: n, repo };
 }
+export function resolveForHook(cwd = process.cwd()) {
+    const r = resolveFor(cwd, { strict: true });
+    if (!r.cfg?.space)
+        return null;
+    if (r.reason !== "single" || !r.repo)
+        return r.cfg;
+    const f = loadAll();
+    const m = Object.values(f?.spaces ?? {})[0];
+    const bound = Object.values(f?.bindings ?? {}).filter((b) => b.space === m?.id);
+    if (!bound.length)
+        return r.cfg;
+    const here = r.repo;
+    return bound.some((b) => b.path === here.root || (!!b.origin && b.origin === here.origin)) ? r.cfg : null;
+}
 export function load() {
     return resolveFor(process.cwd()).cfg;
 }

package/dist/doctor.js

@@ -1,4 +1,5 @@
 import { execFileSync } from "node:child_process";
+import { loadProfile, profileInitialized } from "./profile.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { PantheonClient } from "./client.js";
@@ -74,6 +75,14 @@ export async function doctor(projectDir) {
     verifyChallenge(cfg.publicKey, cfg.space, cfg.member, nonce, sig)
         ? add("pass", "identity", `keypair valid — fingerprint ${fingerprint(cfg.publicKey)}`)
         : add("fail", "identity", "your keypair does not verify against itself", "the config is corrupt — re-run `pantheon join` to mint a new identity, then get re-admitted");
+    const prof = loadProfile(cfg);
+    if (profileInitialized(prof)) {
+        const owns = Object.entries(prof.authority).filter(([, mode]) => mode === "human_required").map(([d]) => d);
+        add("pass", "profile", `${prof.human.display_name} — ${prof.human.title}${owns.length ? `; you personally decide: ${owns.join(", ")}` : "; no human-required domains yet"}`);
+    }
+    else {
+        add("warn", "profile", "no profile published — decisions cannot be routed to you, and a HUMAN_REQUIRED naming you arrives marked unverified", "pantheon profile set --name <you> --title <role> --human-required <domains you personally decide>");
+    }
     const mcpFile = join(projectDir, ".mcp.json");
     if (!existsSync(mcpFile)) {
         add("warn", "mcp entry", "no .mcp.json in this project", "run `pantheon install`");

package/dist/helpers-build.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+export const helperHashPath = (binary) => `${binary}.source.sha256`;
+export function sourceHash(source) {
+    return createHash("sha256").update(readFileSync(source)).digest("hex");
+}
+export function recordHelperBuild(binary, source) {
+    try {
+        writeFileSync(helperHashPath(binary), sourceHash(source) + "\n");
+    }
+    catch { }
+}
+export function helperStale(binary, source) {
+    if (!existsSync(binary) || !existsSync(source))
+        return false;
+    try {
+        return readFileSync(helperHashPath(binary), "utf8").trim() !== sourceHash(source);
+    }
+    catch {
+        return true;
+    }
+}
+//# sourceMappingURL=helpers-build.js.map

package/dist/mcp.js

@@ -2,7 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { PantheonClient } from "./client.js";
-import { fenceBlock, fenceRubric } from "./untrusted.js";
+import { fenceBlock, fenceRubric, assess, fenceReminder } from "./untrusted.js";
 import { resolveFor } from "./config.js";
 import { LIMITS, SENDABLE } from "./protocol.js";
 import { VERSION } from "./version.js";
@@ -92,8 +92,16 @@ RULES
 - Answer every ASK addressed to you. An unanswered ASK blocks a peer and eventually stalls the goal.
 - ACCEPT means you actually checked. If something is wrong, OBJECT with the reason.
 - One act per pantheon_send. Keep bodies short and reference file paths instead of pasting code.
-- DELIVERED means pushed, not written: commit, push, then send branch + commit. Your peer cannot
-  see your disk. When a peer DELIVERS to you, fetch their commit and look at it before ACCEPTing.
+- DELIVERED means pushed, not written: commit, push, then send branch + commit (+ base: the commit
+  you cut from). Your peer cannot see your disk. When a peer DELIVERS to you, fetch their commit,
+  check the declared base is an ancestor and nothing unrelated rides along, then ACCEPT or OBJECT.
+- Scope against what the team can see. Grep origin/<branch>, not your working tree: your unpushed
+  commits and local edits do not exist for your peer, and naming files from them wastes a round.
+- If your human answers you directly in this session, settle your own ESCALATE yourself: pantheon_send
+  ANSWER with ref = the ESCALATE's id. In an interactive session ask your human first; ESCALATE is for
+  when they are not here. Never RETRACT an escalation to clear it.
+- Verdict first, evidence after, and short: a peer reads your act in one screen. Say when you edited
+  your own human's working tree as a side effect, and leave those edits uncommitted for them.
 - If pantheon_send returns PEER_TURN you have been talking to yourself — go back to pantheon_wait.
 
 The relay only moves messages. It has no access to your files, your shell, or your credentials.
@@ -137,6 +145,8 @@ export async function runMcp() {
     const role = process.env.PANTHEON_ROLE === "worker" ? "worker" : "interactive";
     const branch = process.env.PANTHEON_BRANCH;
     const client = new PantheonClient(cfg, undefined, { role });
+    let siblingsWarned = false;
+    let rubricShown = false;
     const server = new McpServer({ name: "pantheon", version: VERSION }, { instructions: instructions(cfg, role, branch) });
     let connectError = null;
     await client.connect().catch((e) => { connectError = e.message; });
@@ -211,6 +221,12 @@ export async function runMcp() {
         const ref = m?.branch && m?.commit
             ? `\n>> fetchable: branch ${m.branch} at ${m.commit} — fetch and check it before you ACCEPT`
             : "";
+        const base = m?.base && m?.commit
+            ? `\n>> declared base ${m.base}: verify it is an ancestor (git merge-base --is-ancestor ${m.base} ${m.commit}) and that nothing unrelated rides along (git log --oneline ${m.base}..${m.commit})`
+            : "";
+        const unverified = r.act === "HUMAN_REQUIRED" && m?.authority
+            ? `\n>> authority ${m.authority}: no published profile covers ${(m.unverified_domains ?? []).join(", ") || "these domains"}, so the relay let this reach the named human unverified. Ask them to run pantheon profile set.`
+            : "";
         const who = r.session ? `${r.from}[${r.session.slice(-6)}${r.role === "worker" ? "·worker" : ""}]` : r.from;
         const at = new Date(r.ts).toISOString().replace(/\.\d{3}Z$/, "Z");
         const safeBody = fenceBlock(who, r.body).block;
@@ -223,13 +239,25 @@ export async function runMcp() {
             .map((o) => `\n!! this ${r.act} dissolves obligation ${o.id}, which you had claimed (${o.body}) — it is no longer owed; stop working on it.`)
             .join("");
         return `[${r.seq}] ${r.act} from ${who}${r.to ? ` to ${r.to.join(",")}` : ""}` +
-            `${r.goal ? ` (goal ${r.goal})` : ""} at ${at} id=${r.id}${r.ref ? ` ref=${r.ref}` : ""}${lead}${stale}\n${safeBody}${ref}${dissolved}`;
+            `${r.goal ? ` (goal ${r.goal})` : ""} at ${at} id=${r.id}${r.ref ? ` ref=${r.ref}` : ""}${lead}${stale}\n${safeBody}${ref}${base}${unverified}${dissolved}`;
+    };
+    const fmtAll = (acts) => {
+        const flagged = acts.some((a) => assess(a.body).length > 0);
+        const rubric = !rubricShown || flagged ? fenceRubric(acts.length) : fenceReminder(acts.length);
+        rubricShown = true;
+        return acts.map(fmt).join("\n\n---\n\n") + `\n\n${rubric}`;
     };
-    const fmtAll = (acts) => acts.map(fmt).join("\n\n---\n\n") + `\n\n${fenceRubric(acts.length)}`;
     const situation = () => {
         const open = [...client.goals.values()].filter((g) => g.state !== "CLOSED");
         const reach = (p) => {
             const head = client.head;
+            const w = p.worker;
+            const worker = w?.state === "holding"
+                ? `; their worker is holding — ${w.detail ?? "deferring to a live session"}${w.until && w.until > Date.now() ? `, ~${Math.round((w.until - Date.now()) / 1000)}s more` : ""}`
+                : w?.state === "running" ? `; their worker is running${w.detail ? ` (${w.detail})` : ""}` : "";
+            return reachText(p, head) + worker;
+        };
+        const reachText = (p, head) => {
             if (p.seen_seq === undefined) {
                 return p.delivered_seq !== undefined && p.delivered_seq >= head
                     ? ", delivered but no read-receipt — they have no wake-up hook, so it waits for their human"
@@ -245,10 +273,13 @@ export async function runMcp() {
         const peers = client.roster.filter((m) => m.id !== cfg.member);
         const siblings = (client.roster.find((m) => m.id === cfg.member)?.sessions ?? [])
             .filter((s) => s.id !== client.session);
+        const warnSiblings = siblings.length && !siblingsWarned;
+        if (siblings.length)
+            siblingsWarned = true;
         return [
             `you are: ${cfg.member} (${cfg.agent ?? "unknown agent"}, session ${client.session}, role ${role})   space: ${cfg.space}   relay: ${client.connected ? "connected" : "OFFLINE"}`,
             siblings.length
-                ? `your other sessions: ${siblings.map((s) => `${s.id}[${s.role}]`).join(" ")} — claim work before doing it, or you will duplicate theirs`
+                ? `your other sessions: ${siblings.map((s) => `${s.id}[${s.role}]`).join(" ")}${warnSiblings ? " — claim work before doing it, or you will duplicate theirs" : ""}`
                 : `your other sessions: none`,
             peers.length
                 ? `peers: ${peers.map((p) => `${p.id} [${p.online ? "online" : "offline"}, ${p.agent}${reach(p)}]`).join("  ")}`
@@ -319,7 +350,7 @@ export async function runMcp() {
                 : `ASK ${owner.member}'s agent about ${owner.domains.join(", ")}.`);
         }
         if (route.unmatched_domains.length || !route.domains.length) {
-            next.push(`Authority is unresolved${route.unmatched_domains.length ? ` for ${route.unmatched_domains.join(", ")}` : ""}; ESCALATE to your own human instead of guessing.`);
+            next.push(`No published profile owns${route.unmatched_domains.length ? ` ${route.unmatched_domains.join(", ")}` : " these domains"}. If one named peer's human clearly must decide, HUMAN_REQUIRED to them still goes through, marked unverified — and ask them to run pantheon profile set. If it is your own human's call, ESCALATE. Do not guess an owner.`);
         }
         return text(`${JSON.stringify(route, null, 2)}\n\nNEXT\n${next.map((x) => `- ${x}`).join("\n")}`);
     }));
@@ -362,16 +393,19 @@ export async function runMcp() {
             ref: z.string().optional().describe("id of the act you are responding to; required for ANSWER/ACCEPT/OBJECT"),
             branch: z.string().optional().describe("REQUIRED for DELIVERED: the branch you pushed the work to"),
             commit: z.string().optional().describe("REQUIRED for DELIVERED: the commit sha your peer should fetch and check"),
+            base: z.string().optional().describe("for DELIVERED: the commit your branch was cut from, so your peer can check nothing unrelated rides along. Worker runs fill this in automatically."),
             remote: z.string().optional().describe("for DELIVERED: the git remote your peer should fetch from (https://, ssh://, or user@host:path). Without it they have to guess that your origin is theirs."),
             defers_to: z.string().optional().describe("on CLOSE: the goal id you are standing down in favour of. The relay refuses this if that goal is closed or is itself deferring, because both sides standing down at once leaves the work with nowhere to live."),
             affects: z.array(z.string()).optional().describe("on PROPOSE: whose agreement this actually needs. Without it EVERY member of the goal owes a verdict — including anyone offline — so a three-person goal stalls on whoever is away."),
         },
-    }, async ({ act, body, goal, to, ref, branch, commit, remote, decision_domains, summary, defers_to, affects }) => guard(async () => {
-        const meta = branch || commit || remote || decision_domains?.length
+    }, async ({ act, body, goal, to, ref, branch, commit, remote, base, decision_domains, summary, defers_to, affects }) => guard(async () => {
+        const baseSha = act === "DELIVERED" ? (base ?? process.env.PANTHEON_BASE) : undefined;
+        const meta = branch || commit || remote || baseSha || decision_domains?.length
             ? {
                 ...(branch ? { branch } : {}),
                 ...(commit ? { commit } : {}),
                 ...(remote ? { remote } : {}),
+                ...(baseSha ? { base: baseSha } : {}),
                 ...(decision_domains?.length ? { decision_domains } : {}),
             }
             : undefined;

package/dist/notifier.js

@@ -1,4 +1,5 @@
 import { execFileSync, spawn } from "node:child_process";
+import { helperStale, recordHelperBuild } from "./helpers-build.js";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { platform } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -17,10 +18,10 @@ export function dueHumanObligations(obligations, member, state, now, reminderMs)
         return last === undefined || now - last >= reminderMs;
     });
 }
-export function pruneNotificationState(state, obligations, member) {
+export function pruneNotificationState(state, obligations, member, now = Date.now()) {
     const active = new Set(humanObligations(obligations, member).map((o) => o.id));
     return {
-        notified_at: Object.fromEntries(Object.entries(state.notified_at).filter(([id]) => active.has(id))),
+        notified_at: Object.fromEntries(Object.entries(state.notified_at).filter(([id, at]) => active.has(id) || (id.startsWith("act:") && now - at < 7 * 86_400_000))),
     };
 }
 function readState(file) {
@@ -56,8 +57,10 @@ export function ensureNativeNotifier(home = CONFIG_DIR) {
     requireDeveloperTools("notifications", "notifier");
     execFileSync("/usr/bin/swiftc", ["-O", source, "-o", binary], { stdio: "pipe" });
     chmodSync(binary, 0o755);
+    recordHelperBuild(binary, source);
     return binary;
 }
+export function notifierStale(home = CONFIG_DIR) { return helperStale(hudBinaryPath(home), hudSourcePath()); }
 export function requireDeveloperTools(what, service) {
     try {
         execFileSync("/usr/bin/xcode-select", ["-p"], { stdio: "pipe" });
@@ -108,12 +111,15 @@ export class HumanNotifier {
         this.opts.log(`notifier online as ${this.cfg.member}`);
         this.opts.log(`  reminders every ${Math.round(this.opts.reminderMs / 60_000)} minutes while unresolved`);
         while (!this.stopped) {
-            const pruned = pruneNotificationState(state, client.obligations, this.cfg.member);
+            const pruned = pruneNotificationState(state, client.obligations, this.cfg.member, now());
             let dirty = JSON.stringify(pruned) !== JSON.stringify(state);
             state = pruned;
-            const due = dueHumanObligations(client.obligations, this.cfg.member, state, now(), this.opts.reminderMs);
+            const profile = loadProfile(this.cfg);
+            const prefs = profile.notifications ?? { decisions: true, deliveries: false, worker_done: false };
+            const due = prefs.decisions
+                ? dueHumanObligations(client.obligations, this.cfg.member, state, now(), this.opts.reminderMs)
+                : [];
             for (const obligation of due) {
-                const profile = loadProfile(this.cfg);
                 const goal = obligation.goal ? client.goals.get(obligation.goal)?.title : undefined;
                 const ok = send("Your input is needed", oneLine(`${this.opts.label ? `${this.opts.label} · ` : ""}${goal ?? "Pantheon decision"}`, 80), decisionTitle(obligation.body, 180), profile, decisionPrompt(obligation.id));
                 if (ok) {
@@ -127,7 +133,24 @@ export class HumanNotifier {
             }
             if (dirty || !existsSync(stateFile))
                 writeState(stateFile, state);
-            await client.next(pollMs);
+            const arrived = await client.next(pollMs);
+            if (prefs.deliveries) {
+                for (const r of arrived) {
+                    if (r.act !== "DELIVERED" || r.from === this.cfg.member || state.notified_at[`act:${r.id}`])
+                        continue;
+                    const goal = r.goal ? client.goals.get(r.goal) : undefined;
+                    const forMe = (r.to?.includes(this.cfg.member) ?? false) || (goal?.members.includes(this.cfg.member) ?? false);
+                    if (!forMe)
+                        continue;
+                    const m = r.meta;
+                    const ok = send("Work delivered to you", oneLine(`${this.opts.label ? `${this.opts.label} · ` : ""}${goal?.title ?? "Pantheon delivery"}`, 80), oneLine(`${r.from} pushed ${m?.branch ?? "a branch"}${m?.commit ? ` @ ${m.commit.slice(0, 7)}` : ""} — ${r.body}`, 180), profile, `A teammate delivered work in pantheon: fetch ${m?.branch ?? "their branch"}${m?.commit ? ` at ${m.commit}` : ""} from ${r.from}, check it against the goal "${goal?.title ?? r.goal ?? ""}", then ACCEPT or OBJECT.`, "Delivered");
+                    if (ok) {
+                        state.notified_at[`act:${r.id}`] = now();
+                        writeState(stateFile, state);
+                        this.opts.log(`> delivery alert for ${r.id} from ${r.from}`);
+                    }
+                }
+            }
         }
         client.close();
     }

package/dist/notify.js

@@ -290,7 +290,7 @@ export async function decideStop(raw, deps) {
     const acts = report.acts ?? [];
     const owed = report.obligations ?? [];
     const closed = new Set(report.closed_goals ?? []);
-    const DEMANDS_RESPONSE = new Set(["ASK", "PROPOSE", "OBJECT", "DELIVERED", "CONTRACT", "ESCALATE"]);
+    const DEMANDS_RESPONSE = new Set(["ASK", "PROPOSE", "OBJECT", "DELIVERED", "CONTRACT"]);
     const work = acts.filter((a) => {
         if (a.goal && closed.has(a.goal))
             return false;

package/dist/pending.js

@@ -102,10 +102,12 @@ export async function pending(opts) {
     const obligations = surfaced.filter((o) => !alreadySeen.has(o.id));
     const head = obligationsBody?.seq;
     const all = (historyBody?.acts ?? []);
+    const mine = all.filter((r) => r.from === cfg.member);
     const acts = all
         .filter((r) => r.from !== cfg.member)
         .filter((r) => r.act !== "JOIN" && r.act !== "LEAVE")
-        .filter((r) => !r.to || r.to.length === 0 || r.to.includes(cfg.member));
+        .filter((r) => !r.to || r.to.length === 0 || r.to.includes(cfg.member))
+        .filter((r) => !mine.some((m) => m.seq > r.seq && (m.ref === r.id || (!!r.goal && m.goal === r.goal))));
     const seq = first
         ? head
         : historyBody === null

package/dist/plans.js

@@ -0,0 +1,46 @@
+export const UNLIMITED = 1_000_000;
+export const DEFAULT_PLANS = {
+    free: { spaces: 1, members: 2, wake: true },
+    pro: { spaces: 10, members: 25, wake: true },
+};
+export const PLAN_NAME = /^[a-z][a-z0-9_-]{0,23}$/;
+const int = (v, min, max) => typeof v === "number" && Number.isInteger(v) && v >= min && v <= max ? v : null;
+export function parseLimits(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const o = raw;
+    const num = (v) => typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+    const spaces = int(num(o["spaces"]), 0, UNLIMITED);
+    const members = int(num(o["members"]), 1, UNLIMITED);
+    const wake = typeof o["wake"] === "boolean" ? o["wake"] : o["wake"] === "true" || o["wake"] === "on" || o["wake"] === "1" ? true : o["wake"] === "false" || o["wake"] === "off" || o["wake"] === "0" || o["wake"] === undefined ? false : null;
+    if (spaces === null || members === null || wake === null)
+        return null;
+    return { spaces, members, wake };
+}
+export function parsePlans(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const out = {};
+    for (const [name, lim] of Object.entries(raw)) {
+        if (!PLAN_NAME.test(name))
+            return null;
+        const l = parseLimits(lim);
+        if (!l)
+            return null;
+        out[name] = l;
+    }
+    return out["free"] ? out : null;
+}
+export function planLimits(plans, plan, override) {
+    if (override) {
+        try {
+            const l = parseLimits(JSON.parse(override));
+            if (l)
+                return l;
+        }
+        catch { }
+    }
+    return plans[plan] ?? plans["free"] ?? DEFAULT_PLANS["free"];
+}
+export const fmtLimit = (n) => n >= UNLIMITED ? "unlimited" : String(n);
+//# sourceMappingURL=plans.js.map

package/dist/profile.js

@@ -25,6 +25,7 @@ export function defaultProfile(cfg) {
         human: { display_name: cfg.display ?? cfg.member, title: "", responsibilities: [] },
         agent: { primary_surface: surfaceFromAgent(cfg.agent), wake_enabled: false },
         attention: { urgent: "primary_surface", decision: "primary_surface", fyi: "inbox" },
+        notifications: { decisions: true, deliveries: false, worker_done: false },
         authority: {},
         decision_keywords: {},
         capabilities: [],
@@ -32,6 +33,9 @@ export function defaultProfile(cfg) {
         updated_at: 0,
     };
 }
+export function wakeDefault(profile) {
+    return (profile.agent.wake_default ?? "anyone") === "anyone";
+}
 export function loadProfile(cfg, file = profilePath()) {
     if (!existsSync(file))
         return defaultProfile(cfg);
@@ -53,6 +57,7 @@ export function loadProfile(cfg, file = profilePath()) {
             },
             agent: { ...defaultProfile(cfg).agent, ...raw.agent, primary_surface: surface },
             attention: { ...defaultProfile(cfg).attention, ...raw.attention },
+            notifications: { ...defaultProfile(cfg).notifications, ...(raw.notifications ?? {}) },
             authority: raw.authority ?? {},
             decision_keywords: cleanKeywords(legacy.decision_keywords),
             capabilities: Array.isArray(raw.capabilities) ? raw.capabilities.filter((x) => typeof x === "string") : [],

package/dist/protocol.js

@@ -160,6 +160,7 @@ export const BindRepo = z.object({
     cid: z.string().max(64).optional(),
     repo: z.string().regex(/^[rl]_[0-9a-f]{16}$/),
     origin: z.string().max(200).nullable().optional(),
+    base: z.string().min(1).max(100).optional(),
 });
 export const OpenGoal = z.object({
     t: z.literal("open_goal"),
@@ -171,7 +172,18 @@ export const OpenGoal = z.object({
     deadline: z.number().int().positive().optional(),
 });
 export const Ping = z.object({ t: z.literal("ping") });
-export const Inbound = z.discriminatedUnion("t", [Hello, SendAct, OpenGoal, Claim, Admit, MakeInvite, PublishProfile, BindRepo, Ping]);
+export const DeleteSpace = z.object({
+    t: z.literal("delete_space"),
+    cid: z.string().max(64).optional(),
+    confirm: z.string().min(1).max(64),
+});
+export const WorkerState = z.object({
+    t: z.literal("worker_state"),
+    state: z.enum(["idle", "holding", "running"]),
+    detail: z.string().max(200).optional(),
+    until: z.number().int().positive().optional(),
+});
+export const Inbound = z.discriminatedUnion("t", [Hello, SendAct, OpenGoal, Claim, Admit, MakeInvite, PublishProfile, BindRepo, DeleteSpace, WorkerState, Ping]);
 export function shouldDeferToHuman(sessions, work, opts = {}) {
     const now = opts.now ?? Date.now();
     const idleMs = opts.idleMs ?? LIMITS.workerIdleMs;

package/dist/quickstart.js

@@ -4,6 +4,7 @@ import { basename } from "node:path";
 import { homedir } from "node:os";
 import { PantheonClient } from "./client.js";
 import { load, save, toInvite, resolveFor, repoInfo, bindRepo, DEFAULT_RELAY } from "./config.js";
+import { loadProfile, wakeDefault } from "./profile.js";
 import { newKeypair } from "./identity.js";
 import { installForUser } from "./install.js";
 import { writeIntent, installHooks } from "./notify.js";
@@ -203,7 +204,7 @@ export async function start(opts) {
                     warnings.push(`this repo was bound to another team (${replaced.space}); it now belongs to "${c.space}"`);
             }
             opts.log(`  space      ${c.space} ${reuse ? "— reconnected" : "— created, you own it"}${repo ? `   ${repo.origin ?? "local repo"} → bound to it` : ""}`);
-            const inv = await client.makeInvite(true, opts.ttlMinutes);
+            const inv = await client.makeInvite(wakeDefault(loadProfile(c)), opts.ttlMinutes);
             invite = toInvite({ ...c, token: inv.url });
             claimed = true;
         }