@bragi-gmbh/codebus 1.2.0

package/dist/config.js

@@ -0,0 +1,103 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CodebusError, DeadSessionError } from "./errors.js";
+import { boundIdentity } from "./rolestore.js";
+import { resolveSession } from "./sessionstore.js";
+// Paths are computed per call so HOME overrides (tests, sandboxes) are honored.
+export const configDir = () => join(homedir(), ".codebus");
+export const configFile = () => join(configDir(), "config.json");
+// Legacy constant exports (display use); prefer the functions above.
+export const CONFIG_DIR = configDir();
+export const CONFIG_FILE = configFile();
+export function loadFileConfig() {
+    try {
+        return JSON.parse(readFileSync(configFile(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveFileConfig(patch) {
+    const merged = { ...loadFileConfig(), ...patch };
+    mkdirSync(configDir(), { recursive: true });
+    writeFileSync(configFile(), JSON.stringify(merged, null, 2) + "\n", { mode: 0o600 });
+    return merged;
+}
+export function resolveConfig(o, env = process.env) {
+    const file = loadFileConfig();
+    const url = o.url ?? env.CODEBUS_URL ?? file.url;
+    // Identity precedence: flags > env > THIS SESSION's checkin > cwd role
+    // binding > config file.
+    // The binding tier is what makes `codebus as --bind` in a directory MEAN
+    // that identity there: without it, tick (binding-aware) previews the
+    // role's mail while inbox/read/reply (file-fallback) silently act as the
+    // AUTHOR — the checked-in agent reads the wrong inbox and concludes its
+    // mail doesn't exist (observed live, first Stop-hook field test).
+    // The SESSION tier above it is what lets N agents share one repository
+    // (researcher/planner/coder/verifier on the same checkout): a dir has one
+    // binding slot, but each running session has its own durable identity, and
+    // a checkin binds THAT (sessionstore.ts) without touching the dir.
+    // Explicit assume (flag/env, e.g. from `codebus as` running an {assume}
+    // entry) suppresses inference exactly like an explicit token does: the
+    // caller has already named the identity.
+    // noRoleBinding (author mode, e.g. `codebus checkin`) drops an AMBIENT
+    // CODEBUS_TOKEN too, not just the agent/assume pins: a stray env pin from
+    // the shell must not let checkin mint or rebind a role under the wrong
+    // author (field incident, FM-6). An explicit --token flag still wins —
+    // that's the caller deliberately naming a credential, not ambient leakage.
+    const explicitAssume = o.noRoleBinding ? undefined : (o.assume ?? env.CODEBUS_ASSUME);
+    const ambientToken = o.noRoleBinding ? undefined : env.CODEBUS_TOKEN;
+    const inferAllowed = !o.token && !ambientToken && !explicitAssume && !o.noRoleBinding;
+    // Dead-tier rule (§2.4 precedent 3): a session-tier entry that EXISTED for
+    // this session but no longer resolves to a usable credential must stop
+    // resolution outright — never fall through to the directory-binding tier
+    // (or further, to the file). "No entry at all" (this session was simply
+    // never checked in) is the normal "none" case and dir inference proceeds.
+    const sessionRes = inferAllowed ? resolveSession() : { status: "none" };
+    if (sessionRes.status === "dead")
+        throw new DeadSessionError(sessionRes.role);
+    const session = sessionRes.status === "ok" ? sessionRes : null;
+    const bound = inferAllowed && !session ? boundIdentity(process.cwd()) : null;
+    if (session) {
+        process.stderr.write(`codebus: acting as ${session.role} (this session's checkin${session.entry.assume ? ", assumed via author credential" : ""})\n`);
+    }
+    else if (bound) {
+        // Inferred identity is always announced — silently acting as an inferred
+        // agent is how you act as the wrong one without noticing. stderr, so
+        // piped/JSON stdout stays clean.
+        process.stderr.write(`codebus: acting as ${bound.role} (cwd binding '${bound.pattern}'${bound.assume ? ", assumed via author credential" : ""})\n`);
+    }
+    // An {assume} binding stores no credential: the wire token stays the
+    // AUTHOR's (config.json) and the auth edge function mints the session AS
+    // the role after checking ownership. A raw-token binding never assumes.
+    const token = o.token ?? ambientToken ?? session?.entry.token ?? bound?.token ?? file.token;
+    const assume = explicitAssume ?? session?.entry.assume ?? bound?.assume;
+    const tokenFromFile = !o.token && !ambientToken && !session && !bound && !!file.token;
+    const workspace = o.workspace ?? env.CODEBUS_WORKSPACE ?? file.workspace ?? "default";
+    const anonKey = o.anonKey ?? env.SUPABASE_ANON_KEY ?? file.anonKey;
+    if (assume && !token) {
+        throw new CodebusError(`${bound ? `binding '${bound.pattern}'` : "this session"} assumes role '${assume}' with your ` +
+            `author credential, but there is none — run \`codebus login\` first.`);
+    }
+    if (!token)
+        throw new CodebusError("no token — run `codebus login --token <token>` (or set CODEBUS_TOKEN).");
+    if (!url)
+        throw new CodebusError("no server URL — run `codebus init` (or set CODEBUS_URL).");
+    // file.agent describes the FILE's token; never pin it onto a flag/env token,
+    // or acting as another agent via CODEBUS_TOKEN would fail the identity check.
+    // A bound role's agent IS pinned: the store recorded which agent that token
+    // authenticates as, so a mismatch should fail loudly (as --set verified it).
+    // When assuming, the session authenticates as the ASSUMED slug (never as the
+    // file token's author), so that is what gets pinned.
+    // Author mode pins NOTHING: the server decides authorization (person-linked
+    // check), and the file's agent label is known to drift from its token's true
+    // owner (observed: label said nihviid-default, token authenticated as
+    // nihviid-web) — a stale label must not be able to fail checkin.
+    const agent = o.noRoleBinding
+        ? undefined
+        : (o.agent ?? env.CODEBUS_AGENT ?? (assume ?? (session ? session.role : bound ? bound.role : tokenFromFile ? file.agent : undefined)));
+    const identitySource = o.token || ambientToken || explicitAssume ? "explicit" : session ? "session" : bound ? "cwd-binding" : tokenFromFile ? "file" : "none";
+    return { url, token, agent, workspace, anonKey, assume, identitySource };
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AA6CnD,gFAAgF;AAChF,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,UAAU,CAAC,CAAC;AAC3D,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,aAAa,CAAC,CAAC;AACjE,qEAAqE;AACrE,MAAM,CAAC,MAAM,UAAU,GAAG,SAAS,EAAE,CAAC;AACtC,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,EAAE,CAAC;AAExC,MAAM,UAAU,cAAc;IAC5B,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,MAAM,CAAC,CAAe,CAAC;IACtE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,KAAiB;IAC9C,MAAM,MAAM,GAAG,EAAE,GAAG,cAAc,EAAE,EAAE,GAAG,KAAK,EAAE,CAAC;IACjD,SAAS,CAAC,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5C,aAAa,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACrF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,CAAY,EAAE,MAAyB,OAAO,CAAC,GAAG;IAC9E,MAAM,IAAI,GAAG,cAAc,EAAE,CAAC;IAC9B,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,WAAW,IAAI,IAAI,CAAC,GAAG,CAAC;IAEjD,uEAAuE;IACvE,yBAAyB;IACzB,yEAAyE;IACzE,qEAAqE;IACrE,yEAAyE;IACzE,wEAAwE;IACxE,kEAAkE;IAClE,uEAAuE;IACvE,0EAA0E;IAC1E,2EAA2E;IAC3E,mEAAmE;IACnE,wEAAwE;IACxE,uEAAuE;IACvE,yCAAyC;IACzC,uEAAuE;IACvE,0EAA0E;IAC1E,uEAAuE;IACvE,uEAAuE;IACvE,2EAA2E;IAC3E,MAAM,cAAc,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC;IACtF,MAAM,YAAY,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,aAAa,CAAC;IACrE,MAAM,YAAY,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,YAAY,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC;IAEtF,2EAA2E;IAC3E,uEAAuE;IACvE,yEAAyE;IACzE,wEAAwE;IACxE,0EAA0E;IAC1E,MAAM,UAAU,GAAG,YAAY,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAE,EAAE,MAAM,EAAE,MAAM,EAAY,CAAC;IACnF,IAAI,UAAU,CAAC,MAAM,KAAK,MAAM;QAAE,MAAM,IAAI,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC9E,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/D,MAAM,KAAK,GAAG,YAAY,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7E,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,OAAO,CAAC,IAAI,2BAA2B,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACxJ,CAAC;SAAM,IAAI,KAAK,EAAE,CAAC;QACjB,yEAAyE;QACzE,qEAAqE;QACrE,iCAAiC;QACjC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,KAAK,CAAC,IAAI,kBAAkB,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACtJ,CAAC;IAED,qEAAqE;IACrE,yEAAyE;IACzE,wEAAwE;IACxE,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,IAAI,YAAY,IAAI,OAAO,EAAE,KAAK,CAAC,KAAK,IAAI,KAAK,EAAE,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC;IAC5F,MAAM,MAAM,GAAG,cAAc,IAAI,OAAO,EAAE,KAAK,CAAC,MAAM,IAAI,KAAK,EAAE,MAAM,CAAC;IACxE,MAAM,aAAa,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,YAAY,IAAI,CAAC,OAAO,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;IACtF,MAAM,SAAS,GAAG,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,iBAAiB,IAAI,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC;IACtF,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,IAAI,GAAG,CAAC,iBAAiB,IAAI,IAAI,CAAC,OAAO,CAAC;IACnE,IAAI,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QACrB,MAAM,IAAI,YAAY,CACpB,GAAG,KAAK,CAAC,CAAC,CAAC,YAAY,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,cAAc,kBAAkB,MAAM,cAAc;YAC9F,qEAAqE,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,CAAC,KAAK;QAAE,MAAM,IAAI,YAAY,CAAC,wEAAwE,CAAC,CAAC;IAC7G,IAAI,CAAC,GAAG;QAAE,MAAM,IAAI,YAAY,CAAC,0DAA0D,CAAC,CAAC;IAC7F,6EAA6E;IAC7E,8EAA8E;IAC9E,4EAA4E;IAC5E,6EAA6E;IAC7E,6EAA6E;IAC7E,qDAAqD;IACrD,4EAA4E;IAC5E,6EAA6E;IAC7E,sEAAsE;IACtE,iEAAiE;IACjE,MAAM,KAAK,GAAG,CAAC,CAAC,aAAa;QAC3B,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,aAAa,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IACzI,MAAM,cAAc,GAClB,CAAC,CAAC,KAAK,IAAI,YAAY,IAAI,cAAc,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;IACzI,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;AAC3E,CAAC"}

package/dist/directives.js

@@ -0,0 +1,102 @@
+// Agent-facing directives, shared so every surface that delivers mail teaches
+// the SAME behavior. Field incident (2026-08-13): agents in the standing watch
+// loop received work and replied "acknowledged" without doing anything — the
+// event line said WHAT arrived but no surface said what receiving it MEANS.
+// The rule, everywhere mail lands: a message that ASKS something of you is a
+// work order — do the work and reply with the outcome; a bare acknowledgement
+// is never a substitute for that.
+//
+// RC2 refinement (2026-08-20): "asks something of you" is the operative test,
+// not "is addressed to you". CodeBus already draws this line in the data model
+// and the CLI: an ask/handoff (or any message with required_action set) is a
+// work order; a plain note/plan is FYI. And `codebus ack` has ALWAYS been the
+// lawful close "for mail that needed no reply (an FYI, a broadcast note)"
+// (ack.ts) — so FYI mail requiring no outcome reply is pre-existing contract,
+// not a new escape hatch. Delivery surfaces still guarantee mail is never
+// silently unseen; they simply tell the truth about which class arrived, so a
+// firehose of notes can't drown the actual asks (the field incident that
+// motivated this: a fresh agent facing 500 unread, 501 notes / 4 asks).
+// Two flavors, not one: a message and a task are followed up with different
+// commands (`codebus read <id>` is meaningless for a task id — AI-review
+// finding on this PR, since a shared directive text had been applying the
+// message wording to both). Both share the same "ACT NOW" framing.
+// Message flavor — used verbatim by surfaces (MCP tools) that have no CLI
+// re-arm step of their own; codebus_inbox only ever returns messages, so
+// this is also its exported name.
+export const ACT_DIRECTIVE_CORE = "ACT NOW — this is a work order, not a notification. Read the full message " +
+    "(codebus read <id>), then do what it asks in this session: execute the work, " +
+    "answer the question with substance, or claim the task and start it. Do NOT " +
+    "reply with a bare acknowledgement — reply when you have the outcome, or a " +
+    "concrete blocker plus what you need to clear it. This is delivered OLDEST " +
+    "unhandled mail first — if more is pending, run codebus inbox --unread " +
+    "afterward and act on the rest that are work orders before re-arming; plain " +
+    "FYI notes among them need only a skim or `codebus ack <id>`, not a reply.";
+export const TASK_ACT_DIRECTIVE_CORE = "ACT NOW — this is a work order, not a notification. Claim it and start the " +
+    "work in this session (codebus task claim <id>), then finish with " +
+    "codebus task done <id> --evidence <ref>. Do NOT reply with a bare " +
+    "acknowledgement — report the outcome, or a concrete blocker plus what you " +
+    "need to clear it.";
+// The CLI standing-loop variants: same rules, plus the re-arm step that only
+// applies to a `watch` invocation. Fire on every event watch delivers, not
+// only under --first (AI-review finding: plain `watch --mine` streamed bare
+// event lines forever with no instruction at all).
+const REARM = "Then re-arm: codebus watch --mine --first --timeout 280000";
+export const ACT_DIRECTIVE = `${ACT_DIRECTIVE_CORE} ${REARM}`;
+export const TASK_ACT_DIRECTIVE = `${TASK_ACT_DIRECTIVE_CORE} ${REARM}`;
+// RC2 field incident (2026-08-20): a freshly checked-in agent walked into an
+// inbox of 507 inbound / 500 unread / 504 unhandled, of which 501 were
+// type=note with required_action NULL and only 4 were type=ask. Senders
+// routinely send actionable requests as bare `note`s — every "needs a reply"
+// surface (bus_digest's message class, `inbox --unread` counts) keys off
+// type/required_action, not prose, so a work order sent as a note is
+// structurally indistinguishable from FYI chatter on every one of those
+// surfaces. This is the sender-side half of the fix: a PROSE heuristic that
+// flags a `note` whose body/subject reads like a request, so the CLI/MCP
+// layer can nudge the sender toward `--type ask`/`--type handoff` or
+// `--required-action` — never a hard block (type is sender-declared per
+// DEC-CB-004(B); this module infers nothing, it only advises).
+const REQUEST_PHRASES = /\b(please|can you|could you|would you|need (?:you|u) to|make sure (?:you|to)|you (?:should|must|need to)|action required|action item|let me know|waiting on you|blocked on you|review (?:this|the|it)|reply (?:with|when)|respond (?:with|when)|asap)\b/i;
+/** True when `text` reads like a request/work-order rather than plain FYI prose. */
+export function looksActionable(text) {
+    const t = (text ?? "").trim();
+    if (!t)
+        return false;
+    if (/\?\s*$/.test(t))
+        return true; // a trailing question mark expects an answer
+    return REQUEST_PHRASES.test(t);
+}
+// Reader-side mirror of the same rule (kept in lockstep with bus_digest's
+// class-7/class-8 split, supabase/migrations/0061_actionable_messages.sql):
+// a message is actionable — needs a reply, not just FYI — when it's typed
+// ask/handoff, or ANY type carries an explicit required_action. Used by
+// `codebus inbox` (which reads message_recipients directly, not through
+// bus_digest) to print a needs-reply/FYI split alongside the raw count.
+export function isActionableMessage(m) {
+    if (m.type === "ask" || m.type === "handoff")
+        return true;
+    return !!(m.required_action && m.required_action.trim().length > 0);
+}
+export const NOTE_ACTIONABLE_WARNING = "this reads like a work order sent as a bare note — 'note' is FYI-only and " +
+    "will NOT surface as unhandled work on any actionable-mail surface " +
+    "(bus_digest, inbox --unread counts). If you need a reply or action, resend " +
+    "with --type ask (or --type handoff), and/or --required-action \"<what the " +
+    "recipient owes>\".";
+// FYI directive (0061 — RC2) — review finding: every delivery surface that
+// used to hand back ACT_DIRECTIVE_CORE for "you have unread mail" did so
+// regardless of what the mail actually was, so a class-8 FYI note (unread,
+// but nothing owed) got the SAME "ACT NOW — this is a work order... do the
+// work it asks or answer with substance" instruction as a genuine ask. That
+// directly contradicts bus_digest's own class-7/8 split. This is the counter-
+// part for mail that is NOT actionable (isActionableMessage() is false):
+// still tells the reader something arrived (never silent — mail must not go
+// unseen), but never frames it as a mandatory work order. Used by
+// mcp.ts (codebus_inbox, when every unread item is FYI-only) and watch.ts
+// (per-event, when the specific message/backlog item isn't actionable).
+export const FYI_DIRECTIVE_CORE = "Delivered mail — read it (codebus read <id>); do not leave it unseen. This is " +
+    "plain note/plan mail (no ask/handoff type, no required_action set), so it asks " +
+    "nothing of you: once read, codebus ack <id> to clear it — the same lawful close " +
+    "as a reply, for mail that needs no answer. No outcome reply is required. But if " +
+    "on reading it DOES ask something of you, treat it as a work order: do the work " +
+    "and reply with the outcome — a bare acknowledgement never counts.";
+export const FYI_DIRECTIVE = `${FYI_DIRECTIVE_CORE} ${REARM}`;
+//# sourceMappingURL=directives.js.map

package/dist/directives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"directives.js","sourceRoot":"","sources":["../src/directives.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,+EAA+E;AAC/E,6EAA6E;AAC7E,4EAA4E;AAC5E,6EAA6E;AAC7E,8EAA8E;AAC9E,kCAAkC;AAClC,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,6EAA6E;AAC7E,8EAA8E;AAC9E,0EAA0E;AAC1E,8EAA8E;AAC9E,0EAA0E;AAC1E,8EAA8E;AAC9E,yEAAyE;AACzE,wEAAwE;AAExE,4EAA4E;AAC5E,yEAAyE;AACzE,0EAA0E;AAC1E,mEAAmE;AAEnE,0EAA0E;AAC1E,yEAAyE;AACzE,kCAAkC;AAClC,MAAM,CAAC,MAAM,kBAAkB,GAC7B,4EAA4E;IAC5E,+EAA+E;IAC/E,6EAA6E;IAC7E,4EAA4E;IAC5E,4EAA4E;IAC5E,wEAAwE;IACxE,6EAA6E;IAC7E,2EAA2E,CAAC;AAE9E,MAAM,CAAC,MAAM,uBAAuB,GAClC,6EAA6E;IAC7E,mEAAmE;IACnE,oEAAoE;IACpE,4EAA4E;IAC5E,mBAAmB,CAAC;AAEtB,6EAA6E;AAC7E,2EAA2E;AAC3E,4EAA4E;AAC5E,mDAAmD;AACnD,MAAM,KAAK,GAAG,4DAA4D,CAAC;AAC3E,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,kBAAkB,IAAI,KAAK,EAAE,CAAC;AAC9D,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,uBAAuB,IAAI,KAAK,EAAE,CAAC;AAExE,6EAA6E;AAC7E,uEAAuE;AACvE,wEAAwE;AACxE,6EAA6E;AAC7E,yEAAyE;AACzE,qEAAqE;AACrE,wEAAwE;AACxE,4EAA4E;AAC5E,yEAAyE;AACzE,qEAAqE;AACrE,wEAAwE;AACxE,+DAA+D;AAC/D,MAAM,eAAe,GACnB,0PAA0P,CAAC;AAE7P,oFAAoF;AACpF,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IAC9B,IAAI,CAAC,CAAC;QAAE,OAAO,KAAK,CAAC;IACrB,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,6CAA6C;IAChF,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjC,CAAC;AAED,0EAA0E;AAC1E,4EAA4E;AAC5E,0EAA0E;AAC1E,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,MAAM,UAAU,mBAAmB,CAAC,CAA4D;IAC9F,IAAI,CAAC,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC1D,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,eAAe,IAAI,CAAC,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACtE,CAAC;AAED,MAAM,CAAC,MAAM,uBAAuB,GAClC,4EAA4E;IAC5E,oEAAoE;IACpE,6EAA6E;IAC7E,4EAA4E;IAC5E,oBAAoB,CAAC;AAEvB,2EAA2E;AAC3E,yEAAyE;AACzE,2EAA2E;AAC3E,2EAA2E;AAC3E,4EAA4E;AAC5E,8EAA8E;AAC9E,yEAAyE;AACzE,4EAA4E;AAC5E,kEAAkE;AAClE,0EAA0E;AAC1E,wEAAwE;AACxE,MAAM,CAAC,MAAM,kBAAkB,GAC7B,gFAAgF;IAChF,iFAAiF;IACjF,kFAAkF;IAClF,kFAAkF;IAClF,iFAAiF;IACjF,mEAAmE,CAAC;AACtE,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,kBAAkB,IAAI,KAAK,EAAE,CAAC"}

package/dist/errors.js

@@ -0,0 +1,110 @@
+export class CodebusError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CodebusError";
+    }
+}
+/**
+ * Round-13 review finding 8 (CONFIRMED, MAJOR): `repo connect --build`'s
+ * previous revision embedded the freshly-minted plaintext ingest token
+ * directly in a thrown `CodebusError`'s `message` — the ONE thing every
+ * generic error handler in this codebase (`cli/src/index.ts`'s top-level
+ * `catch`) prints verbatim to stderr on any uncaught failure. That handler
+ * exists precisely to be generic (it has no idea a failure might be
+ * carrying a secret), so the secret ended up in stderr — exactly the kind
+ * of captured-log/CI-log exposure `--json` mode's "token only inside the
+ * one JSON object" contract was designed to prevent for the SUCCESS path,
+ * now silently reappearing on a failure path via a different channel.
+ *
+ * Round-14 review finding 4 (CONFIRMED, MAJOR): the original fix only
+ * covered the `--build` failure sites, named `BuildFailedWithTokenError`.
+ * But `repoConnectFull`'s own doc already establishes that ANY step
+ * AFTER a successful mint (currently: the `ci_wired` transition, then
+ * `--build`) risks the identical loss on failure — a transition failure
+ * was still throwing a plain, token-free `CodebusError`, silently
+ * discarding the operator's only copy exactly like the original bug did,
+ * just one step earlier in the sequence. Renamed to `PostMintFailureError`
+ * and now used by EVERY throw site between a successful mint and the
+ * point `repoConnectFull` returns normally — not enumerated by name here
+ * (that list is expected to grow if more post-mint steps are ever added;
+ * the rule is positional — "after mint, before return" — not a fixed
+ * enumeration of today's two steps) — so a truly generic
+ * `catch (e) { console.error(e.message) }` is safe by construction no
+ * matter which post-mint step actually failed.
+ *
+ * `message` never contains the token. The one caller that needs it
+ * (`repo.ts`'s own connect-command catch, via `handleConnectError`) checks
+ * for this specific class, renders the token deliberately (once, clearly
+ * marked, matching the print-once discipline `printConnectResult` already
+ * established for the success path), and re-throws a plain, token-free
+ * `CodebusError` with the same message for the generic handler to print
+ * as usual.
+ *
+ * Round-15 review finding 2 (CONFIRMED, MINOR): `message` used to be a
+ * hand-written string composed at each throw site, and `handleConnectError`
+ * additionally hardcoded its OWN generic "--build failed" framing on top of
+ * that — accurate for the `--build` throw sites, but wrong for the
+ * transition-failure site (round-14 finding 4 added), which fails before
+ * any build ever starts. `stage` now names which post-mint step actually
+ * failed (`'transition'` | `'build'`), and both `handleConnectError` and
+ * this class's own `message` are built from it, so the rendered diagnostic
+ * always names the step that actually failed instead of assuming it was
+ * always `--build`.
+ */
+export class PostMintFailureError extends CodebusError {
+    token;
+    stage;
+    constructor(message, token, stage) {
+        super(message);
+        this.token = token;
+        this.stage = stage;
+        this.name = "PostMintFailureError";
+    }
+}
+/**
+ * The session-tier dead-tier rule (docs/plans/codebus-v2-reliability.md §2.4
+ * precedent 3): a session-tier entry existed (this session WAS checked in)
+ * but the role it points at has no usable credential anymore. Resolution
+ * stops here — it must never fall through to the directory-binding tier, or
+ * further, to the config file. A distinct class (rather than a message
+ * substring) so callers that need to tell "an identity died, say so loudly"
+ * apart from "there was never any identity here, stay quiet" (tick.ts's
+ * hook-mode contract) can do it structurally.
+ */
+export class DeadSessionError extends CodebusError {
+    role;
+    constructor(role) {
+        super(`no identity — this session checked in as '${role}', but that role's credential is gone ` +
+            `(forgotten via \`codebus as --forget\`, rotated, or never fully stored). Re-checkin: codebus checkin <name>`);
+        this.role = role;
+        this.name = "DeadSessionError";
+    }
+}
+/**
+ * The session store (~/.codebus/session-roles.json) exists but could not be
+ * trusted: unreadable for a reason other than "doesn't exist yet" (ENOENT),
+ * truncated/corrupt JSON, an unexpected shape, or a lock that could not be
+ * acquired. This is DELIBERATELY not the same as "no session-tier entry" —
+ * that "none" case is what lets a never-checked-in session fall through to
+ * the directory-binding tier. A store we can't parse might well have HAD a
+ * durable entry for this exact session before it got mangled (a truncated
+ * write, a half-finished editor save); treating that as "none" would let
+ * resolution silently fall through to a cwd binding and hand this session a
+ * DIFFERENT agent's identity — the exact foreign-identity takeover the
+ * session tier exists to prevent (dead-tier rule, §2.4 precedent 3). So an
+ * unreadable store fails closed: loud in plain mode, and in --hook mode the
+ * existing swallow-everything wrapper still applies, but it swallows to
+ * SILENCE (never resolves), never to an inferred fallback identity.
+ */
+export class SessionStoreError extends CodebusError {
+    constructor(reason) {
+        super(`session store unreadable (${reason}) — refusing to guess this session's identity from a possibly-` +
+            `corrupt ~/.codebus/session-roles.json. Falling back to a directory binding here could hand this ` +
+            `session a DIFFERENT agent's identity. Restore the file from backup, or remove it if it truly cannot ` +
+            `be recovered (this session will re-checkin from scratch), then retry.`);
+        this.name = "SessionStoreError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,YAAa,SAAQ,KAAK;IACD;IAApC,YAAY,OAAe,EAAS,WAAW,CAAC;QAC9C,KAAK,CAAC,OAAO,CAAC,CAAC;QADmB,aAAQ,GAAR,QAAQ,CAAI;QAE9C,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,OAAO,oBAAqB,SAAQ,YAAY;IAChB;IAAsB;IAA1D,YAAY,OAAe,EAAS,KAAa,EAAS,KAA6B;QACrF,KAAK,CAAC,OAAO,CAAC,CAAC;QADmB,UAAK,GAAL,KAAK,CAAQ;QAAS,UAAK,GAAL,KAAK,CAAwB;QAErF,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,gBAAiB,SAAQ,YAAY;IAC7B;IAAnB,YAAmB,IAAY;QAC7B,KAAK,CACH,6CAA6C,IAAI,wCAAwC;YACzF,6GAA6G,CAC9G,CAAC;QAJe,SAAI,GAAJ,IAAI,CAAQ;QAK7B,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IACjC,CAAC;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,iBAAkB,SAAQ,YAAY;IACjD,YAAY,MAAc;QACxB,KAAK,CACH,6BAA6B,MAAM,gEAAgE;YACnG,kGAAkG;YAClG,sGAAsG;YACtG,uEAAuE,CACxE,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF"}

package/dist/git-hooks.js

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { join } from "node:path";
+// CodeBus marker: used to identify hooks we installed (avoid clobbering user hooks)
+const CODEBUS_MARKER = "# CODEBUS-INSTALLED";
+/**
+ * Generate the post-merge/post-commit hook script that triggers incremental graphify updates.
+ * The hook:
+ * - Detaches immediately (async, non-blocking)
+ * - Uses a lock file to defer concurrent triggers (no stacking)
+ * - Time-caps the graphify build (timeout)
+ * - Runs with nice to limit CPU impact
+ * - Includes the CODEBUS_MARKER for idempotent identification
+ *
+ * @returns the bash script content
+ */
+export function generateGitHookScript() {
+    return `#!/bin/bash
+${CODEBUS_MARKER}
+# Auto-generated by CodeBus: local graph freshness hook
+# Triggers incremental graphify update on post-merge and post-commit
+# ADVISORY ONLY: always exits 0 to never block git operations.
+
+REPO_ROOT="\$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+LOCK_FILE="\${REPO_ROOT}/.codebus/hooks.lock"
+LOCK_TIMEOUT=60  # seconds
+
+# Ensure lock directory exists
+mkdir -p "\$(dirname "\$LOCK_FILE")" 2>/dev/null || true
+
+# Acquire or defer: if another build is already running, exit silently
+exec 9>"$LOCK_FILE" 2>/dev/null || true
+if ! flock -n 9 2>/dev/null; then
+  # Another process holds the lock; defer by exiting
+  exit 0
+fi
+
+# Non-blocking detach: fork, disown, and return immediately
+(
+  # Release the lock in the parent's FD before forking the actual work
+  exec 9>&- 2>/dev/null || true
+
+  # Now in the child process; run the actual build with time cap and nice
+  # Redirect all output to /dev/null so failures don't spam the user.
+  (
+    cd "\$REPO_ROOT" 2>/dev/null || exit 1
+    # Timeout 30s, niced to -10 (low priority)
+    # Build failure is silently swallowed (failure containment).
+    timeout 30 nice -n 10 graphify update . > /dev/null 2>&1
+  ) &
+
+  # Child forks another child and exits immediately (double fork for true detach)
+  disown 2>/dev/null || true
+) &
+
+# Parent returns immediately (lock held until child fully detached)
+wait $! 2>/dev/null || true
+
+# ALWAYS exit 0 to never block git (advisory hook, failure containment)
+exit 0
+`;
+}
+/**
+ * Install the CodeBus git hook into a git repository.
+ * If the hook already exists and is a CodeBus hook (contains CODEBUS_MARKER), skip (idempotent).
+ * If it exists but is NOT a CodeBus hook, chain it (append with a call to the original).
+ * Throws on errors or user hook detection.
+ *
+ * @param repoRoot — git repository root (contains .git/)
+ * @param hookName — 'post-merge' or 'post-commit'
+ * @returns { installed: boolean; chained?: boolean }
+ */
+export function installGitHook(repoRoot, hookName) {
+    const hookPath = join(repoRoot, ".git", "hooks", hookName);
+    const script = generateGitHookScript();
+    // Check if hook already exists
+    if (existsSync(hookPath)) {
+        const existing = readFileSync(hookPath, "utf8");
+        // Already installed by CodeBus: idempotent, skip
+        if (existing.includes(CODEBUS_MARKER)) {
+            return { installed: false, message: `${hookName} hook already installed (CodeBus)` };
+        }
+        // User has an existing hook: chain it
+        // Append a call to the original hook at the end of the new hook
+        const chainedScript = script.replace("exit 0\n", `# Chain: run the pre-existing user hook if it exists
+if [ -x "${hookPath}.user" ]; then
+  "\${${hookPath}.user}" "$@"
+  USER_HOOK_EXIT=$?
+  if [ $USER_HOOK_EXIT -ne 0 ]; then
+    exit $USER_HOOK_EXIT
+  fi
+fi
+
+exit 0
+`);
+        // Back up the original hook
+        writeFileSync(join(repoRoot, ".git", "hooks", `${hookName}.user`), existing);
+        writeFileSync(hookPath, chainedScript);
+        chmodSync(hookPath, 0o755);
+        return { installed: true, chained: true, message: `${hookName} hook installed (chained with existing)` };
+    }
+    // Fresh install
+    writeFileSync(hookPath, script);
+    chmodSync(hookPath, 0o755);
+    return { installed: true, message: `${hookName} hook installed` };
+}
+/**
+ * Install both post-merge and post-commit hooks.
+ * Returns a summary of what was installed.
+ */
+export function installGitHooks(repoRoot) {
+    return {
+        postMerge: installGitHook(repoRoot, "post-merge"),
+        postCommit: installGitHook(repoRoot, "post-commit"),
+    };
+}
+//# sourceMappingURL=git-hooks.js.map

package/dist/git-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-hooks.js","sourceRoot":"","sources":["../src/git-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,oFAAoF;AACpF,MAAM,cAAc,GAAG,qBAAqB,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;EACP,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Cf,CAAC;AACF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB,EAAE,QAAsC;IAKrF,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3D,MAAM,MAAM,GAAG,qBAAqB,EAAE,CAAC;IAEvC,+BAA+B;IAC/B,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAEhD,iDAAiD;QACjD,IAAI,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YACtC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,QAAQ,mCAAmC,EAAE,CAAC;QACvF,CAAC;QAED,sCAAsC;QACtC,gEAAgE;QAChE,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,CAClC,UAAU,EACV;WACK,QAAQ;QACX,QAAQ;;;;;;;;CAQf,CACI,CAAC;QAEF,4BAA4B;QAC5B,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,QAAQ,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC7E,aAAa,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QACvC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAE3B,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,QAAQ,yCAAyC,EAAE,CAAC;IAC3G,CAAC;IAED,gBAAgB;IAChB,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAChC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAE3B,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,QAAQ,iBAAiB,EAAE,CAAC;AACpE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB;IAI9C,OAAO;QACL,SAAS,EAAE,cAAc,CAAC,QAAQ,EAAE,YAAY,CAAC;QACjD,UAAU,EAAE,cAAc,CAAC,QAAQ,EAAE,aAAa,CAAC;KACpD,CAAC;AACJ,CAAC"}

package/dist/graph-bootstrap.js

@@ -0,0 +1,95 @@
+import { spawn } from "node:child_process";
+import { CodebusError } from "./errors.js";
+import { loadGraphSnapshot } from "./graph.js";
+/**
+ * Trigger an out-of-band graphify build.
+ * Spawns `graphify update <repoRoot>` as a detached child process and returns immediately.
+ * Logs a single completion notice only (no streaming of build output).
+ *
+ * @param repoRoot — directory containing .graphify_root or graphify-out/
+ * @param opts — builder command (default: 'graphify') and detach mode
+ */
+export async function buildGraphOutOfBand(repoRoot, opts = {}) {
+    const cmd = opts.graphifyCmd ?? "graphify";
+    const detached = opts.detached !== false; // Default true
+    return new Promise((resolve, reject) => {
+        // Spawn detached (non-blocking)
+        const child = spawn(cmd, ["update", repoRoot], {
+            detached,
+            stdio: "ignore", // Suppress all output
+        });
+        // Set up error handler
+        child.once("error", (err) => {
+            reject(new CodebusError(`Failed to spawn graphify: ${err.message}`, 1));
+        });
+        // If detached, unref immediately and resolve
+        if (detached) {
+            child.unref();
+            console.log("Building knowledge graph in background...");
+            resolve();
+        }
+        else {
+            // For testing: wait for process to finish
+            child.once("exit", (code) => {
+                if (code === 0) {
+                    console.log("Building knowledge graph in background...");
+                    resolve();
+                }
+                else {
+                    reject(new CodebusError(`graphify exited with code ${code}`, code || 1));
+                }
+            });
+        }
+    });
+}
+/**
+ * Register the graphify snapshot as an artifact in the registry.
+ * Idempotent: checks if a current snapshot artifact already exists before inserting.
+ *
+ * @param supabase — authenticated Supabase client
+ * @param workspaceId — workspace UUID
+ * @param agentSlug — agent that produced this artifact
+ * @param opts — repoRoot and dryRun for testing
+ */
+export async function registerGraphSnapshot(supabase, workspaceId, agentSlug, opts = {}) {
+    const repoRoot = opts.repoRoot || process.cwd();
+    // Load the current graph snapshot
+    const snapshot = loadGraphSnapshot(repoRoot);
+    if (!snapshot) {
+        throw new CodebusError("No graphify-out/graph.json found to register", 1);
+    }
+    const builtAtCommit = snapshot.built_at_commit;
+    // In dryRun mode, skip all DB operations
+    if (opts.dryRun) {
+        return { registered: false, snapshotCommit: builtAtCommit };
+    }
+    // Check if an artifact with the same built_at_commit already exists (idempotent)
+    const { data: existing, error: queryError } = await supabase
+        .from("artifacts")
+        .select("id")
+        .eq("workspace_id", workspaceId)
+        .eq("kind", "graph-snapshot")
+        .eq("body", builtAtCommit) // Body stores the commit hash
+        .maybeSingle();
+    if (queryError) {
+        throw new CodebusError(`Failed to query existing artifacts: ${queryError.message}`, 1);
+    }
+    if (existing) {
+        // Already registered for this commit; skip insertion
+        return { registered: false, snapshotCommit: builtAtCommit };
+    }
+    // Insert new artifact
+    const { error: insertError } = await supabase
+        .from("artifacts")
+        .insert({
+        workspace_id: workspaceId,
+        kind: "graph-snapshot",
+        title: `Graph snapshot at ${builtAtCommit.slice(0, 7)}`,
+        body: builtAtCommit, // Store the commit hash for idempotency checks
+    });
+    if (insertError) {
+        throw new CodebusError(`Failed to register graph snapshot: ${insertError.message}`, 1);
+    }
+    return { registered: true, snapshotCommit: builtAtCommit };
+}
+//# sourceMappingURL=graph-bootstrap.js.map

package/dist/graph-bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-bootstrap.js","sourceRoot":"","sources":["../src/graph-bootstrap.ts"],"names":[],"mappings":"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"}