@primitive.ai/prim 0.1.0-alpha.45 → 0.1.0-alpha.46

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: prim
-description: Use the prim CLI for Primitive's decision graph — passive decision capture, the conflict gate, reconcile, rationale confirmations, and team presence. TRIGGER when the user mentions Primitive, prim, decisions / the decision graph / a conflict gate / reconcile; when an edit is denied or warned by a prior decision; when the repo's package.json depends on @primitive.ai/prim; when configuring Primitive session or git hooks. SKIP when "decision" is unrelated to Primitive, or for unrelated CLIs.
+description: Use the prim CLI for Primitive's decision graph — passive capture of coding decisions, deliberate recording of higher-order forks in the road, the conflict gate, reconcile, rationale confirmations, and team presence. TRIGGER when the user mentions Primitive, prim, decisions / the decision graph / a conflict gate / reconcile; when a durable decision emerges during coding, planning, review, or connected-context work; when an edit is denied or warned by a prior decision; when the repo's package.json depends on @primitive.ai/prim; when onboarding to or configuring Primitive session or git hooks. SKIP when "decision" is unrelated to Primitive, or for unrelated CLIs.
 ---
 
 # Working with the prim CLI
@@ -11,7 +11,7 @@ description: Use the prim CLI for Primitive's decision graph — passive decisio
 
 As your team codes, prim passively captures the **decisions** you make -- which library, which pattern, which config value -- into a queryable graph, and links them: a decision can depend on earlier decisions (auto-linked from shared files, or related by hand — see *Relate decisions*) and reference the files it touched. **Conflict Gates** can check a later change against that graph and surface any load-bearing decision it conflicts with; with **Enforcement**, prim blocks the edit until you reconcile the decision and retry. Conflict Gates are **not currently enabled** — capture runs regardless. To enable them for your team, contact support@getprimitive.ai.
 
-You never invoke capture. It runs automatically through the session hooks installed by `npx --yes @primitive.ai/prim claude install` (Claude Code), `npx --yes @primitive.ai/prim codex install` (Codex), or `npx --yes @primitive.ai/prim hermes install` (Hermes). Your job is to **read** the graph before load-bearing edits and **answer** the occasional rationale confirmation. (Responding to Conflict Gates applies only once Enforcement is enabled — see below.)
+Low-level capture runs automatically through the session hooks installed by `npx --yes @primitive.ai/prim claude install` (Claude Code), `npx --yes @primitive.ai/prim codex install` (Codex), or `npx --yes @primitive.ai/prim hermes install` (Hermes). Deliberately record higher-order forks in the road through `prim decisions create` as described below. Your job is also to **read** the graph before load-bearing edits and **answer** the occasional rationale confirmation. (Responding to Conflict Gates applies only once Enforcement is enabled — see below.)
 
 ## Auth
 
@@ -49,6 +49,8 @@ When enabled, the gate fail-opens on its *own* infrastructure errors (no daemon,
 - `npx --yes @primitive.ai/prim decisions recent` -- the team's recent decisions, each row badged by author and agent (`Your Claude Code` / `Your Codex` / `Your Hermes`); `--limit <n>` and `--since <dur>` narrow it. `--author "<name>"` filters to one teammate (feed name, `"First Last"`, last name, username, email, or email local-part) -- the way to answer "what has X decided?"; an unknown or ambiguous name comes back as `unavailable` with the reason, and `authorHasDecisions` in the JSON distinguishes "no feed-visible decisions" (false) from "has decisions, none in this window" (true). The page defaults to the 10 most recent, so it can hide older ones: on an author query the JSON's `windowTotal` is how many that teammate has in the window. When `windowTotal` exceeds the rows returned, don't present the page as complete -- tell the user you're showing the most recent N of `windowTotal` and offer to pull the rest, which is a re-run with `--limit <windowTotal>` (capped at 100; `windowTotalCapped` means the count is a floor rendered `N+`, and a window past 100 can't be fetched whole).
 - `npx --yes @primitive.ai/prim decisions show <idOrShortId>` and `npx --yes @primitive.ai/prim decisions cascade <idOrShortId>` -- full detail, and the downstream blast radius a change would disturb.
 
+Before presenting decision reads, use the current conversation, task, and available memory to understand what matters to the requester. Do not dump the API's chronological rows unchanged. Group related decisions around goals or workstreams, lead with decisions that affect the requester's current work, and surface conflicts, supersessions, or consequential tradeoffs before background activity. Explain why an item is relevant when the connection is supported; do not invent relevance or rationale. Preserve the response's `unavailable`, truncation, and count semantics when reshaping it.
+
 ## Reconcile and the verdict footer
 
 Reconcile and the verdict footer are part of Conflict Gates **Enforcement**, which is **not currently enabled** (contact support@getprimitive.ai to turn it on); the `reconcile` command stays available regardless. When Enforcement is on:
@@ -71,15 +73,96 @@ npx --yes @primitive.ai/prim decisions confirm <idOrShortId>
 
 Confirmations are author-targeted and rare by design; answering keeps the graph's rationale trustworthy. Don't manufacture rationale — if you don't know why a decision was made, say so.
 
-## Author a decision deliberately
+## Preserve durable user decisions
+
+Capture is automatic for low-level choices made while coding. Use the deliberate CLI path for higher-order decisions that emerge in conversation: goals, priorities, principles, invariants, constraints, defaults, commitments, durable tradeoffs, and exceptions.
+
+A decision worth deliberately recording is a genuine **fork in the road**: the user or agent encountered multiple plausible paths, selected one, and that selection should inform future work. Record the chosen behavior, direction, constraint, or tradeoff—not routine implementation needed to finish the task or follow an existing convention. A teammate working elsewhere should benefit from knowing it.
+
+### Ground the rationale in available context
+
+Before deliberately recording a decision, use the full context already available to you to identify **why this path was chosen**. Start with the current conversation. When the decision or task points to relevant connected sources, inspect them too—especially Slack, Granola or other meeting notes, Linear, Zoom transcripts, email, and repository docs or skills. Prefer the specific thread, meeting, ticket, or document the user referenced over a broad search.
+
+Record only rationale supported by those sources. Do not mistake the implementation method, the task request, or a restatement of the decision for its rationale. If the rationale remains unclear or the relevant source is unavailable, omit `--rationale` rather than inventing one.
+
+For proactively identified decisions, let confidence in the rationale determine the interaction:
+
+- **Clear and well-supported** — record the decision and rationale silently at the natural task boundary.
+- **Plausible but uncertain** — at the task boundary, state the proposed rationale and ask for lightweight confirmation: “I understand the reason for choosing X to be Y. Is that right?” Record after confirmation or correction.
+- **No supported rationale** — at the task boundary, ask one focused question: “What made you choose X over the other path?” Record after the answer.
+
+These questions share the interruption budget below; never ask separate questions for the decision and its rationale. If both are uncertain, combine them into one concise prompt. An explicit request to “add this decision to Primitive” still records immediately with the information supplied—do not delay it to demand rationale.
+
+### Direct requests: record immediately
+
+When the user asks to record a decision—for example, “add this decision to Primitive”—author it directly. Do not ask for another confirmation.
+
+### Clear decisions: record without interrupting
+
+When the user clearly makes a durable fork-in-the-road decision without explicitly asking to record it, record it at the next natural task boundary without asking a redundant confirmation question. Preserve the user's meaning and stated rationale; do not strengthen, broaden, or embellish it. Prefer the governing position over the implementation activity that revealed it.
+
+Examples that qualify:
+
+- “We're prioritizing retention this quarter.”
+- “Customer data must remain in the EU.”
+- “Authentication state remains server-authoritative.”
+- “Do not introduce another frontend framework.”
+
+Treat changes to shared agent instructions and standards—such as `AGENTS.md`, `CLAUDE.md`, repository skills, architecture rules, and design-system guidance—as a high-signal opportunity to preserve a decision. Inspect what rule the change establishes or revises. If it represents a genuine fork in the road, record the durable policy itself, not “updated the docs.” If the edit only documents a decision already present in Primitive, do not create a duplicate.
+
+Apply the same attention during non-code deliberation: planning or “grill me” workflows, spec refinement, behavior design, PR planning or review, and conversations imported from Granola or other connected sources. These workflows can settle important forks before any code changes. Accumulate the confirmed decisions and record them at a natural phase or task boundary; do not interrupt or call Primitive after every answer.
 
-Capture is automatic for the decisions you *make while coding*. When the user instead asks you to **record a decision explicitly** — one that didn't fall out of an edit (a design call, a convention, a choice settled in discussion) — author it directly:
+### Onboarding: propose decisions from shared repository memory
+
+When onboarding or `prim welcome` reports `"org": "seed"`, complete this procedure before falling back to the open goals question. Do not treat memory already loaded into the conversation as a substitute for the repository scan. This is a separate decision-proposal pass: do not present repository rules as the user's stated goals or insert them into `$FOUND_GOALS`.
+
+1. From the repository root, discover every Git-tracked shared memory or agent-instruction file with:
+
+   ```
+   git ls-files -- \
+     'MEMORY.md' ':(glob)**/MEMORY.md' \
+     'AGENTS.md' ':(glob)**/AGENTS.md' \
+     'CLAUDE.md' ':(glob)**/CLAUDE.md'
+   ```
+
+2. Read every path returned before selecting candidates. Never automatically read an untracked or gitignored memory file; use one only when the user explicitly asks to promote it to the team's Primitive graph.
+3. Extract at most three explicit, durable positions that appear to remain in force. A candidate must state a genuine fork in the road—such as a goal, priority, principle, invariant, constraint, default, commitment, tradeoff, or exception. Do not infer decisions from code, repository structure, or unstated implications. Do not bulk-import the documents.
+4. Run `npx --yes @primitive.ai/prim decisions recent --limit 20` and omit candidates equivalent to existing decisions. If the result is unavailable or too incomplete to rule out a duplicate confidently, do not propose the uncertain candidate; explain the limitation.
+5. Present the remaining candidates as proposed decisions. For each one, include the proposed intent, the source path, and only rationale or alternatives explicitly supported by that source. Ask the user to approve or revise the proposals before creating them; do not silently attribute a historical repository decision to the onboarding user.
+
+If the scan returns no matching files or no eligible candidates, say so briefly and continue with the normal open onboarding question. Never invent a proposal to fill the gap.
+
+Outside onboarding, before creating a proactively identified decision, read recent decisions to avoid duplicating an existing position:
+
+```
+npx --yes @primitive.ai/prim decisions recent --limit 20
+```
+
+If an equivalent decision is already present, do not create or suggest it again. After this duplicate check—or after the user confirms an onboarding proposal—author the decision directly:
 
 ```
 npx --yes @primitive.ai/prim decisions create --intent "Adopt prosemirror-collab over Yjs" --area data --rationale "Server-authoritative ordering" --alternatives "Yjs,Automerge"
 ```
 
-Only `--intent` is required. Optional: `--kind` (change|exploration|task_execution|unclear, default change), `--rationale`, `--area`, `--decided`, `--alternatives` (comma-separated), `--confidence` (high|medium|low, default high), `--reversibility` (high|low, default high), and `--files` (comma-separated repo-relative paths the decision governs — these are the files Conflict Gates would check on later edits, same path form as `decisions check`; Conflict Gates are not currently enabled). STDOUT is the created identity `{ decisionId, shortId, createdAt }`; STDERR prints `[prim] created dec_<short>.` — pass that `dec_<short>` straight into `decisions show` / `cascade` / `confirm`. Author on the user's behalf only when they ask for a decision to be recorded; don't narrate your own routine edits into the graph (the hooks already do that).
+Only `--intent` is required. Optional: `--kind` (change|exploration|task_execution|unclear, default change), `--rationale`, `--area`, `--decided`, `--alternatives` (comma-separated), `--confidence` (high|medium|low, default high), `--reversibility` (high|low, default high), and `--files` (comma-separated repo-relative paths the decision governs — these are the files Conflict Gates would check on later edits, same path form as `decisions check`; Conflict Gates are not currently enabled). Omit `--files` for broad directions that should not immediately participate in file-based Conflict Gates. STDOUT is the created identity `{ decisionId, shortId, createdAt }`; STDERR prints `[prim] created dec_<short>.` — pass that `dec_<short>` straight into `decisions show` / `cascade` / `confirm`.
+
+### Inferred decisions: finish first, then optionally ask once
+
+When several statements or implementation choices strongly imply a higher-order fork in the road but the user did not state the decision explicitly, do not record it automatically. Complete the requested work first. At the natural stopping point, optionally ask one concise confirmation question that states the synthesized decision:
+
+> A broader direction seemed to emerge: prioritize activation and retention before acquisition work. Should I record that as a team decision?
+
+Record it only after an affirmative response. Consolidate related evidence into one governing decision rather than listing or recording each underlying implementation choice.
+
+### Interruption budget
+
+- Never interrupt active implementation solely to improve Primitive's records.
+- Ask at most one Primitive-related confirmation question per task, only after completing the requested work.
+- Ask nothing when the inference is weak, local, temporary, already recorded, or unlikely to guide another teammate.
+- Do not ask when the user requested a narrow execution task or appears to want a quick result without discussion.
+- Drop a rejected suggestion. Do not raise it again unless the user materially changes the decision.
+- If ambiguity must already be resolved to perform the task, fold the durable-policy distinction into that necessary question instead of adding a separate Primitive question.
+- Do not narrate or record routine edits, syntax, naming, testing, debugging tactics, or branch/commit mechanics; passive hooks already cover coding activity.
 
 ## Relate decisions (link / unlink)
 
@@ -142,9 +225,11 @@ Examples:
 - **An "unavailable" / "not verified" decision check is not an all-clear.** Treat constraints as UNKNOWN and proceed deliberately; never read the silence as approval — the same holds for Conflict Gates once enabled.
 - **When Enforcement is enabled, a `deny` means a real prior decision conflicts.** Reconcile only when you genuinely intend to override it; otherwise pick an approach that respects it.
 - **Reconcile bypasses are single-use and short-lived.** One bypass clears your *next* edit to the governed file; it is not a standing override.
-- **Capture of your coding activity is automatic, never manual.** If decisions aren't showing up, check that the session hooks are installed (`claude status` / `codex status` / `hermes status`) and the daemon is running — don't try to inject moves by hand. (Deliberately *authoring* a decision the user asks you to record is a separate, supported path — `decisions create`, above.)
+- **Capture of coding activity is automatic; never inject moves by hand.** If decisions aren't showing up, check that the session hooks are installed (`claude status` / `codex status` / `hermes status`) and the daemon is running. Deliberately authoring a higher-order fork—either at the user's request or under the conservative proactive policy above—is a separate, supported path through `decisions create`.
 - **Don't fabricate rationale on a confirmation.** If you don't know why a decision was made, say so rather than guessing.
 
 ## After each task
 
+If the user clearly made a durable fork-in-the-road decision, check recent decisions and record it now if it is not already present. If a strong higher-order decision was only inferred, decide whether it clears the interruption budget; if so, ask the single concise confirmation question after reporting the completed work. Otherwise say nothing about Primitive.
+
 If Conflict Gates are enabled and one denied or warned you, report which decision(s) it named and whether you reconciled. If you read the graph before a load-bearing change, note what you found so the user can verify in the dashboard.

package/dist/{chunk-ZWTZMTV5.js → chunk-ESLX7ISX.js}

@@ -1,6 +1,6 @@
 import {
   getSiteUrl
-} from "./chunk-PI6LDYNJ.js";
+} from "./chunk-VQ2ZV2D5.js";
 
 // src/journal.ts
 import {

package/dist/{chunk-6TRRGGLD.js → chunk-JT4Q333I.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-PI6LDYNJ.js";
+} from "./chunk-VQ2ZV2D5.js";
 
 // src/decisions/feedback.ts
 var FEEDBACK_PROTOCOL_VERSION = 1;

package/dist/chunk-VQ2ZV2D5.js

@@ -0,0 +1,502 @@
+// src/client.ts
+import { createHash, randomBytes as randomBytes2 } from "crypto";
+import {
+  chmodSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join2, resolve } from "path";
+
+// src/lib/file-lock.ts
+import { randomBytes } from "crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_POLL_MS = 50;
+var DEFAULT_INIT_GRACE_MS = 2e3;
+var DIRECTORY_MODE = 448;
+var FILE_MODE = 384;
+function ownerPath(lockDir) {
+  return join(lockDir, "owner.json");
+}
+function readOwner(lockDir) {
+  try {
+    const owner = JSON.parse(readFileSync(ownerPath(lockDir), "utf8"));
+    if (!Number.isInteger(owner.pid) || owner.pid <= 0 || typeof owner.nonce !== "string" || typeof owner.createdAt !== "number") {
+      return null;
+    }
+    return owner;
+  } catch {
+    return null;
+  }
+}
+function sameOwner(a, b) {
+  return a?.pid === b.pid && a.nonce === b.nonce && a.createdAt === b.createdAt;
+}
+function tryTakeLock(lockDir, now) {
+  try {
+    mkdirSync(lockDir, { mode: DIRECTORY_MODE });
+  } catch (error) {
+    if (error.code === "EEXIST") return null;
+    throw error;
+  }
+  const owner = {
+    pid: process.pid,
+    nonce: randomBytes(16).toString("hex"),
+    createdAt: now
+  };
+  try {
+    writeFileSync(ownerPath(lockDir), `${JSON.stringify(owner)}
+`, {
+      encoding: "utf8",
+      mode: FILE_MODE,
+      flag: "wx"
+    });
+    return owner;
+  } catch (error) {
+    rmSync(lockDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function recoverStaleLock(lockDir, now, alive, initGraceMs) {
+  const owner = readOwner(lockDir);
+  if (owner) {
+    if (alive(owner.pid)) return false;
+    if (!sameOwner(readOwner(lockDir), owner)) return false;
+    rmSync(lockDir, { recursive: true, force: true });
+    return true;
+  }
+  try {
+    const before = statSync(lockDir).mtimeMs;
+    if (now - before < initGraceMs) return false;
+    if (readOwner(lockDir)) return false;
+    if (statSync(lockDir).mtimeMs !== before) return false;
+    rmSync(lockDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return true;
+  }
+}
+function abortError(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortError(signal);
+}
+async function defaultSleep(ms, signal) {
+  if (!signal) {
+    await new Promise((resolve2) => setTimeout(resolve2, ms));
+    return;
+  }
+  throwIfAborted(signal);
+  await new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function withFileLock(lockDir, operation, options = {}) {
+  mkdirSync(dirname(lockDir), { recursive: true, mode: DIRECTORY_MODE });
+  const nowMs = options.nowMs ?? Date.now;
+  const alive = options.processAlive ?? processIsAlive;
+  const deadline = nowMs() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  let owner = null;
+  while (!owner) {
+    throwIfAborted(options.signal);
+    const now = nowMs();
+    owner = tryTakeLock(lockDir, now);
+    if (owner) break;
+    recoverStaleLock(lockDir, now, alive, options.initGraceMs ?? DEFAULT_INIT_GRACE_MS);
+    if (now >= deadline) {
+      throw new Error(`timed out waiting for file lock ${lockDir}`);
+    }
+    if (options.sleep) {
+      await options.sleep(options.pollMs ?? DEFAULT_POLL_MS);
+      throwIfAborted(options.signal);
+    } else {
+      await defaultSleep(options.pollMs ?? DEFAULT_POLL_MS, options.signal);
+    }
+  }
+  try {
+    throwIfAborted(options.signal);
+    return await operation();
+  } finally {
+    if (sameOwner(readOwner(lockDir), owner)) {
+      rmSync(lockDir, { recursive: true, force: true });
+    }
+  }
+}
+
+// src/client.ts
+var CONFIG_DIR_MODE = 448;
+var CREDENTIAL_FILE_MODE = 384;
+var REFRESH_THRESHOLD_MS = 6e4;
+var DEFAULT_API_URL = "https://api.getprimitive.ai";
+function loadEnvFile() {
+  const envVars = {};
+  for (const file of [".env.local", ".env"]) {
+    const filePath = resolve(process.cwd(), file);
+    if (!existsSync2(filePath)) continue;
+    const content = readFileSync2(filePath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      envVars[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
+    }
+  }
+  return envVars;
+}
+var TOKEN_FILE_PATH = join2(homedir(), ".config", "prim", "token");
+var REFRESH_TOKEN_PATH = join2(dirname2(TOKEN_FILE_PATH), "refresh_token");
+var TOKEN_EXPIRES_PATH = join2(dirname2(TOKEN_FILE_PATH), "token_expires_at");
+var TERMINAL_REFRESH_PATH = join2(dirname2(TOKEN_FILE_PATH), "refresh_terminal");
+var CREDENTIAL_LOCK_PATH = join2(dirname2(TOKEN_FILE_PATH), "credentials.lock");
+function readTrimmed(path) {
+  try {
+    const value = readFileSync2(path, "utf8").trim();
+    return value || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveAuthCredential() {
+  if (process.env.PRIM_TOKEN) {
+    return { token: process.env.PRIM_TOKEN, source: "environment" };
+  }
+  const stored = readTrimmed(TOKEN_FILE_PATH);
+  if (stored) {
+    return { token: stored, source: "token_file" };
+  }
+  const envToken = loadEnvFile().PRIM_TOKEN;
+  return envToken ? { token: envToken, source: "env_file" } : void 0;
+}
+function getSiteUrl() {
+  if (process.env.PRIM_API_URL) return process.env.PRIM_API_URL;
+  return loadEnvFile().PRIM_API_URL ?? DEFAULT_API_URL;
+}
+function getJwtExpiry(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) return void 0;
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    return payload.exp ? payload.exp * 1e3 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function expiresAtFor(token, expiresIn) {
+  return expiresIn === void 0 ? getJwtExpiry(token) : Date.now() + expiresIn * 1e3;
+}
+function ensureConfigDirectory() {
+  const directory = dirname2(TOKEN_FILE_PATH);
+  mkdirSync2(directory, { recursive: true, mode: CONFIG_DIR_MODE });
+  chmodSync(directory, CONFIG_DIR_MODE);
+}
+function atomicWrite(path, content) {
+  ensureConfigDirectory();
+  const temp = join2(
+    dirname2(path),
+    `.${path.slice(dirname2(path).length + 1)}.tmp-${process.pid}-${randomBytes2(8).toString("hex")}`
+  );
+  try {
+    writeFileSync2(temp, content, {
+      encoding: "utf8",
+      mode: CREDENTIAL_FILE_MODE,
+      flag: "wx"
+    });
+    renameSync(temp, path);
+  } catch (error) {
+    rmSync2(temp, { force: true });
+    throw error;
+  }
+}
+function removeCredentialFile(path) {
+  if (!existsSync2(path)) return false;
+  rmSync2(path, { force: true });
+  return true;
+}
+function getTokenExpiresAt() {
+  const stored = readTrimmed(TOKEN_EXPIRES_PATH);
+  if (stored === void 0) return void 0;
+  const value = Number(stored);
+  return Number.isNaN(value) ? void 0 : value;
+}
+function isTokenExpiringSoon(credential) {
+  if (credential.source !== "token_file") return false;
+  const expiresAt = getTokenExpiresAt();
+  return expiresAt !== void 0 && Date.now() >= expiresAt - REFRESH_THRESHOLD_MS;
+}
+function refreshFingerprint(refreshToken2) {
+  return createHash("sha256").update(refreshToken2).digest("hex");
+}
+function terminalFingerprint() {
+  return readTrimmed(TERMINAL_REFRESH_PATH);
+}
+function writeTerminalFingerprint(refreshToken2) {
+  atomicWrite(TERMINAL_REFRESH_PATH, `${refreshFingerprint(refreshToken2)}
+`);
+}
+function clearTerminalFingerprint() {
+  removeCredentialFile(TERMINAL_REFRESH_PATH);
+}
+function isSessionEnded() {
+  if (resolveAuthCredential()?.source !== "token_file") return false;
+  const refreshToken2 = readTrimmed(REFRESH_TOKEN_PATH);
+  const ended = terminalFingerprint();
+  return Boolean(refreshToken2 && ended && refreshFingerprint(refreshToken2) === ended);
+}
+function withCredentialLock(operation, options = {}) {
+  return withFileLock(CREDENTIAL_LOCK_PATH, operation, options);
+}
+function commitCredentialsUnlocked(credentials) {
+  const accessToken = credentials.accessToken.trim();
+  const refreshToken2 = credentials.refreshToken.trim();
+  if (!accessToken || !refreshToken2) {
+    throw new Error("OAuth credentials require both access and refresh tokens");
+  }
+  atomicWrite(REFRESH_TOKEN_PATH, `${refreshToken2}
+`);
+  const expiresAt = expiresAtFor(accessToken, credentials.expiresIn);
+  if (expiresAt === void 0) removeCredentialFile(TOKEN_EXPIRES_PATH);
+  else atomicWrite(TOKEN_EXPIRES_PATH, `${expiresAt}
+`);
+  atomicWrite(TOKEN_FILE_PATH, `${accessToken}
+`);
+  clearTerminalFingerprint();
+  _cachedCredential = { token: accessToken, source: "token_file" };
+}
+async function commitCredentials(credentials, options = {}) {
+  await withCredentialLock(() => commitCredentialsUnlocked(credentials), options);
+}
+async function setStoredToken(token, options = {}) {
+  const value = token.trim();
+  if (!value) throw new Error("Token cannot be empty");
+  await withCredentialLock(() => {
+    removeCredentialFile(REFRESH_TOKEN_PATH);
+    removeCredentialFile(TOKEN_EXPIRES_PATH);
+    clearTerminalFingerprint();
+    atomicWrite(TOKEN_FILE_PATH, `${value}
+`);
+    _cachedCredential = { token: value, source: "token_file" };
+  }, options);
+}
+async function clearStoredCredentials(options = {}) {
+  const { beforeClear, ...lockOptions } = options;
+  return withCredentialLock(async () => {
+    const refreshToken2 = readTrimmed(REFRESH_TOKEN_PATH);
+    let callbackError;
+    try {
+      await beforeClear?.(refreshToken2);
+    } catch (error) {
+      callbackError = error;
+    }
+    let removed = false;
+    for (const path of [
+      TOKEN_FILE_PATH,
+      REFRESH_TOKEN_PATH,
+      TOKEN_EXPIRES_PATH,
+      TERMINAL_REFRESH_PATH
+    ]) {
+      removed = removeCredentialFile(path) || removed;
+    }
+    _cachedCredential = void 0;
+    if (callbackError) throw callbackError;
+    return removed;
+  }, lockOptions);
+}
+function isTerminalRefreshResponse(response, detail) {
+  if (detail.includes("invalid_grant") || detail.includes("Session has already ended")) return true;
+  try {
+    const error = JSON.parse(detail).error;
+    return error === "invalid_grant" || response.status === 401 && error === "Invalid or expired refresh token";
+  } catch {
+    return response.status === 401 && detail.includes("Invalid or expired refresh token");
+  }
+}
+function refreshDiagnostic(response, detail, quiet) {
+  if (quiet) return;
+  process.stderr.write(
+    `[prim] token refresh rejected by broker: ${response.status} ${response.statusText}${detail ? ` \u2014 ${detail}` : ""}
+`
+  );
+}
+async function performTokenRefresh(options = {}) {
+  const selected = resolveAuthCredential();
+  if (selected?.source !== "token_file") return void 0;
+  const startingGeneration = readTrimmed(REFRESH_TOKEN_PATH);
+  if (!startingGeneration || isSessionEnded()) return void 0;
+  return withCredentialLock(
+    async () => {
+      const currentCredential = resolveAuthCredential();
+      if (currentCredential?.source !== "token_file") return void 0;
+      const currentGeneration = readTrimmed(REFRESH_TOKEN_PATH);
+      if (!currentGeneration) return void 0;
+      if (currentGeneration !== startingGeneration) {
+        return currentCredential.token;
+      }
+      if (isSessionEnded()) return void 0;
+      const response = await fetch(`${getSiteUrl()}/mcp/broker/refresh`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refresh_token: currentGeneration }),
+        signal: options.signal
+      });
+      if (!response.ok) {
+        const detail = (await response.text().catch(() => "")).slice(0, 200);
+        if (isTerminalRefreshResponse(response, detail) && readTrimmed(REFRESH_TOKEN_PATH) === currentGeneration) {
+          writeTerminalFingerprint(currentGeneration);
+        }
+        refreshDiagnostic(response, detail, options.quiet);
+        const winner = resolveAuthCredential();
+        return readTrimmed(REFRESH_TOKEN_PATH) !== currentGeneration && winner?.source === "token_file" ? winner.token : void 0;
+      }
+      let data;
+      try {
+        data = await response.json();
+      } catch {
+        if (readTrimmed(REFRESH_TOKEN_PATH) === currentGeneration) {
+          writeTerminalFingerprint(currentGeneration);
+        }
+        return void 0;
+      }
+      const record = typeof data === "object" && data !== null && !Array.isArray(data) ? data : void 0;
+      const accessToken = typeof record?.access_token === "string" ? record.access_token.trim() : "";
+      const replacementRefreshToken = typeof record?.refresh_token === "string" ? record.refresh_token.trim() : "";
+      if (!(accessToken && replacementRefreshToken) || replacementRefreshToken === currentGeneration) {
+        if (readTrimmed(REFRESH_TOKEN_PATH) === currentGeneration) {
+          writeTerminalFingerprint(currentGeneration);
+        }
+        return void 0;
+      }
+      commitCredentialsUnlocked({
+        accessToken,
+        refreshToken: replacementRefreshToken,
+        expiresIn: typeof record?.expires_in === "number" && Number.isFinite(record.expires_in) ? record.expires_in : void 0
+      });
+      return accessToken;
+    },
+    { signal: options.signal }
+  );
+}
+var _refreshInFlight;
+function refreshToken(options = {}) {
+  if (_refreshInFlight) return _refreshInFlight;
+  const attempt = performTokenRefresh(options).then((token) => {
+    if (token) _cachedCredential = { token, source: "token_file" };
+    return token;
+  }).finally(() => {
+    if (_refreshInFlight === attempt) _refreshInFlight = void 0;
+  });
+  _refreshInFlight = attempt;
+  return attempt;
+}
+var HttpError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+  }
+};
+var _cachedCredential;
+function selectedCredential() {
+  const resolved = resolveAuthCredential();
+  if (!_cachedCredential || resolved?.token !== _cachedCredential.token || resolved?.source !== _cachedCredential.source) {
+    _cachedCredential = resolved;
+  }
+  return _cachedCredential;
+}
+async function request(method, path, body, options) {
+  const url = `${getSiteUrl()}${path}`;
+  let credential = selectedCredential();
+  let refreshAttempted = false;
+  if (credential && isTokenExpiringSoon(credential)) {
+    refreshAttempted = true;
+    const token = await refreshToken({
+      signal: options?.signal,
+      quiet: options?.quietRefresh
+    });
+    if (token) credential = { token, source: "token_file" };
+  }
+  const doFetch = (token) => {
+    const headers = { "Content-Type": "application/json" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    return fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: options?.signal
+    });
+  };
+  const tokenUsed = credential?.token;
+  let response = await doFetch(tokenUsed);
+  if (response.status === 401) {
+    const latest = resolveAuthCredential();
+    let retryToken = latest?.token !== tokenUsed ? latest?.token : void 0;
+    if (!retryToken && latest?.source === "token_file" && !refreshAttempted) {
+      refreshAttempted = true;
+      retryToken = await refreshToken({ signal: options?.signal, quiet: options?.quietRefresh });
+    }
+    if (retryToken) {
+      _cachedCredential = {
+        token: retryToken,
+        source: latest?.source === "token_file" ? "token_file" : latest?.source ?? "token_file"
+      };
+      response = await doFetch(retryToken);
+    }
+  }
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new HttpError(401, "Authentication expired. Run `prim auth login` to re-authenticate.");
+    }
+    const errorBody = await response.json().catch(() => null);
+    throw new HttpError(response.status, errorBody?.error ?? `HTTP ${response.status}`);
+  }
+  return response.json();
+}
+function getClient() {
+  return {
+    get: (path, options) => request("GET", path, void 0, options),
+    post: (path, body, options) => request("POST", path, body, options)
+  };
+}
+
+export {
+  withFileLock,
+  TOKEN_FILE_PATH,
+  REFRESH_TOKEN_PATH,
+  resolveAuthCredential,
+  getSiteUrl,
+  getTokenExpiresAt,
+  isSessionEnded,
+  commitCredentials,
+  setStoredToken,
+  clearStoredCredentials,
+  refreshToken,
+  HttpError,
+  getClient
+};

package/dist/{chunk-6MKLCOEH.js → chunk-Z4VI6TNX.js}

@@ -1,7 +1,7 @@
 import {
   getClient,
   getSiteUrl
-} from "./chunk-PI6LDYNJ.js";
+} from "./chunk-VQ2ZV2D5.js";
 import {
   daemonRequest
 } from "./chunk-UTKQTZHL.js";