@mrciphersmith/keryx 0.2.96 → 0.2.98

package/dist/cli.js

@@ -301,6 +301,13 @@ var init_provider_config = __esm(() => {
 // src/lib/shell-config.ts
 import { existsSync as existsSync2 } from "fs";
 import path3 from "path";
+function noteSavedCredentialEnv(keys) {
+  for (const key of keys)
+    savedCredentialKeys.add(key);
+}
+function savedCredentialEnvKeys() {
+  return savedCredentialKeys;
+}
 function shellConfigPath(dir) {
   return path3.join(keryxConfigDir(dir), "auth.json");
 }
@@ -383,10 +390,13 @@ function applySavedApiKeys(dir) {
       }
     }
   } catch {}
+  noteSavedCredentialEnv(applied);
   return applied;
 }
+var savedCredentialKeys;
 var init_shell_config = __esm(() => {
   init_config_dir();
+  savedCredentialKeys = new Set;
 });
 
 // src/lib/oauth/grants.ts
@@ -472,6 +482,7 @@ function applyOAuthAccessToEnv(dir) {
       applied.push(envKey);
     }
   }
+  noteSavedCredentialEnv(applied);
   return applied;
 }
 function grantFromTokens(method, tokens, now = Date.now) {
@@ -571,10 +582,61 @@ function customCompatProviders(dir) {
 function allOpenAiCompatProviders(dir) {
   return [...OPENAI_COMPAT_PROVIDERS, ...customCompatProviders(dir)];
 }
+function modelsErrorDetail(body) {
+  const text = body.slice(0, MODELS_ERROR_BODY_LIMIT).trim();
+  if (text.length === 0) {
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = undefined;
+  }
+  if (typeof parsed === "object" && parsed !== null) {
+    const record = parsed;
+    const error = record.error;
+    if (typeof error === "string" && error.length > 0) {
+      return error;
+    }
+    if (typeof error === "object" && error !== null) {
+      const message = error.message;
+      if (typeof message === "string" && message.length > 0) {
+        return message;
+      }
+    }
+    for (const field of ["detail", "message"]) {
+      const value = record[field];
+      if (typeof value === "string" && value.length > 0) {
+        return value;
+      }
+    }
+    return;
+  }
+  if (text.startsWith("<") || text.includes("<html")) {
+    return;
+  }
+  const firstLine = text.split(`
+`, 1)[0]?.trim();
+  return firstLine !== undefined && firstLine.length > 0 ? firstLine : undefined;
+}
+function modelsFailureLine(providerLabel, failure) {
+  const detail = "detail" in failure && failure.detail !== undefined ? ` \u2014 ${failure.detail}` : "";
+  switch (failure.kind) {
+    case "rejected":
+      return `${providerLabel} rejected the credential (HTTP ${failure.status})${detail}`;
+    case "http":
+      return `${providerLabel} could not list models (HTTP ${failure.status})${detail}`;
+    case "unreachable":
+      return `${providerLabel} could not be reached${detail}`;
+    case "empty":
+      return `${providerLabel} reports no models`;
+  }
+}
 async function fetchOpenAiCompatModelsDetailed(fetchFn, provider, apiKey, opts) {
   const url = `${provider.baseUrl.replace(/\/+$/, "")}${provider.modelsPath ?? DEFAULT_MODELS_PATH}`;
   const timeoutMs = opts?.timeoutMs ?? MODELS_FETCH_TIMEOUT_MS;
-  const fallback = { models: [], source: "fallback" };
+  const fallback = (failure) => ({ models: [], source: "fallback", failure });
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
@@ -584,7 +646,9 @@ async function fetchOpenAiCompatModelsDetailed(fetchFn, provider, apiKey, opts)
     }
     const res = await fetchFn(url, init);
     if (!res.ok) {
-      return fallback;
+      const detail = modelsErrorDetail(await res.text().catch(() => ""));
+      const kind = res.status === 401 || res.status === 403 ? "rejected" : "http";
+      return fallback({ kind, status: res.status, ...detail === undefined ? {} : { detail } });
     }
     const body = await res.json();
     const ids = Array.isArray(body?.data) ? body.data.map((m) => {
@@ -597,11 +661,13 @@ async function fetchOpenAiCompatModelsDetailed(fetchFn, provider, apiKey, opts)
       return "";
     }).filter((id) => id.length > 0) : [];
     if (ids.length === 0) {
-      return fallback;
+      return fallback({ kind: "empty" });
     }
     return { models: Array.from(new Set(ids)).sort(), source: "live" };
-  } catch {
-    return fallback;
+  } catch (err) {
+    const aborted = controller.signal.aborted;
+    const message = err instanceof Error ? err.message : String(err);
+    return fallback({ kind: "unreachable", detail: aborted ? `timed out after ${timeoutMs}ms` : message });
   } finally {
     clearTimeout(timer);
   }
@@ -821,7 +887,7 @@ optimisation. With no second family configured it reports single-family review
 with a stated reason and exits 0 \u2014 that is a normal configuration, not an error.
 `);
 }
-var DEFAULT_MODELS_PATH = "/v1/models", OPENAI_COMPAT_PROVIDERS, MODELS_FETCH_TIMEOUT_MS = 1e4, BALANCE_FETCH_TIMEOUT_MS = 8000;
+var DEFAULT_MODELS_PATH = "/v1/models", OPENAI_COMPAT_PROVIDERS, MODELS_FETCH_TIMEOUT_MS = 1e4, MODELS_ERROR_BODY_LIMIT = 4096, BALANCE_FETCH_TIMEOUT_MS = 8000;
 var init_providers = __esm(() => {
   init_provider_config();
   init_grants();
@@ -13250,7 +13316,7 @@ var init_staleness = __esm(() => {
 });
 
 // src/wiki/staleness.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { readFile as readFile29 } from "fs/promises";
 import path68 from "path";
 async function computePageNodeHash(cwd, keyFiles, graph) {
@@ -13261,7 +13327,7 @@ async function computePageNodeHash(cwd, keyFiles, graph) {
     if (knownPaths.has(file)) {
       try {
         const content = await readFile29(path68.join(cwd, file), "utf8");
-        digest = createHash6("sha256").update(content).digest("hex");
+        digest = createHash7("sha256").update(content).digest("hex");
       } catch {
         digest = "<missing>";
       }
@@ -13271,7 +13337,7 @@ async function computePageNodeHash(cwd, keyFiles, graph) {
   entries.sort((a, b) => a.path.localeCompare(b.path));
   const combined = entries.map((entry) => `${entry.path}:${entry.digest}`).join(`
 `);
-  return createHash6("sha256").update(combined).digest("hex");
+  return createHash7("sha256").update(combined).digest("hex");
 }
 function isPageUnchangedSinceLastEnrich(pagePath, currentHash, completedNodeHashes) {
   const previous = completedNodeHashes?.[pagePath];
@@ -13325,7 +13391,7 @@ var init_staleness2 = __esm(() => {
 });
 
 // src/wiki/provenance.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 function parseProvenance(content) {
   const verifiedAt = singleLineField(content, "VerifiedAt");
   const verifiedScope = singleLineField(content, "VerifiedScope");
@@ -13337,7 +13403,7 @@ function parseProvenance(content) {
 }
 async function computeVerifiedScope(cwd, describePaths, graph) {
   if (describePaths.length === 0) {
-    return `sha256:${createHash7("sha256").update("<empty-describe-set>").digest("hex")}`;
+    return `sha256:${createHash8("sha256").update("<empty-describe-set>").digest("hex")}`;
   }
   return `sha256:${await computePageNodeHash(cwd, describePaths, graph)}`;
 }
@@ -13542,7 +13608,7 @@ var init_collect = __esm(() => {
 });
 
 // src/wiki/section-marker.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import { readFile as readFile31 } from "fs/promises";
 function parseMarkers(content) {
   const lines = content.split(`
@@ -13673,7 +13739,7 @@ function proposeSectionId(headingText, fallbackOrdinal) {
   return slug.length > 0 && ID_RE.test(slug) ? slug : `section-${fallbackOrdinal}`;
 }
 function digest(value) {
-  return createHash8("sha256").update(value).digest("hex");
+  return createHash9("sha256").update(value).digest("hex");
 }
 function planPageMigration(relativePath, content) {
   const lines = content.split(`
@@ -13813,7 +13879,7 @@ var init_section_marker = __esm(() => {
 });
 
 // src/wiki/section-index.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 function resolveWikiPageIdentity(relativePath, content) {
   const markers = parseMarkers(content);
   if (markers.page) {
@@ -13905,7 +13971,7 @@ function detectLanguage(text) {
   return ru ? "ru" : "en";
 }
 function digestOf2(value) {
-  return createHash9("sha256").update(value).digest("hex");
+  return createHash10("sha256").update(value).digest("hex");
 }
 function fieldFromLines(lines, name) {
   const pattern = new RegExp(`^${name}:\\s*(.+)$`, "i");
@@ -14436,7 +14502,7 @@ async function runRuntimeEmbedder(dep, asset, texts, dims) {
 var MEMORY_EMBEDDING_ID = "memory.embedding", DEFAULT_EMBED_DIMS = 96;
 
 // src/memory/embedding/index.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { mkdir as mkdir21, readFile as readFile32, writeFile as writeFile24 } from "fs/promises";
 import path70 from "path";
 function embeddingsDir(cwd) {
@@ -14449,7 +14515,7 @@ ${entry.tags.join(" ")}
 ${entry.details}`.trim();
 }
 function contentHash(text) {
-  return createHash10("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash11("sha256").update(text).digest("hex").slice(0, 16);
 }
 async function buildEmbeddingIndex(cwd, entries, embedder, model, now) {
   const sorted = [...entries].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
@@ -15181,7 +15247,7 @@ var init_backlinks = __esm(() => {
 });
 
 // src/ctx/assembly.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { mkdir as mkdir22, rename as rename2, writeFile as writeFile25 } from "fs/promises";
 import path73 from "path";
 function assembleContext(input) {
@@ -15236,7 +15302,7 @@ async function recordContextAssembly(input) {
   await rename2(temporary, target);
 }
 function traceIdFor(correlationId, outcome) {
-  return createHash11("sha256").update(`${outcome}\x00${correlationId}`).digest("hex").slice(0, 24);
+  return createHash12("sha256").update(`${outcome}\x00${correlationId}`).digest("hex").slice(0, 24);
 }
 function traceRefFor(traceId) {
   return `./.metaproject/context-operations/traces/${traceId}.json`;
@@ -16095,9 +16161,9 @@ var init_evidence = __esm(() => {
 });
 
 // src/wiki/managed-block.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 function hashBlockContent(content) {
-  return createHash12("sha256").update(content.trim()).digest("hex");
+  return createHash13("sha256").update(content.trim()).digest("hex");
 }
 function findManagedBlock(content) {
   const lines = content.split(`
@@ -16348,7 +16414,7 @@ var init_template_structure = __esm(() => {
 
 // src/wiki/service.ts
 import { spawn as spawn2 } from "child_process";
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { mkdir as mkdir23, readFile as readFile35, readdir as readdir7, rm as rm6, writeFile as writeFile26 } from "fs/promises";
 import path75 from "path";
 function wikiRootPath2(cwd) {
@@ -16650,7 +16716,7 @@ function resolveEvidenceScope(cwd, override) {
   const absolute = path75.resolve(cwd);
   return {
     projectId: override?.projectId ?? (path75.basename(absolute) || "project"),
-    checkoutId: override?.checkoutId ?? `checkout:${createHash13("sha256").update(absolute).digest("hex").slice(0, 16)}`,
+    checkoutId: override?.checkoutId ?? `checkout:${createHash14("sha256").update(absolute).digest("hex").slice(0, 16)}`,
     ...override?.workspaceId ? { workspaceId: override.workspaceId } : {},
     ...override?.taskId ? { taskId: override.taskId } : {}
   };
@@ -17456,7 +17522,7 @@ var init_service3 = __esm(() => {
 });
 
 // src/gdgraph/wiki-layer.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 import { mkdir as mkdir24, stat as stat8, writeFile as writeFile27 } from "fs/promises";
 import path76 from "path";
 function storageDir(projectRoot) {
@@ -17513,7 +17579,7 @@ function buildWikiLayer(input) {
 function computeFingerprints(fileRecords, mtimes) {
   return fileRecords.map((record) => ({
     path: record.path,
-    contentHash: createHash14("sha256").update(record.content).digest("hex"),
+    contentHash: createHash15("sha256").update(record.content).digest("hex"),
     mtimeMs: mtimes.get(record.path) ?? 0
   })).sort((a, b) => a.path.localeCompare(b.path));
 }
@@ -22153,7 +22219,7 @@ var init_slate = __esm(() => {
 });
 
 // src/flow/store.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { appendFile as appendFile3, mkdir as mkdir30, readFile as readFile48, readdir as readdir9 } from "fs/promises";
 import path90 from "path";
 function flowsRoot(cwd) {
@@ -22325,7 +22391,7 @@ async function acChecksum(cwd, dir) {
 `).split(`
 `).map((line) => line.trimEnd()).join(`
 `).trim();
-  return `sha256:${createHash15("sha256").update(normalized).digest("hex")}`;
+  return `sha256:${createHash16("sha256").update(normalized).digest("hex")}`;
 }
 async function assertAcIntact(cwd, dir, flow) {
   if (!flow.acChecksum) {
@@ -22365,7 +22431,7 @@ var init_slate_course = __esm(() => {
 });
 
 // src/sac/trusted-wrap-up.ts
-import { createHash as createHash16, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash17, randomUUID as randomUUID7 } from "crypto";
 function createTrustedWrapUpAuthority(input) {
   const now = input.now ?? (() => new Date);
   return Object.freeze({
@@ -22397,7 +22463,7 @@ function createTrustedWrapUpAuthority(input) {
   });
 }
 function digest2(value) {
-  return createHash16("sha256").update(value).digest("hex");
+  return createHash17("sha256").update(value).digest("hex");
 }
 var issued, consumed;
 var init_trusted_wrap_up = __esm(() => {
@@ -22407,7 +22473,7 @@ var init_trusted_wrap_up = __esm(() => {
 
 // src/sac/index.ts
 import { access as access2, readFile as readFile49, realpath as realpath5 } from "fs/promises";
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import path91 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 async function resolveSacNormativeSchemaPath(fileName, searchFrom = [fileURLToPath5(new URL(".", import.meta.url)), process.cwd()]) {
@@ -23085,7 +23151,7 @@ async function validateSacContract(input) {
   return { valid: errors.length === 0, errors };
 }
 function hashSacRecord(value) {
-  return createHash17("sha256").update(typeof value === "string" ? value : JSON.stringify(value)).digest("hex");
+  return createHash18("sha256").update(typeof value === "string" ? value : JSON.stringify(value)).digest("hex");
 }
 async function resolveWorkspaceReference(input) {
   if (!workspacePathPattern.test(input.uri) || path91.isAbsolute(input.uri) || /^[a-z][a-z0-9+.-]*:/i.test(input.uri) || input.uri.includes("\\"))
@@ -23196,7 +23262,7 @@ var init_secure_resource_read = __esm(() => {
 
 // src/sac/workspace-service.ts
 import { mkdir as mkdir31, readdir as readdir10, readFile as readFile50 } from "fs/promises";
-import { createHash as createHash18, randomUUID as randomUUID8 } from "crypto";
+import { createHash as createHash19, randomUUID as randomUUID8 } from "crypto";
 import path93 from "path";
 
 class WorkspaceService {
@@ -23486,7 +23552,7 @@ class WorkspaceService {
   }
   contentDigest(absolutePath) {
     try {
-      return createHash18("sha256").update(readWorkspaceFileNoFollow(this.root, absolutePath)).digest("hex");
+      return createHash19("sha256").update(readWorkspaceFileNoFollow(this.root, absolutePath)).digest("hex");
     } catch {
       return;
     }
@@ -23618,7 +23684,7 @@ var init_workspace_service = __esm(() => {
 });
 
 // src/sac/guarded-owner-writer.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 function createGuardedOwnerWriter(input) {
   const recoverReceipt = input.recoverReceipt;
   return Object.freeze({
@@ -23643,7 +23709,7 @@ function receiptMatchesIntent(input) {
   return binding.owner === input.owner && binding.bindingHash === bindingHash(input.owner, input.intent) && binding.intentRef === input.intent.intentRef && binding.proposalId === input.intent.proposalId && binding.proposalRevision === input.intent.proposalRevision && binding.workspaceId === input.intent.workspaceId && binding.correlationId === input.intent.correlationId && binding.idempotencyKey === input.intent.idempotencyKey && binding.reviewerSubject === input.intent.reviewerSubject && binding.reviewerAuthority === input.intent.reviewerAuthority && binding.policyRevision === input.intent.policyRevision;
 }
 function bindingHash(owner, intent) {
-  return createHash19("sha256").update(JSON.stringify({ owner, ...intent })).digest("hex");
+  return createHash20("sha256").update(JSON.stringify({ owner, ...intent })).digest("hex");
 }
 var init_guarded_owner_writer = () => {};
 
@@ -24296,7 +24362,7 @@ var init_wrap_up_evidence = __esm(() => {
 });
 
 // src/sac/session-wrap-up.ts
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 import { mkdir as mkdir32, writeFile as writeFile33 } from "fs/promises";
 import path95 from "path";
 function sessionEvidenceRef(workspaceId, sessionId) {
@@ -24362,12 +24428,12 @@ async function resolveSessionWrapUp(input) {
     await writeFile33(path95.join(input.cwd, noticeRelPath), floor.notice, "utf8");
   const observedAt = now().toISOString();
   const evidence = [
-    { kind: "wrap-up", uri: `./${wrapUpRelPath}`, revision: createHash20("sha256").update(safeWrapUp.content).digest("hex"), observedAt },
-    { kind: diffKind, uri: `./${diffRelPath}`, revision: createHash20("sha256").update(safeDiff.content).digest("hex"), observedAt },
-    { kind: "session", uri: `./${relPath}`, revision: createHash20("sha256").update(safeSession.content).digest("hex"), observedAt }
+    { kind: "wrap-up", uri: `./${wrapUpRelPath}`, revision: createHash21("sha256").update(safeWrapUp.content).digest("hex"), observedAt },
+    { kind: diffKind, uri: `./${diffRelPath}`, revision: createHash21("sha256").update(safeDiff.content).digest("hex"), observedAt },
+    { kind: "session", uri: `./${relPath}`, revision: createHash21("sha256").update(safeSession.content).digest("hex"), observedAt }
   ];
   if (floor.notice !== undefined) {
-    evidence.push({ kind: REDACTION_NOTICE_KIND, uri: `./${noticeRelPath}`, revision: createHash20("sha256").update(floor.notice).digest("hex"), observedAt });
+    evidence.push({ kind: REDACTION_NOTICE_KIND, uri: `./${noticeRelPath}`, revision: createHash21("sha256").update(floor.notice).digest("hex"), observedAt });
   }
   return {
     workspaceId: input.workspaceId,
@@ -24393,7 +24459,7 @@ var init_session_wrap_up = __esm(() => {
 });
 
 // src/sac/review-confirm-token.ts
-import { createHash as createHash21, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash22, randomBytes as randomBytes3 } from "crypto";
 import { readFile as readFile51 } from "fs/promises";
 import path96 from "path";
 function confirmTokenPath(cwd, workspaceId, proposalId) {
@@ -24403,7 +24469,7 @@ function confirmReceiptPath(cwd, workspaceId, proposalId, idempotencyKey) {
   return path96.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.${sha256(idempotencyKey)}.confirm-receipt.json`);
 }
 function sha256(text) {
-  return createHash21("sha256").update(text).digest("hex");
+  return createHash22("sha256").update(text).digest("hex");
 }
 async function mintConfirmToken(cwd, workspaceId, proposalId, deps = {}) {
   const now = deps.now ?? (() => new Date);
@@ -24564,7 +24630,7 @@ function round(value) {
 var init_dedup = () => {};
 
 // src/sac/proposal-evidence.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import { readFile as readFile52, rm as rm8 } from "fs/promises";
 import path97 from "path";
 function proposalPath(cwd, workspaceId, proposalId) {
@@ -24592,7 +24658,7 @@ async function readVerifiedProposalEvidence(cwd, workspaceId, proposalId) {
   } catch {
     return { ok: false, code: "evidence_file_unreadable" };
   }
-  if (createHash22("sha256").update(content).digest("hex") !== evidence.revision) {
+  if (createHash23("sha256").update(content).digest("hex") !== evidence.revision) {
     return { ok: false, code: "evidence_revision_mismatch" };
   }
   return { proposal, evidence, content };
@@ -24603,7 +24669,7 @@ async function readSidecarNote(cwd, workspaceId, proposalId) {
   });
 }
 function digestOf3(content) {
-  return createHash22("sha256").update(content).digest("hex");
+  return createHash23("sha256").update(content).digest("hex");
 }
 async function readTargetVersion(absolutePath) {
   try {
@@ -25295,7 +25361,7 @@ var init_wiki_owner_writer = __esm(() => {
 });
 
 // src/gdskills/project-skills.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 import { homedir as homedir3 } from "os";
 import { mkdir as mkdir34, readFile as readFile57, stat as stat11 } from "fs/promises";
 import path101 from "path";
@@ -25363,7 +25429,7 @@ function resolveOriginPath(ref, projectRoot) {
   return path101.resolve(projectRoot, trimmed);
 }
 function hashOriginContent(content) {
-  return `sha256:${createHash23("sha256").update(content).digest("hex")}`;
+  return `sha256:${createHash24("sha256").update(content).digest("hex")}`;
 }
 async function readSkillOrigin(projectRoot, ref, now = () => new Date) {
   const resolved = resolveOriginPath(ref, projectRoot);
@@ -25623,7 +25689,7 @@ ${filesToRead}
 
 ## Verification
 
-- Current state: not verified.
+- Verification status: see \`verification.md\` (written by \`keryx skills verify\`).
 - Run: \`keryx skills verify ${moduleName}/${skillName}\`
 `;
 }
@@ -25874,7 +25940,7 @@ var init_skill_owner_writer = __esm(() => {
 });
 
 // src/sac/proposal-lifecycle.ts
-import { createHash as createHash24, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash25, randomUUID as randomUUID11 } from "crypto";
 import { appendFile as appendFile4, mkdir as mkdir35, readdir as readdir12, readFile as readFile59 } from "fs/promises";
 import path102 from "path";
 function supportsOwnerWriteRecovery(writer) {
@@ -26311,7 +26377,7 @@ class ProposalLifecycleService {
   }
 }
 function hash(value) {
-  return createHash24("sha256").update(value).digest("hex");
+  return createHash25("sha256").update(value).digest("hex");
 }
 function recordHash(value) {
   return hash(JSON.stringify(value));
@@ -26535,7 +26601,7 @@ var init_workspace_resolve = __esm(() => {
 });
 
 // src/sac/machine-wrap-up.ts
-import { createHash as createHash25, randomUUID as randomUUID13 } from "crypto";
+import { createHash as createHash26, randomUUID as randomUUID13 } from "crypto";
 import { mkdir as mkdir36 } from "fs/promises";
 import path103 from "path";
 function groupSeedsByKind(slate) {
@@ -26550,7 +26616,7 @@ function groupSeedsByKind(slate) {
   return map;
 }
 function sha2562(value) {
-  return createHash25("sha256").update(value).digest("hex");
+  return createHash26("sha256").update(value).digest("hex");
 }
 function mechanicalSummary(diff, course) {
   return `Mechanical wrap-up summary (model turn unavailable or timed out):
@@ -28496,9 +28562,9 @@ var init_orchestrate = __esm(() => {
 });
 
 // src/harness/policy/profiles.ts
-import { createHash as createHash26 } from "crypto";
+import { createHash as createHash27 } from "crypto";
 function sha256Hex2(input) {
-  return createHash26("sha256").update(input, "utf8").digest("hex");
+  return createHash27("sha256").update(input, "utf8").digest("hex");
 }
 function readOnlyReview() {
   return {
@@ -29718,7 +29784,7 @@ var init_supersede = __esm(() => {
 });
 
 // src/memory/service.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 import { mkdir as mkdir38, readFile as readFile63, writeFile as writeFile36 } from "fs/promises";
 import path110 from "path";
 function dataRoot(cwd) {
@@ -29775,7 +29841,7 @@ function createMemoryService() {
       const indexPath = path110.join(indexDir, "index.json");
       await writeFile36(indexPath, `${JSON.stringify({
         catalogVersion: 1,
-        sourceFingerprint: createHash27("sha256").update(JSON.stringify(entries.map((e) => ({
+        sourceFingerprint: createHash28("sha256").update(JSON.stringify(entries.map((e) => ({
           path: e.relativePath,
           content: [e.title, e.type, e.status, e.confidence, e.summary, e.details, e.tags, e.scopes, e.validFrom, e.validTo].join("\x00")
         })))).digest("hex"),
@@ -35918,7 +35984,7 @@ var init_github = __esm(() => {
 });
 
 // src/harness/tool/metaproject-adapter.ts
-import { lstat as lstat3, readdir as readdir17, readFile as readFile74, realpath as realpath6, stat as stat14 } from "fs/promises";
+import { lstat as lstat4, readdir as readdir17, readFile as readFile74, realpath as realpath6, stat as stat14 } from "fs/promises";
 import { isAbsolute, join, relative, resolve } from "path";
 function isMissingExecutable(cause) {
   const message = cause instanceof Error ? cause.message : String(cause);
@@ -35974,12 +36040,16 @@ function flattenAttribution(attribution) {
 }
 async function projectRemovalTrail(cwd, query) {
   const lookup = searchRemovals(await loadDeletionTrail(cwd), query);
+  if (lookup.verdict === "trail-absent") {
+    return { verdict: "trail-absent", summary: TRAIL_ABSENT_SUMMARY };
+  }
+  const summary = clipAutomaticRecallText(lookup.reason.split(`${cwd}/`).join(""), MAX_REMOVAL_SUMMARY_BYTES);
   if (lookup.verdict !== "recorded-removed") {
-    return { verdict: lookup.verdict, summary: clipAutomaticRecallText(lookup.reason, MAX_REMOVAL_SUMMARY_BYTES) };
+    return { verdict: lookup.verdict, summary };
   }
   return {
     verdict: "recorded-removed",
-    summary: clipAutomaticRecallText(lookup.reason, MAX_REMOVAL_SUMMARY_BYTES),
+    summary,
     totalRemovals: lookup.occurrences.length,
     removals: lookup.occurrences.slice(0, MAX_REMOVAL_RECORDS).map((item) => ({
       layer: item.layer,
@@ -36049,7 +36119,7 @@ async function parseCatalogSummaries(cwd) {
 async function walkSkillCatalog(cwd) {
   const root = join(cwd, ".metaproject", "skills", "gdskills");
   const entries = [];
-  const rootInfo = await lstat3(root).catch(() => null);
+  const rootInfo = await lstat4(root).catch(() => null);
   if (!rootInfo || !rootInfo.isDirectory() || rootInfo.isSymbolicLink())
     return entries;
   const rootReal = await realpath6(root).catch(() => null);
@@ -36735,7 +36805,7 @@ function createMetaprojectAdapter(cwd, overrides = {}) {
     }
   };
 }
-var DEFAULT_DEPS, MAX_EXCERPT_BYTES = 400, MAX_QUERY_BYTES2 = 4096, UNKNOWN_PROVENANCE = "unknown", MAX_SEARCH_OUTPUT_BYTES = 20000, SEARCH_CODE_RG_MISSING, MAX_REMOVAL_RECORDS = 5, MAX_REMOVAL_SUMMARY_BYTES = 1600;
+var DEFAULT_DEPS, MAX_EXCERPT_BYTES = 400, MAX_QUERY_BYTES2 = 4096, UNKNOWN_PROVENANCE = "unknown", MAX_SEARCH_OUTPUT_BYTES = 20000, SEARCH_CODE_RG_MISSING, MAX_REMOVAL_RECORDS = 5, MAX_REMOVAL_SUMMARY_BYTES = 1600, TRAIL_ABSENT_SUMMARY = 'no removal has ever been recorded in this project (it has no deletion trail) \u2014 not the claim "this never existed".';
 var init_metaproject_adapter = __esm(() => {
   init_wiki_freshness();
   init_fs();
@@ -38150,7 +38220,7 @@ var init_metaproject_operations = __esm(() => {
 });
 
 // src/wiki/deep-enrich.ts
-import { randomUUID as randomUUID15, createHash as createHash28 } from "crypto";
+import { randomUUID as randomUUID15, createHash as createHash29 } from "crypto";
 function composeAbortSignals(external, timeout) {
   if (external === undefined) {
     return { signal: timeout, dispose: () => {} };
@@ -38181,7 +38251,7 @@ function errorMessage2(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
 function sha256Hex3(text) {
-  return createHash28("sha256").update(text).digest("hex");
+  return createHash29("sha256").update(text).digest("hex");
 }
 function buildDeepEnrichTools(port) {
   const deepOps = METAPROJECT_OPERATIONS.filter((op) => DEEP_ENRICH_OPS.includes(op.name));
@@ -40253,9 +40323,9 @@ var init_memory = __esm(() => {
 
 // src/lib/serve-config.ts
 import { existsSync as existsSync25 } from "fs";
-import path173 from "path";
+import path174 from "path";
 function serveConfigPath(dir) {
-  return path173.join(keryxConfigDir(dir), "serve.json");
+  return path174.join(keryxConfigDir(dir), "serve.json");
 }
 function parseIpv4(value) {
   const parts = value.split(".");
@@ -41172,15 +41242,43 @@ async function refreshProviderGrant(provider, http, dir) {
   saveOAuthGrant(provider, next, dir);
   return next;
 }
+async function refreshSavedGrants(http, dir, providers = SESSION_REFRESHED_GRANTS) {
+  const warnings = [];
+  const now = http.now ?? Date.now;
+  for (const provider of providers) {
+    if (!SESSION_REFRESHED_GRANTS.includes(provider))
+      continue;
+    const grant = loadOAuthGrant(provider, dir);
+    if (grant === undefined)
+      continue;
+    if (grant.refresh === undefined || grant.refresh.length === 0) {
+      if (grant.expires !== undefined && grant.expires <= now()) {
+        warnings.push(`${provider}: the saved login has expired and holds no refresh token. Run \`keryx auth login ${provider}\`.`);
+      }
+      continue;
+    }
+    if (!grantNeedsRefresh(grant, http.now))
+      continue;
+    try {
+      await refreshProviderGrant(provider, http, dir);
+    } catch (cause) {
+      const reason = cause instanceof Error ? cause.message : String(cause);
+      warnings.push(`${provider}: the saved login is expiring or expired and could not be refreshed (${reason}). ` + `Run \`keryx auth login ${provider}\`.`);
+    }
+  }
+  return warnings;
+}
 function logoutProvider(provider, dir) {
   deleteOAuthGrant(provider, dir);
 }
+var SESSION_REFRESHED_GRANTS;
 var init_login = __esm(() => {
   init_catalog();
   init_copilot();
   init_device_code();
   init_grants();
   init_openai_codex();
+  SESSION_REFRESHED_GRANTS = ["grok", "github-copilot"];
 });
 
 // src/cli.ts
@@ -41193,7 +41291,7 @@ import {
   chmod as chmod2,
   mkdir as mkdir14,
   readFile as readFile23,
-  unlink,
+  unlink as unlink2,
   writeFile as writeFile16
 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
@@ -42784,7 +42882,7 @@ var BUNDLED_GDSKILLS = [
     "If the request asks to create, run, resume, track, or finish a managed flow and Task Manager is enabled, route implementation work to `gdskills/orchestration/flow-orchestrator/SKILL.md` before `job-orchestrator`.",
     "Prefer project-local skills and module manifests before broad raw file search.",
     "Route to the narrowest applicable skill and record unavailable modules explicitly."
-  ], ["any repository task", "route context", "which skill should be used", "ordinary product-development request", "agent should decide tools"]),
+  ], ["any repository task", "route context", "which skill should be used", "ordinary product-development request", "agent should decide tools"], "Use when a request's routing to a Metaproject module, skill, or project-skill is unclear and needs deciding before any work starts. NOT for: picking between gdgraph, gdctx, gdwiki, memory, and health once the module is already known (see context-router)."),
   skill("context-router", "core", ["minimal", "recommended", "full"], "Choose between gdgraph, gdctx, gdwiki, memory, health, and project-skills before raw file reads.", [
     "Start from the user's goal, not from command names.",
     "Use gdgraph for file relationships and affected context.",
@@ -42794,13 +42892,13 @@ var BUNDLED_GDSKILLS = [
     "Use health for normalized quality and gate status; use testing for test selection and test context.",
     "Prefer MCP tools/resources for these capabilities when connected; otherwise use the matching skill and CLI command.",
     "Use project-skills for known modules, components, stores, services, and domain entities."
-  ], ["find files", "understand code", "collect context", "what should I inspect", "agent routing"]),
+  ], ["find files", "understand code", "collect context", "what should I inspect", "agent routing"], "Use when the Metaproject module or skill is already known and the next step is picking gdgraph, gdctx, gdwiki, memory, health, or project-skills before reading raw files. NOT for: deciding which top-level skill or module should handle a request (see metaproject-router)."),
   skill("entity-skill-router", "core", ["minimal", "recommended", "full"], "Select relevant project-skills for known modules, components, stores, services, and domain entities.", [
     "Check `.metaproject/project-skills` for matching module/entity skills.",
     "Use gdgraph affected context to find nearby entities when the target is a file.",
     "Load only the matching project-skill and directly referenced files.",
     "If no project-skill exists, suggest creating one with `keryx skills generate`."
-  ], ["project skill", "component pattern", "module-specific work"]),
+  ], ["project skill", "component pattern", "module-specific work"], "Use when a known module, component, store, service, or domain entity already has a project-skill that should be loaded instead of searched for from scratch. NOT for: scaffolding a project-skill that does not exist yet (see entity-skill-creator), checking one against current code (see entity-skill-verifier), or applying a finding to one (see entity-skill-learner)."),
   skill("entity-skill-creator", "core", ["minimal", "recommended", "full"], "Create canonical project-skills from a path, symbol, wiki page, module, component, store, service, or domain entity.", [
     "Normalize the target into module, entity, files, symbols, and wiki references.",
     "Collect evidence from gdgraph, gdctx, gdwiki, health, and memory when available.",
@@ -42809,7 +42907,7 @@ var BUNDLED_GDSKILLS = [
     "To refresh a project-skill from its Origin (or a new file), run `keryx skills update <module>/<name> [--from <origin>]`.",
     "Run `keryx skills route <target>` and `keryx skills inspect <module>/<skill-name>` to confirm registration and routing.",
     "Run `keryx skills verify <module>/<skill-name>` and finish with `keryx skills status`."
-  ], ["create skill", "generate project skill", "new entity skill", "\u0441\u043E\u0437\u0434\u0430\u0439 \u0441\u043A\u0438\u043B", "\u0441\u043E\u0437\u0434\u0430\u0439 \u0441\u043A\u0438\u043B\u043B \u0434\u043B\u044F <path>", "import skill", "import skills from", "update skill from", "\u043F\u043E\u0434\u0442\u044F\u043D\u0438 \u0441\u043A\u0438\u043B\u044B", "\u043E\u0431\u043D\u043E\u0432\u0438 \u0441\u043A\u0438\u043B"]),
+  ], ["create skill", "generate project skill", "new entity skill", "\u0441\u043E\u0437\u0434\u0430\u0439 \u0441\u043A\u0438\u043B", "\u0441\u043E\u0437\u0434\u0430\u0439 \u0441\u043A\u0438\u043B\u043B \u0434\u043B\u044F <path>", "import skill", "import skills from", "update skill from", "\u043F\u043E\u0434\u0442\u044F\u043D\u0438 \u0441\u043A\u0438\u043B\u044B", "\u043E\u0431\u043D\u043E\u0432\u0438 \u0441\u043A\u0438\u043B"], "Use when no project-skill exists yet for a target module, component, store, service, or domain entity, or one needs scaffolding, importing, or refreshing from its origin. NOT for: loading a project-skill that already exists (see entity-skill-router)."),
   skill("reviewer-skill-creator", "core", ["recommended", "full"], "Create a project-local reviewer for review-orchestrator from a rules file, review profile, or written team standard.", [
     "Read the source in full and sort it into method, convention, and persona before writing anything.",
     "Scaffold with `keryx skills create <target> --module review --name <reviewer> --note <gist> --origin <source file>`; the target is a routing key, the note is the prose.",
@@ -42819,18 +42917,18 @@ var BUNDLED_GDSKILLS = [
     "Confirm with `keryx review reviewers` \u2014 creating files is not registration, and registration is not discovery.",
     "For existing SKILL.md packages, run `keryx skills import --from <dir|file|https-url> --module <module>`; `keryx review import` is the review-shaped alias with the review-vantage-* prefix."
   ], ["create a reviewer", "new reviewer for review-orchestrator", "make a reviewer from this profile", "\u0441\u043E\u0437\u0434\u0430\u0439 \u0440\u0435\u0432\u044C\u044E\u0435\u0440\u0430", "\u0441\u043E\u0437\u0434\u0430\u0439 \u043D\u043E\u0432\u043E\u0433\u043E \u0440\u0435\u0432\u044C\u044E\u0435\u0440\u0430 \u043D\u0430 \u043E\u0441\u043D\u043E\u0432\u0430\u043D\u0438\u0438", "import vantage reviewers", "import overlay reviewers"]),
-  skill("entity-skill-verifier", "core", ["minimal", "recommended", "full"], "Verify project-skills against current code, graph, wiki, health, memory, tests, and review lessons.", [
-    "Resolve candidate skills through ownership and gdgraph affected context.",
-    "Compare skill claims with current code, wiki decisions, health reports, and memory.",
-    "Classify each skill as fresh, stale, needs-review, or blocked.",
-    "Write a verification report and only update generated sections when policy allows it."
-  ], ["verify skill", "skill-verify-skill", "stale skill"]),
+  skill("entity-skill-verifier", "core", ["minimal", "recommended", "full"], "Run `keryx skills verify` to check a project-skill's required files, SKILL.md metadata, manifest registration, target-path existence, and evidence artifacts (gdgraph, gdctx, validated gdwiki, Code Health, canonical accepted memory), then classify it as fresh, needs-review, stale, or blocked. The command does not read the skill's prose or compare it against current code \u2014 that comparison is a manual agent step.", [
+    "Resolve the target project-skill through gdgraph affected context or `keryx skills route <target>`.",
+    "Run `keryx skills verify <module>/<skill-name>` (`--dry-run` previews without writing).",
+    "The command checks required files, SKILL.md metadata (version, target, last-verified), manifest registration, target path existence, and evidence artifacts for gdgraph, gdctx, gdwiki, Code Health, and memory consultation, then classifies the skill fresh, needs-review, stale, or blocked and writes the JSON report plus `verification.md`.",
+    "Manually read the skill and the code, wiki, and health evidence it points at to check its claims \u2014 the command does not do this comparison \u2014 then route stale or blocked findings to entity-skill-learner."
+  ], ["verify skill", "skill-verify-skill", "stale skill"], "Use when an existing project-skill needs classifying \u2014 fresh, needs-review, stale, or blocked \u2014 from its required files, metadata, manifest registration, target-path existence, and evidence artifacts (gdgraph, gdctx, gdwiki, Code Health, memory), followed by a manual read of its claims against current code as this skill's next step. NOT for: applying a review, test, or health finding to update a skill (see entity-skill-learner)."),
   skill("entity-skill-learner", "core", ["minimal", "recommended", "full"], "Update project-skills from review findings, test failures, health reports, memory entries, and verifier reports.", [
     "Parse the source report and map findings to project-skills.",
     "Classify lessons as anti-patterns, checklist changes, template changes, workflow changes, or architecture rules.",
     "Respect manual sections and autonomy policy.",
     "Increment version and append `skill-changelog.md` entries with provenance."
-  ], ["learn from review", "update skill", "skill lesson"]),
+  ], ["learn from review", "update skill", "skill lesson"], "Use when a review finding, test failure, health report, memory entry, or verifier report points at a project-skill that needs updating. NOT for: checking a skill's current accuracy with no source report driving it (see entity-skill-verifier)."),
   skill("job-orchestrator", "orchestration", ["recommended", "full"], "Run full task pipelines: clarify, collect context, plan, implement, verify, review, and summarize.", [
     "Clarify ambiguity with interviewer-style questions only when required.",
     "Collect compact context through Metaproject modules before implementation.",
@@ -43177,7 +43275,7 @@ var BUNDLED_GDSKILLS = [
     "Find existing root agent entrypoints.",
     "Keep managed Metaproject blocks idempotent.",
     "Ensure local `.metaproject/index.md` and skill catalog are first-class references."
-  ], ["agents.md", "claude.md", "entrypoint"]),
+  ], ["agents.md", "claude.md", "entrypoint"], "Use when AGENTS.md or CLAUDE.md needs its managed Metaproject block added, refreshed, or kept idempotent. NOT for: splitting an oversized entrypoint into rules and project-skills (see agent-entrypoint-distiller)."),
   skill("agent-entrypoint-distiller", "platform", ["minimal", "recommended", "full"], "Split large AGENTS.md/CLAUDE.md files into high-priority Metaproject rules and project-specific skills.", [
     "Run `keryx rules distill` when the user asks to decompose a large CLAUDE.md/AGENTS.md.",
     "Keep root entrypoints compact: non-project/highest-priority instructions plus `.metaproject/index.md` routing.",
@@ -43187,7 +43285,7 @@ var BUNDLED_GDSKILLS = [
     "Install hooks only when explicitly enabled.",
     "Keep hooks lightweight and idempotent.",
     "Avoid network and destructive behavior inside hooks."
-  ], ["install hook", "git hook", "post-commit"]),
+  ], ["install hook", "git hook", "post-commit"], "Use when a lightweight, explicitly-enabled git hook for graph, health, or skill verification needs installing or checking. NOT for: general hook design guidance not tied to these three (see hookify)."),
   skill("hookify", "platform", ["full"], "Use hook guidance for safe hook design and installation.", [
     "Detect existing hooks and preserve user content.",
     "Install idempotent managed blocks.",
@@ -43202,23 +43300,23 @@ var BUNDLED_GDSKILLS = [
     "Read bundled and project-local skill metadata.",
     "Generate concise catalog entries grouped by category.",
     "Keep catalog deterministic and local-first."
-  ], ["skill catalog", "list skills", "skills registry"]),
+  ], ["skill catalog", "list skills", "skills registry"], "Use when `.metaproject/skills/catalog.md` or the machine-readable skill registry is missing or out of date with bundled and project-local skill metadata. NOT for: turning skills into runtime artifacts (see skill-runtime-exporter) or pushing them to local runtimes (see skill-sync)."),
   skill("skill-runtime-exporter", "platform", ["full"], "Export canonical skills to runtime-compatible Codex or Claude artifacts.", [
     "Read canonical skill packages.",
     "Remove management-only files from runtime exports.",
     "Keep runtime `SKILL.md` concise with references, scripts, and assets as needed."
-  ], ["export skill", "runtime skill", "codex skill"]),
+  ], ["export skill", "runtime skill", "codex skill"], "Use when canonical skill packages need turning into runtime-compatible Codex or Claude artifacts, stripped of management-only files. NOT for: regenerating the skill catalog (see skill-catalog-manager) or pushing the export to local runtimes (see skill-sync)."),
   skill("skill-sync", "platform", ["full"], "Sync exported runtime skills to configured local runtimes only when explicitly enabled.", [
     "Read configured runtime targets.",
     "Validate runtime skill packages before sync.",
     "Sync only selected skills and report changed files."
-  ], ["sync skills", "install runtime skills", "global skill sync"])
+  ], ["sync skills", "install runtime skills", "global skill sync"], "Use when already-exported runtime skills need pushing to configured local runtimes, and only when sync is explicitly enabled. NOT for: producing the runtime export itself (see skill-runtime-exporter).")
 ];
-function skill(name, category, profiles, purpose, workflow, triggers) {
+function skill(name, category, profiles, purpose, workflow, triggers, descriptionOverride) {
   return {
     name,
     category,
-    description: `Use when ${purpose.charAt(0).toLowerCase()}${purpose.slice(1)}`,
+    description: descriptionOverride ?? `Use when ${purpose.charAt(0).toLowerCase()}${purpose.slice(1)}`,
     purpose,
     workflow,
     triggers,
@@ -43243,9 +43341,10 @@ function renderBundledSkill(skillEntry) {
   const workflow = skillEntry.workflow.map((step, index) => `${index + 1}. ${step}`).join(`
 `);
   const commandContract = renderAgentCommandContract(skillEntry);
+  const descriptionField = skillEntry.description.includes(":") ? `description: ${JSON.stringify(skillEntry.description)}` : `description: ${skillEntry.description}`;
   return `---
 name: ${skillEntry.name}
-description: ${skillEntry.description}
+${descriptionField}
 ---
 
 # ${skillEntry.name}
@@ -43380,8 +43479,9 @@ ${sections}
 
 // src/gdskills/install.ts
 init_fs();
-import { cp, copyFile, mkdir as mkdir7, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
+import { cp, copyFile, lstat as lstat3, mkdir as mkdir7, readFile as readFile10, unlink, writeFile as writeFile7 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
+import { createHash as createHash5 } from "crypto";
 import path31 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -43742,6 +43842,27 @@ function relativeContractPath(contract) {
   return contract.sourcePath ?? path30.join("src", "gdskills", "contracts", contract.fileName);
 }
 
+// src/gdskills/retired-rules.ts
+var RETIRED_RULES = [
+  {
+    fileName: "review-agent-profile.mdc",
+    shippedSha256: [
+      "e29a832821e501fa8a0acb5130007db1e21f1cee29f8ab6b2a1a7b35f9945281"
+    ],
+    reason: "Byte-identical duplicate of code-review-ai-assistant.mdc \u2014 nothing distinguished the two, and only the latter was ever routed to."
+  },
+  {
+    fileName: "review-strict-profile.mdc",
+    shippedSha256: [
+      "2e8847426bfba76ece8a208952402edadc6a062920aed07a721902b635a3f0e6",
+      "bc7e6df820682f75cbc1349e70d98b5692aa1c4bae903e28f41a67edb7a5a484"
+    ],
+    reason: "Outlived the review-strict skill it backed; review-orchestrator's Step 6 now resolves the model tier directly via `keryx review tier` instead."
+  }
+];
+var LARGEST_SHIPPED_RETIRED_RULE_BYTES = 2248;
+var RETIRED_RULE_SIZE_CAP_BYTES = LARGEST_SHIPPED_RETIRED_RULE_BYTES * 4;
+
 // src/gdskills/install.ts
 async function installGdskills(metaprojectRoot, profile, options = {}) {
   const skills = getBundledSkillsForProfile(profile);
@@ -43773,18 +43894,20 @@ async function installGdskills(metaprojectRoot, profile, options = {}) {
     }
   }
   await installBundledSharedSkills(skillsRoot);
-  await installBundledRules(metaprojectRoot);
+  const retiredRuleOutcomes = await installBundledRules(metaprojectRoot);
   const catalogPath = path31.join(metaprojectRoot, "skills", "catalog.md");
   await writeFile7(catalogPath, await preserveProjectSkillsSection(catalogPath, renderGdskillsCatalog(profile)), "utf8");
   const manifestPath = path31.join(metaprojectRoot, "modules", "gdskills.md");
   await writeFile7(manifestPath, renderGdskillsManifest(profile), "utf8");
   await installContracts(contractsRoot);
+  const warnings = retiredRuleOutcomes.map(retiredRuleWarning).filter((warning) => warning !== null);
   return {
     profile,
     installedSkills: skills.length,
     skillsRoot,
     catalogPath,
-    manifestPath
+    manifestPath,
+    warnings
   };
 }
 async function installBundledSharedSkills(skillsRoot) {
@@ -43796,10 +43919,83 @@ async function installBundledSharedSkills(skillsRoot) {
 }
 async function installBundledRules(metaprojectRoot) {
   const rulesSource = bundledRulesSourcePath();
+  const rulesTarget = path31.join(metaprojectRoot, "rules", "core");
   if (!existsSync9(rulesSource)) {
-    return;
+    return [];
+  }
+  await cp(rulesSource, rulesTarget, { recursive: true, force: true });
+  return removeUnmodifiedRetiredRules(rulesTarget);
+}
+async function removeUnmodifiedRetiredRules(rulesTarget, fsOps = { unlink }) {
+  const outcomes = [];
+  for (const retired of RETIRED_RULES) {
+    const installedPath = path31.join(rulesTarget, retired.fileName);
+    let stage = "lstat";
+    try {
+      const stats = await lstat3(installedPath);
+      if (!stats.isFile()) {
+        outcomes.push({ fileName: retired.fileName, action: "kept-not-regular-file" });
+        continue;
+      }
+      if (stats.size > RETIRED_RULE_SIZE_CAP_BYTES) {
+        outcomes.push({ fileName: retired.fileName, action: "kept-oversized", sizeBytes: stats.size });
+        continue;
+      }
+      stage = "read";
+      const content = await readFile10(installedPath);
+      const hash = createHash5("sha256").update(normalizeRetiredRuleContent(content)).digest("hex");
+      if (retired.shippedSha256.includes(hash)) {
+        stage = "unlink";
+        await fsOps.unlink(installedPath);
+        outcomes.push({ fileName: retired.fileName, action: "removed" });
+      } else {
+        outcomes.push({ fileName: retired.fileName, action: "kept-modified" });
+      }
+    } catch (error) {
+      if (isErrnoException(error) && error.code === "ENOENT") {
+        continue;
+      }
+      outcomes.push({
+        fileName: retired.fileName,
+        action: "kept-error",
+        stage,
+        errorCode: isErrnoException(error) && error.code ? error.code : "UNKNOWN"
+      });
+    }
+  }
+  return outcomes;
+}
+function normalizeRetiredRuleContent(content) {
+  let text = content.toString("utf8");
+  if (text.charCodeAt(0) === 65279) {
+    text = text.slice(1);
+  }
+  return text.replace(/\r\n/g, `
+`);
+}
+function isErrnoException(error) {
+  return error instanceof Error && "code" in error;
+}
+function retiredRuleWarning(outcome) {
+  if (outcome.action === "removed") {
+    return null;
+  }
+  const reason = RETIRED_RULES.find((retired) => retired.fileName === outcome.fileName)?.reason ?? "no longer shipped by keryx";
+  const prefix = `${outcome.fileName} is no longer shipped by keryx (${reason})`;
+  switch (outcome.action) {
+    case "kept-modified":
+      return `${prefix}; kept because it differs from every shipped version \u2014 delete it, or rename it if you still rely on it`;
+    case "kept-not-regular-file":
+      return `${prefix}; kept because it is not a regular file (a symlink, directory, or similar) \u2014 keryx will not read or remove it; delete or rename it yourself if appropriate`;
+    case "kept-oversized":
+      return `${prefix}; kept because it is ${outcome.sizeBytes} bytes, far larger than any version keryx ever shipped under this name \u2014 inspect it, then delete or rename it if appropriate`;
+    case "kept-error":
+      return outcome.stage === "unlink" ? `${prefix}; matches a shipped version but could not be removed (${outcome.errorCode}) \u2014 delete it by hand` : `${prefix}; kept because it could not be read (${outcome.errorCode}) \u2014 inspect it, then delete or rename it if appropriate`;
+    default: {
+      const exhaustive = outcome;
+      throw new Error(`unhandled retired rule outcome: ${JSON.stringify(exhaustive)}`);
+    }
   }
-  await cp(rulesSource, path31.join(metaprojectRoot, "rules", "core"), { recursive: true, force: true });
 }
 async function preserveProjectSkillsSection(catalogPath, nextCatalog) {
   if (!await pathExists(catalogPath)) {
@@ -46105,13 +46301,33 @@ function escapeHtml(value) {
 function renderProjectRulesReadme() {
   return `# Project Rules
 
-This directory stores repository-level instructions imported from root agent entrypoints such as \`AGENTS.md\` or \`CLAUDE.md\`.
+This directory holds two different kinds of rule files. Do not treat them the same way.
 
-Rules:
+## Imported entrypoint rules (this directory)
+
+The \`.md\` files here (e.g. \`agents-md.md\`, \`claude-md.md\`) are repository-level instructions
+imported from root agent entrypoints such as \`AGENTS.md\` or \`CLAUDE.md\`.
 
 - treat files here as high-priority agent-readable mirrors of root instructions;
 - update the root entrypoint first when changing project-wide instructions;
 - rerun \`keryx rules sync\`, \`keryx init\`, or \`keryx update\` to resync imported rule files.
+
+## Core rule library (\`core/*.mdc\`)
+
+\`core/*.mdc\` is an on-demand rule library, not something loaded automatically. A rule file is
+read only when a skill or \`routing.md\` cites it by path.
+
+- \`alwaysApply\` and \`globs\` in each rule's frontmatter are Cursor-format metadata for Cursor's
+  own auto-attach behavior; keryx itself does not read or act on either field;
+- a stack-specific rule (e.g. \`nestjs-dto.mdc\`, \`mobx-store-template.mdc\`) declares the stack(s)
+  it applies to via a \`stack_requires\` frontmatter key, using the same tag vocabulary as a
+  skill's \`metadata.stack_requires\`; it is only relevant to projects on that stack;
+- the bundled tree (\`src/gdskills/bundled/rules/core/\`) is the source of truth \u2014 \`core/\` here is
+  an installed mirror, and \`keryx init\`/\`keryx update\` overwrite it wholesale on install;
+  a rule retired from the bundled tree is removed from here too when it is an unmodified shipped
+  copy; otherwise it is kept (with a warning that says why \u2014 edited, not a regular file, oversized,
+  or unreadable/unremovable), since discarding it silently could lose your changes or hide a
+  filesystem problem.
 `;
 }
 function renderImportedAgentRules({
@@ -46119,7 +46335,7 @@ function renderImportedAgentRules({
   content
 }) {
   const body = extractAgentRuleBody(content);
-  const normalizedBody = body.length > 0 ? body : `This root entrypoint delegates agent routing to \`.metaproject/index.md\`.
+  const normalizedBody = body.length > 0 && !isHeadingOnlyBody(body) ? body : `This root entrypoint delegates agent routing to \`.metaproject/index.md\`.
 
 Read \`.metaproject/index.md\` first, then follow the high-priority rules, skills, and module references listed there.`;
   return `---
@@ -46143,6 +46359,9 @@ This file is generated from the repository root agent entrypoint. Edit \`${sourc
 ${normalizedBody}
 `;
 }
+function isHeadingOnlyBody(body) {
+  return body.replace(/^#[^\n]*\n?/, "").trim().length === 0;
+}
 function extractAgentRuleBody(content) {
   const marker = "<!-- keryx:index -->";
   const endMarker = "<!-- /keryx:index -->";
@@ -47243,13 +47462,13 @@ import { readFile as readFile17, rm as rm3 } from "fs/promises";
 import path44 from "path";
 
 // src/lib/install-plan.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { readFile as readFile16 } from "fs/promises";
 import path43 from "path";
 // package.json
 var package_default = {
   name: "@mrciphersmith/keryx",
-  version: "0.2.96",
+  version: "0.2.98",
   description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   private: false,
   publishConfig: {
@@ -47390,7 +47609,7 @@ function parseDivergenceResolution(args) {
   return;
 }
 function digestOf(content) {
-  return `sha256:${createHash5("sha256").update(content, "utf8").digest("hex")}`;
+  return `sha256:${createHash6("sha256").update(content, "utf8").digest("hex")}`;
 }
 function installJournalPath(metaprojectRoot) {
   return path43.join(metaprojectRoot, INSTALL_JOURNAL_RELATIVE_PATH);
@@ -49612,8 +49831,10 @@ async function initCommand(args) {
       await installGdwikiPostCommitHook(projectRoot);
     }
   }
+  let gdskillsWarnings = [];
   if (enableGdskills) {
-    await installGdskills(metaprojectRoot, gdskillsProfile);
+    const gdskillsInstallResult = await installGdskills(metaprojectRoot, gdskillsProfile);
+    gdskillsWarnings = gdskillsInstallResult.warnings;
     if (enableGdskillsHook) {
       await installGdskillsPostCommitHook(projectRoot);
     }
@@ -49867,6 +50088,12 @@ async function initCommand(args) {
   if (enableSac) {
     statusLine("sac", true, "shared agent context: cross-session workspace propose/review (opt-in)");
   }
+  if (gdskillsWarnings.length > 0) {
+    heading("Warnings");
+    for (const warning of gdskillsWarnings) {
+      note(warning);
+    }
+  }
   const gitHooksRoot = await resolveGitHooksRoot(projectRoot);
   const hookLines = [];
   if (enableGdgraph) {
@@ -50240,7 +50467,7 @@ Use this skill when a task requires code graph context, dependency impact analys
 4. Use \`keryx gdgraph affected <target>\` before implementation or review.
 `;
   if (await readFile23(legacyReadmePath, "utf8") === legacyContent) {
-    await unlink(legacyReadmePath);
+    await unlink2(legacyReadmePath);
   }
 }
 function runtimeSourcePath(relativePath) {
@@ -53184,7 +53411,7 @@ function readLiteral(source, start, quote) {
 
 // src/wiki/freshness/queue.ts
 init_fs();
-import { readFile as readFile43, rename as rename3, stat as stat10, unlink as unlink2, writeFile as writeFile30 } from "fs/promises";
+import { readFile as readFile43, rename as rename3, stat as stat10, unlink as unlink3, writeFile as writeFile30 } from "fs/promises";
 import path86 from "path";
 var QUEUE_FILE = "freshness-queue.jsonl";
 var ROTATED_FILE = "freshness-queue.1.jsonl";
@@ -53225,7 +53452,7 @@ async function drainQueue(cwd) {
 async function clearQueue(cwd) {
   for (const file of [rotatedQueuePath(cwd), queuePath(cwd)]) {
     if (await pathExists(file)) {
-      await unlink2(file).catch(() => {
+      await unlink3(file).catch(() => {
         return;
       });
     }
@@ -57464,6 +57691,8 @@ var BUNDLED_SKILL_CHECKS = [
   "frontmatter:name-unique",
   "frontmatter:description",
   "frontmatter:metadata",
+  "frontmatter:harness-claude",
+  "frontmatter:category",
   "catalog:registered",
   "model:concrete-declaration",
   "persona:name",
@@ -57608,17 +57837,60 @@ var INSTALLED_PREFIXES = [
 var GENERATED_PATH_ROOTS = [
   { prefix: "rules/entrypoints/", producedBy: "keryx rules distill" }
 ];
-var PATH_REFERENCE = /(?:^|[\s"'`([])((?:\.metaproject\/|skills\/|rules\/|scripts\/)[\w./@-]*[\w.@-])/g;
-function normaliseReferencePath(reference) {
+var PATH_REFERENCE = /(?:^|[\s"'`([])((?:\.metaproject\/|skills\/|rules\/|scripts\/)[\w./@*-]*[\w.@*-])/g;
+function resolveInstalledReference(reference, known) {
   for (const [from, to] of INSTALLED_PREFIXES) {
     if (reference.startsWith(from))
       return to + reference.slice(from.length);
   }
   if (reference.startsWith(".metaproject/"))
     return;
-  const root = reference.split("/")[0] ?? "";
+  const segments = reference.split("/");
+  const root = segments[0] ?? "";
+  if (root === "skills") {
+    if (segments.length === 3 && known.has(segments[2] ?? ""))
+      return reference;
+    return null;
+  }
   return CHECKED_PATH_ROOTS.includes(root) ? reference : undefined;
 }
+function scanCrossReferences(text, root, known, checkSkillNames, add) {
+  text.split(`
+`).forEach((line, index) => {
+    if (checkSkillNames) {
+      for (const pattern of SKILL_REFERENCE_PATTERNS) {
+        for (const match of line.matchAll(pattern)) {
+          const referenced = match[1];
+          if (!referenced.includes("-"))
+            continue;
+          if (known.has(referenced))
+            continue;
+          if (KNOWN_EXTERNAL_SKILL_REFERENCES.has(referenced))
+            continue;
+          add("xref:skill", index + 1, `names a skill \`${referenced}\` that this tree does not ship; either bundle it or stop naming it.`);
+        }
+      }
+    }
+    for (const match of line.matchAll(PATH_REFERENCE)) {
+      const raw = match[1];
+      if (raw.includes("<") || raw.includes("*") || raw.includes("$"))
+        continue;
+      const resolved = resolveInstalledReference(raw, known);
+      if (resolved === undefined)
+        continue;
+      if (resolved === null) {
+        add("xref:path", index + 1, `path \`${raw}\` names the SOURCE tree's own layout, not an installed one \u2014 an installed project has no top-level \`skills/\`, only \`.metaproject/skills/gdskills/\u2026\`. Write \`.metaproject/skills/gdskills/${raw.slice("skills/".length)}\` (or the \`skills/gdskills/\u2026\` form), or, to name the whole skill rather than a file in it, drop everything past its directory.`);
+        continue;
+      }
+      if (GENERATED_PATH_ROOTS.some((entry) => resolved === entry.prefix.replace(/\/$/, "") || resolved.startsWith(entry.prefix))) {
+        continue;
+      }
+      if (existsSync24(path143.join(root, resolved)))
+        continue;
+      add("xref:path", index + 1, `path \`${raw}\` resolves to nothing under the shipped tree (looked for \`${resolved}\`).`);
+    }
+  });
+}
 var SKILL_DOCUMENT_NAMES = new Set(HARNESS_SKILL_RUNTIMES.map((runtime) => skillBuildFileName(runtime)));
 var KNOWN_SKILL_COMPANION_DOCUMENTS = new Map([
   [
@@ -57650,6 +57922,12 @@ function bundledSkillFiles(root) {
 function bundledSkillDocuments(root) {
   return walkSkillDocuments(root, (name) => SKILL_DOCUMENT_NAMES.has(name));
 }
+function bundledRuleFiles(root) {
+  const rulesRoot = path143.join(root, "rules", "core");
+  if (!existsSync24(rulesRoot))
+    return [];
+  return readdirSync2(rulesRoot, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => path143.join(rulesRoot, entry.name)).sort();
+}
 function defaultBundledRoot() {
   const directPath = path143.join(import.meta.dir, "bundled");
   if (existsSync24(directPath))
@@ -57672,6 +57950,7 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
     const skillDir = path143.dirname(file);
     const skill = path143.basename(skillDir);
     const rel = path143.relative(skillsRoot, file).split(path143.sep).join("/");
+    const category = path143.dirname(rel).split("/")[0] ?? "";
     const text = readFileSync6(file, "utf8");
     const add = (check, line, message) => {
       findings.push({ check, skill, file: rel, line, message });
@@ -57710,9 +57989,25 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
         if (metadataVersion === null) {
           add("frontmatter:metadata", 1, "frontmatter `metadata` declares no `version`; without one a skill cannot be said to have changed.");
         }
+        const metadataCategory = /^\s{2,}category\s*:\s*(.+)$/m.exec(block);
+        if (metadataCategory !== null) {
+          const declaredCategory = (metadataCategory[1] ?? "").trim().replace(/^["']|["']$/g, "");
+          if (declaredCategory.length > 0 && declaredCategory !== category) {
+            add("frontmatter:category", 1, `frontmatter \`metadata.category\` is "${declaredCategory}" but this skill ships under \`${category}/${skill}\`; set it to "${category}" or drop the field.`);
+          }
+        }
+      }
+      if (path143.basename(file) === "SKILL.md") {
+        const compatibleHarnesses = /^\s{2,}compatible_harnesses\s*:\s*(.+)$/m.exec(block);
+        if (compatibleHarnesses !== null) {
+          const declared = (compatibleHarnesses[1] ?? "").trim().replace(/^["']|["']$/g, "");
+          const harnesses = declared.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+          if (!harnesses.includes("claude")) {
+            add("frontmatter:harness-claude", 1, `frontmatter \`compatible_harnesses\` ("${declared}") omits \`claude\`, but this file IS the Claude build \u2014 add \`claude\` to the list.`);
+          }
+        }
       }
     }
-    const category = path143.dirname(rel).split("/")[0] ?? "";
     if (!catalogued.has(`${category}/${skill}`)) {
       add("catalog:registered", null, `BUNDLED_GDSKILLS (src/gdskills/catalog.ts) does not name \`${category}/${skill}\`, so \`keryx skills install\` never copies this directory and no user ever sees it.`);
     }
@@ -57726,35 +58021,15 @@ function evaluateBundledTree(root = defaultBundledRoot()) {
     for (const offender of homePathOffenders(text)) {
       add("path:personal-home", offender.line, offender.why);
     }
-    text.split(`
-`).forEach((line, index) => {
-      for (const pattern of SKILL_REFERENCE_PATTERNS) {
-        for (const match of line.matchAll(pattern)) {
-          const referenced = match[1];
-          if (!referenced.includes("-"))
-            continue;
-          if (known.has(referenced))
-            continue;
-          if (KNOWN_EXTERNAL_SKILL_REFERENCES.has(referenced))
-            continue;
-          add("xref:skill", index + 1, `names a skill \`${referenced}\` that this tree does not ship; either bundle it or stop naming it.`);
-        }
-      }
-      for (const match of line.matchAll(PATH_REFERENCE)) {
-        const raw = match[1];
-        if (raw.includes("<") || raw.includes("*") || raw.includes("$"))
-          continue;
-        const normalised = normaliseReferencePath(raw);
-        if (normalised === undefined)
-          continue;
-        if (GENERATED_PATH_ROOTS.some((entry) => normalised === entry.prefix.replace(/\/$/, "") || normalised.startsWith(entry.prefix))) {
-          continue;
-        }
-        if (existsSync24(path143.join(root, normalised)))
-          continue;
-        add("xref:path", index + 1, `path \`${raw}\` resolves to nothing under the shipped tree (looked for \`${normalised}\`).`);
-      }
-    });
+    scanCrossReferences(text, root, known, true, add);
+  }
+  for (const file of bundledRuleFiles(root)) {
+    const rel = path143.relative(root, file).split(path143.sep).join("/");
+    const text = readFileSync6(file, "utf8");
+    const add = (check, line, message) => {
+      findings.push({ check, skill: path143.basename(file, path143.extname(file)), file: rel, line, message });
+    };
+    scanCrossReferences(text, root, known, false, add);
   }
   for (const dir of [...new Set(files.map((file) => path143.dirname(file)))].sort()) {
     for (const entry of readdirSync2(dir, { withFileTypes: true })) {
@@ -57878,6 +58153,12 @@ async function skillsCommand(args) {
     note(`skills   ${relativeToCwd(result.skillsRoot)}`);
     note(`catalog  ${relativeToCwd(result.catalogPath)}`);
     note(`manifest ${relativeToCwd(result.manifestPath)}`);
+    if (result.warnings.length > 0) {
+      console.log("Warnings:");
+      for (const warning of result.warnings) {
+        console.log(`- ${warning}`);
+      }
+    }
     nextSteps([
       `Browse the catalog: ${style.cyan("keryx skills catalog")}.`,
       `Route a request: ${style.cyan("keryx skills route <target>")}.`
@@ -64758,14 +65039,17 @@ init_pr_comments();
 init_loop();
 
 // src/review/stack.ts
-var STACK_TAGS = ["nestjs", "react", "mobx", "prisma"];
+var STACK_TAGS = ["nestjs", "react", "mobx", "prisma", "playwright", "sql", "http-server"];
 function isStackTag(value) {
   return STACK_TAGS.includes(value);
 }
 var TAG_MARKERS = {
   react: ["react", "react-dom"],
   mobx: ["mobx", "mobx-react", "mobx-react-lite"],
-  prisma: ["prisma", "@prisma/client"]
+  prisma: ["prisma", "@prisma/client"],
+  playwright: ["@playwright/test", "playwright"],
+  sql: ["prisma", "@prisma/client", "typeorm", "sequelize", "knex", "drizzle-orm", "pg", "mysql2", "better-sqlite3", "kysely"],
+  "http-server": ["express", "fastify", "koa", "hono", "@nestjs/core", "@hapi/hapi"]
 };
 var DEPENDENCY_FIELDS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
 async function detectProjectStack(cwd, options = {}) {
@@ -68127,14 +68411,14 @@ init_fs();
 init_json();
 
 // src/security/detect/mcp.ts
-import { createHash as createHash29 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 function hashToolDefinition(tool) {
   const canonical = JSON.stringify({
     name: tool.name,
     description: tool.description ?? "",
     inputSchema: tool.inputSchema ?? null
   });
-  return createHash29("sha256").update(canonical).digest("hex");
+  return createHash30("sha256").update(canonical).digest("hex");
 }
 var POISONING_PATTERNS = [
   {
@@ -69236,7 +69520,7 @@ function wrapBwrap(command, profile, launcherPath = BWRAP_PROGRAM) {
 }
 
 // src/harness/process/sandbox/adapter.ts
-import { createHash as createHash30 } from "crypto";
+import { createHash as createHash31 } from "crypto";
 
 // src/harness/process/sandbox/wrap.ts
 function wrapWithSandbox(command, profile, opts) {
@@ -69266,7 +69550,7 @@ function wrapWithSandbox(command, profile, opts) {
 function spawnError(command, message) {
   return {
     kind: "spawn-error",
-    observedHash: createHash30("sha256").update(`${command.path}
+    observedHash: createHash31("sha256").update(`${command.path}
 ${command.argv.join(" ")}`, "utf8").digest("hex"),
     errorMessage: message
   };
@@ -69894,12 +70178,12 @@ function entryProblems(name, entry) {
 }
 function oauthProblems(name, oauth) {
   const problems = [];
-  const known = new Set(["clientId", "clientSecretEnvVar", "scopes", "callbackPort"]);
+  const known = new Set(["clientId", "scopes", "callbackPort"]);
   for (const key of Object.keys(oauth)) {
     if (!known.has(key))
       problems.push(`server "${name}" oauth has unknown field "${key}"`);
   }
-  for (const field of ["clientId", "clientSecretEnvVar"]) {
+  for (const field of ["clientId"]) {
     if (oauth[field] !== undefined && typeof oauth[field] !== "string") {
       problems.push(`server "${name}" oauth.${field} must be a string`);
     }
@@ -70459,6 +70743,229 @@ function createMcpInteractiveTools(deps) {
   return [searchTool, useTool];
 }
 
+// src/mcp-servers/credentials.ts
+init_config_dir();
+import path165 from "path";
+var FORGET_CODE_VERIFIER = { code_verifier: undefined };
+var CREDENTIALS_SCHEMA_VERSION = 1;
+function credentialsFile(configDir) {
+  return path165.join(configDir ?? ensureKeryxConfigDir(), "mcp-credentials.json");
+}
+function credentialKey(serverName, serverUrl) {
+  return `${serverName}:${serverUrl}`;
+}
+function readAll2(configDir) {
+  const file = credentialsFile(configDir);
+  const read = readConfigFile(file);
+  if (!read.ok) {
+    return isDefiniteAbsence(read.reason) ? { file: {} } : { file: {}, problem: `${file} could not be read (${read.reason})` };
+  }
+  try {
+    const parsed = parseJsonTolerant(read.text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { file: {}, problem: `${file} must be a JSON object` };
+    }
+    const parsedFile = parsed;
+    if (typeof parsedFile.schemaVersion === "number" && parsedFile.schemaVersion > CREDENTIALS_SCHEMA_VERSION) {
+      return {
+        file: {},
+        problem: `${file} was written by a newer keryx ` + `(schemaVersion ${parsedFile.schemaVersion} > ${CREDENTIALS_SCHEMA_VERSION}); nothing was changed`
+      };
+    }
+    return { file: parsedFile };
+  } catch (error) {
+    return {
+      file: {},
+      problem: `${file} is not valid JSON (${error instanceof Error ? error.message : String(error)}); nothing was changed`
+    };
+  }
+}
+function readCredential(serverName, serverUrl, configDir) {
+  const { file, problem } = readAll2(configDir);
+  const record = file.credentials?.[credentialKey(serverName, serverUrl)];
+  return problem === undefined ? { record } : { record, problem };
+}
+function writeCredential(serverName, serverUrl, patch, configDir) {
+  const target = credentialsFile(configDir);
+  const outcome = withFileLock2(`${target}.lock`, () => mergeUnlocked(target, serverName, serverUrl, patch, configDir));
+  if (outcome === null) {
+    return { ok: false, error: `${target} is locked by another keryx; nothing was written` };
+  }
+  return outcome;
+}
+function mergeUnlocked(target, serverName, serverUrl, patch, configDir) {
+  const { file, problem } = readAll2(configDir);
+  if (problem !== undefined) {
+    return { ok: false, error: problem };
+  }
+  const key = credentialKey(serverName, serverUrl);
+  const credentials = { ...file.credentials, [key]: { ...file.credentials?.[key], ...patch } };
+  writeOwnerOnlyFileAtomic(target, `${JSON.stringify({ schemaVersion: CREDENTIALS_SCHEMA_VERSION, credentials }, null, 2)}
+`);
+  return { ok: true, file: target };
+}
+function clearCredential(serverName, serverUrl, configDir) {
+  const target = credentialsFile(configDir);
+  const outcome = withFileLock2(`${target}.lock`, () => {
+    const { file, problem } = readAll2(configDir);
+    if (problem !== undefined)
+      return { ok: false, error: problem };
+    const credentials = { ...file.credentials };
+    delete credentials[credentialKey(serverName, serverUrl)];
+    writeOwnerOnlyFileAtomic(target, `${JSON.stringify({ schemaVersion: CREDENTIALS_SCHEMA_VERSION, credentials }, null, 2)}
+`);
+    return { ok: true, file: target };
+  });
+  if (outcome === null) {
+    return { ok: false, error: `${target} is locked by another keryx; nothing was removed` };
+  }
+  return outcome;
+}
+function forgetByName(serverName, configDir) {
+  const target = credentialsFile(configDir);
+  const outcome = withFileLock2(`${target}.lock`, () => {
+    const { file, problem } = readAll2(configDir);
+    if (problem !== undefined)
+      return { count: 0, error: problem };
+    const credentials = { ...file.credentials };
+    let count = 0;
+    for (const key of Object.keys(credentials)) {
+      const separator = key.indexOf(":");
+      if (separator === -1)
+        continue;
+      if (key.slice(0, separator) !== serverName)
+        continue;
+      delete credentials[key];
+      count++;
+    }
+    if (count > 0) {
+      writeOwnerOnlyFileAtomic(target, `${JSON.stringify({ schemaVersion: CREDENTIALS_SCHEMA_VERSION, credentials }, null, 2)}
+`);
+    }
+    return { count };
+  });
+  return outcome ?? { count: 0, error: `${target} is locked by another keryx; nothing was removed` };
+}
+var EXPIRY_MARGIN_MS = 30000;
+function isExpired(tokens, now) {
+  if (tokens === undefined)
+    return true;
+  if (tokens.expires_at === undefined) {
+    return false;
+  }
+  return tokens.expires_at - EXPIRY_MARGIN_MS <= now;
+}
+function describeCredential(record, now) {
+  if (record?.tokens === undefined)
+    return "no stored credential";
+  if (isExpired(record.tokens, now)) {
+    return record.tokens.refresh_token === undefined ? "stored credential has expired; re-authenticate" : "stored credential has expired; it will be refreshed on the next connect";
+  }
+  if (record.tokens.expires_at === undefined)
+    return "stored credential, no stated expiry";
+  const minutes = Math.max(0, Math.round((record.tokens.expires_at - now) / 60000));
+  return `stored credential, valid for about ${minutes} more minute(s)`;
+}
+function usesOAuth(server) {
+  if (typeof server.url !== "string" || server.url === "")
+    return false;
+  if (server.oauth === false)
+    return false;
+  if (server.bearer_token_env_var !== undefined && server.bearer_token_env_var !== "")
+    return false;
+  return !Object.keys(server.headers ?? {}).some((name) => name.toLowerCase() === "authorization");
+}
+
+// src/mcp-servers/oauth-provider.ts
+class OAuthInteractionRequiredError extends Error {
+  serverName;
+  constructor(serverName) {
+    super(`server "${serverName}" needs OAuth and this process cannot ask: run \`keryx mcp auth ${serverName}\` in a terminal`);
+    this.serverName = serverName;
+    this.name = "OAuthInteractionRequiredError";
+  }
+}
+var CLIENT_NAME = "keryx";
+function createOAuthProvider(deps) {
+  const now = deps.now ?? Date.now;
+  const read = () => readCredential(deps.serverName, deps.serverUrl, deps.configDir);
+  return {
+    get redirectUrl() {
+      return deps.redirectUrl;
+    },
+    get clientMetadata() {
+      return {
+        client_name: CLIENT_NAME,
+        redirect_uris: deps.redirectUrl === undefined ? [] : [deps.redirectUrl],
+        grant_types: ["authorization_code", "refresh_token"],
+        response_types: ["code"],
+        ...deps.scopes === undefined || deps.scopes.length === 0 ? {} : { scope: deps.scopes.join(" ") },
+        token_endpoint_auth_method: "none"
+      };
+    },
+    state() {
+      if (deps.state === undefined) {
+        if (!deps.interactive)
+          throw new OAuthInteractionRequiredError(deps.serverName);
+        throw new Error("no callback listener is running; state is minted by the listener");
+      }
+      return deps.state;
+    },
+    clientInformation() {
+      if (deps.clientId !== undefined && deps.clientId !== "") {
+        return { client_id: deps.clientId };
+      }
+      return read().record?.client;
+    },
+    saveClientInformation(client) {
+      if (!deps.interactive)
+        throw new OAuthInteractionRequiredError(deps.serverName);
+      const write = writeCredential(deps.serverName, deps.serverUrl, { client }, deps.configDir);
+      if (!write.ok)
+        throw new Error(write.error);
+    },
+    tokens() {
+      const stored = read().record?.tokens;
+      if (stored === undefined)
+        return;
+      if (isExpired(stored, now()) && stored.refresh_token === undefined)
+        return;
+      return stored;
+    },
+    saveTokens(sdkTokens) {
+      const tokens = {
+        access_token: sdkTokens.access_token,
+        ...sdkTokens.token_type === undefined ? {} : { token_type: sdkTokens.token_type },
+        ...sdkTokens.refresh_token === undefined ? {} : { refresh_token: sdkTokens.refresh_token },
+        ...sdkTokens.scope === undefined ? {} : { scope: sdkTokens.scope },
+        ...sdkTokens.expires_in === undefined ? {} : { expires_at: now() + sdkTokens.expires_in * 1000 }
+      };
+      const write = writeCredential(deps.serverName, deps.serverUrl, { tokens, ...FORGET_CODE_VERIFIER }, deps.configDir);
+      if (!write.ok)
+        throw new Error(write.error);
+    },
+    async redirectToAuthorization(url) {
+      if (!deps.interactive)
+        throw new OAuthInteractionRequiredError(deps.serverName);
+      if (deps.openBrowser === undefined)
+        throw new OAuthInteractionRequiredError(deps.serverName);
+      await deps.openBrowser(url);
+    },
+    saveCodeVerifier(codeVerifier) {
+      const write = writeCredential(deps.serverName, deps.serverUrl, { code_verifier: codeVerifier }, deps.configDir);
+      if (!write.ok)
+        throw new Error(write.error);
+    },
+    codeVerifier() {
+      const verifier = read().record?.code_verifier;
+      if (verifier === undefined) {
+        throw new Error("no PKCE verifier stored; the authorisation was not started by this keryx");
+      }
+      return verifier;
+    }
+  };
+}
+
 // src/mcp-servers/doctor.ts
 function redactValues(values) {
   const out = {};
@@ -70555,12 +71062,38 @@ async function diagnose(server, options) {
         detail: describeHollow(resolved.hollow)
       };
     }
+    const declaresOAuth = server.raw.oauth !== undefined && server.raw.oauth !== false;
+    if (declaresOAuth && usesOAuth(server.raw)) {
+      const stored = readCredential(server.name, server.url ?? "", options.configDir);
+      if (stored.problem !== undefined) {
+        return { ...base, status: "needs_auth", toolCount: 0, skipped: [], detail: stored.problem };
+      }
+      const tokens = stored.record?.tokens;
+      if (tokens === undefined || isExpired(tokens, (options.now ?? Date.now)()) && tokens.refresh_token === undefined) {
+        return {
+          ...base,
+          status: "needs_auth",
+          toolCount: 0,
+          skipped: [],
+          detail: tokens === undefined ? `no stored credential; run \`keryx mcp auth ${server.name}\`` : `stored credential has expired and cannot be refreshed; run \`keryx mcp auth ${server.name}\``
+        };
+      }
+    }
   }
   const timeoutMs = server.startup_timeout_sec !== undefined ? server.startup_timeout_sec * 1000 : options.connectTimeoutMs ?? DEFAULT_DOCTOR_TIMEOUT_MS;
   let connection;
   try {
     connection = await withTimeout(options.connect(server), timeoutMs, server.name);
   } catch (error) {
+    if (base.transport === "http" && usesOAuth(server.raw) && needsAuthorisation(error)) {
+      return {
+        ...base,
+        status: "needs_auth",
+        toolCount: 0,
+        skipped: [],
+        detail: `${displayUrl(server.raw.url)} requires authorisation; run \`keryx mcp auth ${server.name}\``
+      };
+    }
     return {
       ...base,
       status: "failed",
@@ -70586,6 +71119,20 @@ async function diagnose(server, options) {
     } catch {}
   }
 }
+function needsAuthorisation(error) {
+  if (httpStatusOf(error) === 401)
+    return true;
+  if (error instanceof OAuthInteractionRequiredError)
+    return true;
+  return DEAD_CREDENTIAL_CODES.has(oauthErrorCodeOf(error));
+}
+var DEAD_CREDENTIAL_CODES = new Set(["invalid_grant", "invalid_client"]);
+function oauthErrorCodeOf(error) {
+  if (typeof error !== "object" || error === null)
+    return "";
+  const code = error.errorCode;
+  return typeof code === "string" ? code : "";
+}
 function explainConnectFailure(transport, server, error) {
   const message = sanitiseForDisplay(messageOf(error));
   if (transport !== "http")
@@ -70710,193 +71257,144 @@ function formatDoctorReport(report) {
 `);
 }
 
-// src/mcp-servers/runtime.ts
-import path166 from "path";
-
-// src/mcp-servers/manager.ts
-var DEFAULT_CONNECT_CONCURRENCY = 4;
-var DEFAULT_STARTUP_TIMEOUT_MS = 15000;
-async function startServers(servers, connect, options = {}) {
-  const concurrency = Math.max(1, options.concurrency ?? DEFAULT_CONNECT_CONCURRENCY);
-  const states = new Map;
-  const catalogs = [];
-  const enabled = [];
-  for (const server of servers) {
-    if (server.enabled) {
-      enabled.push(server);
-    } else {
-      states.set(server.name, { name: server.name, status: "disabled", toolCount: 0 });
-    }
+// src/lib/oauth/open-url.ts
+import { spawn as spawn5 } from "child_process";
+function browserOpenPlan(url, platform = process.platform, env = process.env) {
+  if (url.length === 0) {
+    return;
   }
-  let next = 0;
-  const worker = async () => {
-    for (;; ) {
-      const index = next++;
-      const server = enabled[index];
-      if (server === undefined)
-        return;
-      const timeoutMs = server.startup_timeout_sec !== undefined ? server.startup_timeout_sec * 1000 : options.defaultStartupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-      let connection;
-      try {
-        connection = await withTimeout2(connect(server), timeoutMs, server.name, (late) => {
-          late.close().catch(() => {});
+  if (platform === "darwin") {
+    return { cmd: "open", args: [url] };
+  }
+  if (platform === "win32") {
+    return { cmd: "cmd", args: ["/c", "start", "", url] };
+  }
+  if (typeof env.DISPLAY === "string" && env.DISPLAY.length > 0) {
+    return { cmd: "xdg-open", args: [url] };
+  }
+  if (typeof env.WAYLAND_DISPLAY === "string" && env.WAYLAND_DISPLAY.length > 0) {
+    return { cmd: "xdg-open", args: [url] };
+  }
+  return;
+}
+function openVerificationUrl(url, deps = {}) {
+  const plan = browserOpenPlan(url, deps.platform ?? process.platform, deps.env ?? process.env);
+  if (plan === undefined) {
+    return;
+  }
+  const spawnFn = deps.spawn ?? spawn5;
+  try {
+    const child = spawnFn(plan.cmd, plan.args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {}
+}
+
+// src/mcp-servers/oauth-callback.ts
+import { randomBytes as randomBytes4, timingSafeEqual } from "crypto";
+function matchesState(given, expected) {
+  if (given === null)
+    return false;
+  const a = Buffer.from(given, "utf8");
+  const b = Buffer.from(expected, "utf8");
+  if (a.length !== b.length)
+    return false;
+  return timingSafeEqual(a, b);
+}
+var LOOPBACK_HOST = "127.0.0.1";
+var CALLBACK_TIMEOUT_MS = 5 * 60000;
+function page(title, detail) {
+  return [
+    "<!doctype html><meta charset=utf-8>",
+    `<title>${title}</title>`,
+    '<body style="font:14px system-ui;padding:3rem;max-width:34rem">',
+    `<h1 style="font-size:1.1rem">${title}</h1>`,
+    `<p>${detail}</p>`,
+    "</body>"
+  ].join("");
+}
+function startCallbackListener(options = {}) {
+  const state = randomBytes4(32).toString("base64url");
+  const timeoutMs = options.timeoutMs ?? CALLBACK_TIMEOUT_MS;
+  const serve = options.serve ?? Bun.serve;
+  let settle = () => {};
+  const result = new Promise((resolve) => {
+    settle = resolve;
+  });
+  let done = false;
+  let timer;
+  const server = serve({
+    hostname: LOOPBACK_HOST,
+    port: options.port ?? 0,
+    fetch(request) {
+      const url = new URL(request.url);
+      if (done) {
+        return new Response(page("Already handled", "This authorisation was already completed."), {
+          status: 410,
+          headers: { "content-type": "text/html" }
         });
-        const tools = await withTimeout2(connection.listTools(), timeoutMs, server.name);
-        const catalog = catalogForServer(server.name, tools);
-        catalogs.push(catalog);
-        states.set(server.name, {
-          name: server.name,
-          status: "connected",
-          toolCount: catalog.entries.length,
-          connection
+      }
+      const given = url.searchParams.get("state");
+      if (!matchesState(given, state)) {
+        return new Response(page("Not this flow", "This request did not come from the authorisation keryx started."), {
+          status: 400,
+          headers: { "content-type": "text/html" }
         });
-      } catch (error) {
-        if (connection !== undefined) {
-          try {
-            await connection.close();
-          } catch {}
-        }
-        states.set(server.name, {
-          name: server.name,
-          status: "failed",
-          error: error instanceof Error ? error.message : String(error),
-          toolCount: 0
+      }
+      const error = url.searchParams.get("error");
+      if (error !== null) {
+        const description = url.searchParams.get("error_description");
+        done = true;
+        settle({ ok: false, reason: description === null ? error : `${error}: ${description}` });
+        return new Response(page("Authorisation refused", "You can close this tab and return to keryx."), {
+          status: 200,
+          headers: { "content-type": "text/html" }
+        });
+      }
+      const code = url.searchParams.get("code");
+      if (code === null || code === "") {
+        return new Response(page("No code", "The authorisation server returned no code."), {
+          status: 400,
+          headers: { "content-type": "text/html" }
         });
       }
+      done = true;
+      settle({ ok: true, code });
+      return new Response(page("Authorised", "keryx has what it needs. You can close this tab."), {
+        status: 200,
+        headers: { "content-type": "text/html" }
+      });
     }
-  };
-  await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(enabled.length, 1)) }, worker));
-  return {
-    servers: [...states.values()].sort((a, b) => a.name.localeCompare(b.name)),
-    catalog: mergeCatalogs(catalogs)
-  };
-}
-async function withTimeout2(work, ms, name, onAbandoned) {
-  let timer;
-  let settled = false;
-  try {
-    return await Promise.race([
-      work,
-      new Promise((_resolve, reject) => {
-        timer = setTimeout(() => reject(new Error(`server "${name}" did not answer within ${ms}ms`)), ms);
-      })
-    ]).then((value) => {
-      settled = true;
-      return value;
-    });
-  } finally {
+  });
+  const close = () => {
     if (timer !== undefined)
       clearTimeout(timer);
-    if (!settled && onAbandoned !== undefined) {
-      work.then(onAbandoned).catch(() => {});
-    }
-  }
-}
-async function closeServers(states) {
-  await Promise.all(states.map(async (state) => {
+    timer = undefined;
     try {
-      await state.connection?.close();
+      server.stop(true);
     } catch {}
-  }));
-}
-
-// src/mcp-servers/trust.ts
-init_config_dir();
-import { createHash as createHash31 } from "crypto";
-import path165 from "path";
-function trustFile(configDir) {
-  return path165.join(configDir ?? ensureKeryxConfigDir(), "mcp-servers-trust.json");
-}
-function serverFingerprint(server) {
-  const material = JSON.stringify({
-    command: server.command ?? null,
-    args: server.args ?? [],
-    url: server.url ?? null,
-    env: server.env ?? {},
-    cwd: server.cwd ?? null,
-    headers: sortedKeys(server.headers),
-    bearer_token_env_var: server.bearer_token_env_var ?? null
+  };
+  timer = setTimeout(() => {
+    if (done)
+      return;
+    done = true;
+    settle({
+      ok: false,
+      reason: `no response within ${Math.round(timeoutMs / 1000)}s \u2014 the browser tab was never completed`
+    });
+  }, timeoutMs);
+  timer.unref?.();
+  result.then(() => {
+    const drain = setTimeout(close, 50);
+    drain.unref?.();
   });
-  return createHash31("sha256").update(material).digest("hex").slice(0, 32);
-}
-function sortedKeys(values) {
-  return Object.entries(values ?? {}).sort(([a], [b]) => a.localeCompare(b));
-}
-function trustKey(server) {
-  return `${server.file}::${server.name}`;
-}
-function loadTrustStore(configDir) {
-  const read = readConfigFile(trustFile(configDir));
-  if (!read.ok)
-    return {};
-  try {
-    const parsed = parseJsonTolerant(read.text);
-    const approvals = parsed.approvals;
-    if (approvals === undefined)
-      return {};
-    const clean = {};
-    for (const [key, value] of Object.entries(approvals)) {
-      if (typeof value === "string")
-        clean[key] = value;
-    }
-    return clean;
-  } catch {
-    return {};
-  }
-}
-function requiresApproval(server, approvals) {
-  if (!server.projectLocal)
-    return false;
-  return approvals[trustKey(server)] !== serverFingerprint(server);
-}
-function approveServer(server, configDir) {
-  const file = trustFile(configDir);
-  const read = readConfigFile(file);
-  if (!read.ok && !isDefiniteAbsence(read.reason)) {
-    return { ok: false, error: `${file} could not be read (${read.reason}); nothing was written` };
-  }
-  const approvals = loadTrustStore(configDir);
-  approvals[trustKey(server)] = serverFingerprint(server);
-  writeOwnerOnlyFileAtomic(file, `${JSON.stringify({ approvals }, null, 2)}
-`);
-  return { ok: true, file };
-}
-function revokeServer(server, configDir) {
-  const file = trustFile(configDir);
-  const approvals = loadTrustStore(configDir);
-  delete approvals[trustKey(server)];
-  writeOwnerOnlyFileAtomic(file, `${JSON.stringify({ approvals }, null, 2)}
-`);
-  return { ok: true, file };
-}
-function describeForApproval(server) {
-  const raw = server.raw;
-  if (raw.url !== undefined && raw.url.length > 0) {
-    const shown = displayUrl(raw.url);
-    const credentials = credentialSummary(raw);
-    return credentials === undefined ? shown : `${shown}  [sends ${credentials}]`;
-  }
-  return [raw.command, ...raw.args ?? []].filter(Boolean).join(" ");
-}
-function credentialSummary(raw) {
-  const named = new Set;
-  if (raw.bearer_token_env_var !== undefined && raw.bearer_token_env_var !== "") {
-    named.add(raw.bearer_token_env_var);
-  }
-  for (const value of Object.values(raw.headers ?? {})) {
-    for (const match of value.matchAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)/g))
-      named.add(match[1]);
-  }
-  const headerNames = Object.keys(raw.headers ?? {});
-  if (named.size === 0 && headerNames.length === 0)
-    return;
-  const parts = [];
-  if (named.size > 0)
-    parts.push([...named].sort().join(", "));
-  const literal = headerNames.filter((n) => !/\$\{/.test(raw.headers?.[n] ?? ""));
-  if (literal.length > 0)
-    parts.push(`literal header(s) ${literal.sort().join(", ")}`);
-  return parts.join(" + ");
+  return {
+    redirectUrl: `http://${LOOPBACK_HOST}:${server.port}/callback`,
+    boundHost: server.hostname ?? "",
+    state,
+    result,
+    close
+  };
 }
 
 // src/mcp-client/wire.ts
@@ -71015,6 +71513,7 @@ async function connectHttpMcpServer(url, options = {}) {
   }
   const sdk = await loadHttpSdk();
   const transport = new sdk.StreamableHTTPClientTransport(parsed, {
+    ...options.authProvider === undefined ? {} : { authProvider: options.authProvider },
     fetch: (input, init) => fetch(input, { ...init, redirect: "error" }),
     requestInit: {
       ...Object.keys(headers).length > 0 ? { headers } : {},
@@ -71148,6 +71647,195 @@ async function connectStdioMcpServer(argv, options, handshakeTimeoutMs, signal,
   };
 }
 
+// src/mcp-servers/runtime.ts
+import path167 from "path";
+
+// src/mcp-servers/manager.ts
+var DEFAULT_CONNECT_CONCURRENCY = 4;
+var DEFAULT_STARTUP_TIMEOUT_MS = 15000;
+async function startServers(servers, connect, options = {}) {
+  const concurrency = Math.max(1, options.concurrency ?? DEFAULT_CONNECT_CONCURRENCY);
+  const states = new Map;
+  const catalogs = [];
+  const enabled = [];
+  for (const server of servers) {
+    if (server.enabled) {
+      enabled.push(server);
+    } else {
+      states.set(server.name, { name: server.name, status: "disabled", toolCount: 0 });
+    }
+  }
+  let next = 0;
+  const worker = async () => {
+    for (;; ) {
+      const index = next++;
+      const server = enabled[index];
+      if (server === undefined)
+        return;
+      const timeoutMs = server.startup_timeout_sec !== undefined ? server.startup_timeout_sec * 1000 : options.defaultStartupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+      let connection;
+      try {
+        connection = await withTimeout2(connect(server), timeoutMs, server.name, (late) => {
+          late.close().catch(() => {});
+        });
+        const tools = await withTimeout2(connection.listTools(), timeoutMs, server.name);
+        const catalog = catalogForServer(server.name, tools);
+        catalogs.push(catalog);
+        states.set(server.name, {
+          name: server.name,
+          status: "connected",
+          toolCount: catalog.entries.length,
+          connection
+        });
+      } catch (error) {
+        if (connection !== undefined) {
+          try {
+            await connection.close();
+          } catch {}
+        }
+        states.set(server.name, {
+          name: server.name,
+          status: "failed",
+          error: error instanceof Error ? error.message : String(error),
+          toolCount: 0
+        });
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, Math.max(enabled.length, 1)) }, worker));
+  return {
+    servers: [...states.values()].sort((a, b) => a.name.localeCompare(b.name)),
+    catalog: mergeCatalogs(catalogs)
+  };
+}
+async function withTimeout2(work, ms, name, onAbandoned) {
+  let timer;
+  let settled = false;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`server "${name}" did not answer within ${ms}ms`)), ms);
+      })
+    ]).then((value) => {
+      settled = true;
+      return value;
+    });
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    if (!settled && onAbandoned !== undefined) {
+      work.then(onAbandoned).catch(() => {});
+    }
+  }
+}
+async function closeServers(states) {
+  await Promise.all(states.map(async (state) => {
+    try {
+      await state.connection?.close();
+    } catch {}
+  }));
+}
+
+// src/mcp-servers/trust.ts
+init_config_dir();
+import { createHash as createHash32 } from "crypto";
+import path166 from "path";
+function trustFile(configDir) {
+  return path166.join(configDir ?? ensureKeryxConfigDir(), "mcp-servers-trust.json");
+}
+function serverFingerprint(server) {
+  const material = JSON.stringify({
+    command: server.command ?? null,
+    args: server.args ?? [],
+    url: server.url ?? null,
+    env: server.env ?? {},
+    cwd: server.cwd ?? null,
+    headers: sortedKeys(server.headers),
+    bearer_token_env_var: server.bearer_token_env_var ?? null
+  });
+  return createHash32("sha256").update(material).digest("hex").slice(0, 32);
+}
+function sortedKeys(values) {
+  return Object.entries(values ?? {}).sort(([a], [b]) => a.localeCompare(b));
+}
+function trustKey(server) {
+  return `${server.file}::${server.name}`;
+}
+function loadTrustStore(configDir) {
+  const read = readConfigFile(trustFile(configDir));
+  if (!read.ok)
+    return {};
+  try {
+    const parsed = parseJsonTolerant(read.text);
+    const approvals = parsed.approvals;
+    if (approvals === undefined)
+      return {};
+    const clean = {};
+    for (const [key, value] of Object.entries(approvals)) {
+      if (typeof value === "string")
+        clean[key] = value;
+    }
+    return clean;
+  } catch {
+    return {};
+  }
+}
+function requiresApproval(server, approvals) {
+  if (!server.projectLocal)
+    return false;
+  return approvals[trustKey(server)] !== serverFingerprint(server);
+}
+function approveServer(server, configDir) {
+  const file = trustFile(configDir);
+  const read = readConfigFile(file);
+  if (!read.ok && !isDefiniteAbsence(read.reason)) {
+    return { ok: false, error: `${file} could not be read (${read.reason}); nothing was written` };
+  }
+  const approvals = loadTrustStore(configDir);
+  approvals[trustKey(server)] = serverFingerprint(server);
+  writeOwnerOnlyFileAtomic(file, `${JSON.stringify({ approvals }, null, 2)}
+`);
+  return { ok: true, file };
+}
+function revokeServer(server, configDir) {
+  const file = trustFile(configDir);
+  const approvals = loadTrustStore(configDir);
+  delete approvals[trustKey(server)];
+  writeOwnerOnlyFileAtomic(file, `${JSON.stringify({ approvals }, null, 2)}
+`);
+  return { ok: true, file };
+}
+function describeForApproval(server) {
+  const raw = server.raw;
+  if (raw.url !== undefined && raw.url.length > 0) {
+    const shown = displayUrl(raw.url);
+    const credentials = credentialSummary(raw);
+    return credentials === undefined ? shown : `${shown}  [sends ${credentials}]`;
+  }
+  return [raw.command, ...raw.args ?? []].filter(Boolean).join(" ");
+}
+function credentialSummary(raw) {
+  const named = new Set;
+  if (raw.bearer_token_env_var !== undefined && raw.bearer_token_env_var !== "") {
+    named.add(raw.bearer_token_env_var);
+  }
+  for (const value of Object.values(raw.headers ?? {})) {
+    for (const match of value.matchAll(/\$\{([A-Za-z_][A-Za-z0-9_]*)/g))
+      named.add(match[1]);
+  }
+  const headerNames = Object.keys(raw.headers ?? {});
+  if (named.size === 0 && headerNames.length === 0)
+    return;
+  const parts = [];
+  if (named.size > 0)
+    parts.push([...named].sort().join(", "));
+  const literal = headerNames.filter((n) => !/\$\{/.test(raw.headers?.[n] ?? ""));
+  if (literal.length > 0)
+    parts.push(`literal header(s) ${literal.sort().join(", ")}`);
+  return parts.join(" + ");
+}
+
 // src/harness/external/env.ts
 var EXTERNAL_ENV_DENY = [
   "ANTHROPIC_API_KEY",
@@ -71376,7 +72064,7 @@ function createMcpRuntime(options) {
   ];
   const kills = [];
   const env = options.env ?? process.env;
-  const connect = options.connect ?? ((server) => defaultConnect(server, env, dialling.signal, kills));
+  const connect = options.connect ?? ((server) => defaultConnect(server, env, dialling.signal, kills, options.configDir));
   const settled = startServers(launchable, connect).then((result) => {
     catalog = result.catalog;
     states = [...heldStates, ...result.servers].sort((a, b) => a.name.localeCompare(b.name));
@@ -71421,7 +72109,25 @@ function handshakeBudgetMs(server) {
 }
 var MAX_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 var DEFAULT_HANDSHAKE_MS = 15000;
-async function connectRemote(server, env, signal) {
+var SESSION_REDIRECT_URL = "http://127.0.0.1/keryx-session-never-listens";
+function sessionAuthProviderOptions(server, runtimeConfigDir, stored, now = Date.now()) {
+  if (!usesOAuth(server.raw))
+    return;
+  const tokens = stored?.tokens;
+  if (tokens === undefined)
+    return;
+  if (isExpired(tokens, now) && tokens.refresh_token === undefined)
+    return;
+  return {
+    serverName: server.name,
+    serverUrl: server.url,
+    ...runtimeConfigDir === undefined ? {} : { configDir: runtimeConfigDir },
+    redirectUrl: SESSION_REDIRECT_URL,
+    interactive: false,
+    ...server.oauth === false || server.oauth?.clientId === undefined ? {} : { clientId: server.oauth.clientId }
+  };
+}
+async function connectRemote(server, env, signal, runtimeConfigDir) {
   const target = remoteTargetProblem(server.raw, env);
   if (target !== undefined) {
     throw new Error(`server "${server.name}": ${target}`);
@@ -71430,8 +72136,11 @@ async function connectRemote(server, env, signal) {
   if (!resolved.ok) {
     throw new Error(`server "${server.name}": ${describeHollow(resolved.hollow)}`);
   }
+  const options = sessionAuthProviderOptions(server, runtimeConfigDir, server.url === undefined ? undefined : readCredential(server.name, server.url, runtimeConfigDir).record);
+  const authProvider = options === undefined ? undefined : createOAuthProvider(options);
   return connectHttpMcpServer(server.url, {
     headers: resolved.headers,
+    ...authProvider === undefined ? {} : { authProvider },
     handshakeTimeoutMs: handshakeBudgetMs(server),
     ...signal === undefined ? {} : { signal }
   });
@@ -71441,9 +72150,9 @@ function timeoutFor(server, rawName) {
     return;
   return server.tool_timeouts?.[rawName] ?? server.tool_timeout_sec;
 }
-async function defaultConnect(server, env, signal, kills) {
+async function defaultConnect(server, env, signal, kills, configDir) {
   if (transportOf(server) === "http")
-    return connectRemote(server, env, signal);
+    return connectRemote(server, env, signal, configDir);
   const command = server.command;
   if (command === undefined || command === "") {
     throw new Error(`server "${server.name}" sets neither command nor url`);
@@ -71456,22 +72165,22 @@ async function defaultConnect(server, env, signal, kills) {
 function defaultServerCwd(server, fallbackCwd = process.cwd()) {
   if (server.source !== "project")
     return fallbackCwd;
-  return path166.dirname(path166.dirname(server.file));
+  return path167.dirname(path167.dirname(server.file));
 }
 
 // src/mcp-servers/store.ts
 init_config_dir();
 import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
-import path167 from "path";
+import path168 from "path";
 var SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
 function userConfigFile(configDir) {
-  return path167.join(configDir ?? ensureKeryxConfigDir(), "mcp-servers.json");
+  return path168.join(configDir ?? ensureKeryxConfigDir(), "mcp-servers.json");
 }
 function projectConfigFile(projectRoot) {
-  return path167.join(projectRoot, ".keryx", "mcp-servers.json");
+  return path168.join(projectRoot, ".keryx", "mcp-servers.json");
 }
 function overlayFile(configDir) {
-  return path167.join(configDir ?? ensureKeryxConfigDir(), "mcp-servers-disabled.json");
+  return path168.join(configDir ?? ensureKeryxConfigDir(), "mcp-servers-disabled.json");
 }
 function readForWrite(file) {
   const read = readConfigFile(file);
@@ -71510,7 +72219,7 @@ function writeDocument(file, doc, scope) {
     writeOwnerOnlyFileAtomic(file, body);
     return;
   }
-  mkdirSync6(path167.dirname(file), { recursive: true });
+  mkdirSync6(path168.dirname(file), { recursive: true });
   writeFileSync7(file, body, { encoding: "utf8" });
 }
 function addServer(options) {
@@ -71614,7 +72323,9 @@ var MCP_CONSUMER_SUBCOMMANDS = [
   "disable",
   "trust",
   "untrust",
-  "doctor"
+  "doctor",
+  "auth",
+  "logout"
 ];
 function isMcpConsumerSubcommand(value) {
   return MCP_CONSUMER_SUBCOMMANDS.includes(value ?? "");
@@ -71637,6 +72348,10 @@ async function runMcpConsumerCommand(subcommand, args, deps) {
       return trustCommand(args, deps, false);
     case "doctor":
       return doctorCommand(args, deps);
+    case "auth":
+      return authCommand(args, deps);
+    case "logout":
+      return logoutCommand(args, deps);
   }
 }
 function projectRootOf(deps) {
@@ -71778,6 +72493,178 @@ function addCommand(argv, deps) {
   deps.log(`Run \`keryx mcp doctor ${name}\` to check it connects.`);
   return 0;
 }
+function logoutCommand(args, deps) {
+  const own = splitAtSeparator(args).own;
+  const name = own[0];
+  if (name === undefined || name.startsWith("-")) {
+    deps.err("usage: keryx mcp logout <name>");
+    return 1;
+  }
+  const config = load(deps);
+  const server = config.servers.find((candidate) => candidate.name === name);
+  const url = server?.url;
+  if (url === undefined) {
+    const removed = forgetByName(name, deps.configDir);
+    if (removed.count === 0) {
+      deps.err(`no stored credential for "${name}".`);
+      return 1;
+    }
+    deps.log(`Forgot ${removed.count} stored credential(s) for "${name}".`);
+    return 0;
+  }
+  const existing = readCredential(name, url, deps.configDir);
+  if (existing.problem !== undefined) {
+    deps.err(existing.problem);
+    return 1;
+  }
+  if (existing.record === undefined) {
+    deps.log(`"${name}" has no stored credential; nothing to forget.`);
+    return 0;
+  }
+  const cleared = clearCredential(name, url, deps.configDir);
+  if (!cleared.ok) {
+    deps.err(cleared.error);
+    return 1;
+  }
+  deps.log(`Forgot the stored credential for "${name}".`);
+  deps.log(`Run \`keryx mcp auth ${name}\` to authorise again.`);
+  return 0;
+}
+async function authCommand(args, deps) {
+  const own = splitAtSeparator(args).own;
+  const unknown = own.filter((arg, index, all) => isUnknownFlag(arg, index, all));
+  if (unknown.length > 0) {
+    deps.err(`unknown option ${unknown[0]}`);
+    return 1;
+  }
+  const name = positional3(args);
+  if (name === undefined) {
+    deps.err("usage: keryx mcp auth <name>");
+    return 1;
+  }
+  const config = load(deps);
+  const server = config.servers.find((candidate) => candidate.name === name);
+  if (server === undefined) {
+    deps.err(config.servers.length === 0 ? `no server named "${name}" \u2014 no MCP servers are configured` : `no server named "${name}". Configured: ${config.servers.map((s) => s.name).join(", ")}`);
+    return 1;
+  }
+  if (transportOf(server) !== "http") {
+    deps.err(`"${name}" is a local (stdio) server; OAuth applies to remote ones.`);
+    return 1;
+  }
+  if (requiresApproval(server, loadTrustStore(deps.configDir))) {
+    deps.err(`"${name}" is a project server that has not been approved.`);
+    deps.err(`Read what it connects to, then: keryx mcp trust ${name}`);
+    return 1;
+  }
+  const env = deps.env ?? process.env;
+  const targetProblem = remoteTargetProblem(server.raw, env);
+  if (targetProblem !== undefined) {
+    deps.err(`"${name}": ${targetProblem}`);
+    return 1;
+  }
+  if (!usesOAuth(server.raw)) {
+    deps.err(`"${name}" does not use OAuth \u2014 it authenticates with a header or bearer_token_env_var.`);
+    deps.err("Nothing to do. Remove that credential first if you meant to switch to OAuth.");
+    return 1;
+  }
+  const interactive = resolveInteractive(deps.interactive, process.stdin, process.stdout);
+  if (!interactive) {
+    deps.err(`"${name}" needs OAuth, and this process has no terminal to ask in.`);
+    deps.err("Run `keryx mcp auth " + name + "` from an interactive shell.");
+    return 1;
+  }
+  deps.log(`Authorising "${name}" at ${displayUrl(server.raw.url)}\u2026`);
+  deps.log("A browser window will open. keryx never sees your password \u2014 only the token the server issues.");
+  return await runOAuthFlow(server, deps);
+}
+async function runOAuthFlow(server, deps) {
+  const configuredPort = server.oauth === false ? undefined : server.oauth?.callbackPort;
+  const listener = startCallbackListener(configuredPort === undefined ? {} : { port: configuredPort });
+  try {
+    const provider = createOAuthProvider({
+      serverName: server.name,
+      serverUrl: server.url,
+      ...deps.configDir === undefined ? {} : { configDir: deps.configDir },
+      interactive: true,
+      openBrowser: deps.openBrowser ?? ((url) => {
+        openAuthorisationUrl(url, deps.log);
+      }),
+      redirectUrl: listener.redirectUrl,
+      state: listener.state,
+      ...server.oauth === false || server.oauth?.clientId === undefined ? {} : { clientId: server.oauth.clientId },
+      ...server.oauth === false || server.oauth?.scopes === undefined ? {} : { scopes: server.oauth.scopes }
+    });
+    let opened = false;
+    const legOne = await connectHttpMcpServer(server.url, {
+      authProvider: {
+        ...provider,
+        redirectToAuthorization: async (url) => {
+          opened = true;
+          await provider.redirectToAuthorization(url);
+        }
+      },
+      handshakeTimeoutMs: 30000
+    }).then((connection) => ({ ok: true, connection }), (error) => ({ ok: false, error }));
+    if (legOne.ok) {
+      await legOne.connection.close();
+      const existing = readCredential(server.name, server.url, deps.configDir).record;
+      if (existing?.tokens === undefined) {
+        deps.log(`"${server.name}" connects without authentication; there is nothing to authorise.`);
+      } else {
+        deps.log(`"${server.name}" is already authorised; nothing to do.`);
+      }
+      return 0;
+    }
+    if (!opened) {
+      const message = legOne.error instanceof Error ? legOne.error.message : String(legOne.error);
+      deps.err(`Could not start authorisation for "${server.name}": ${sanitiseForDisplay(message)}`);
+      return 1;
+    }
+    const result = await listener.result;
+    if (!result.ok) {
+      deps.err(`Authorisation did not complete: ${result.reason}`);
+      return 1;
+    }
+    const sdk = await loadAuthSdk();
+    await sdk.auth(provider, { serverUrl: server.url, authorizationCode: result.code });
+    const stored = readCredential(server.name, server.url, deps.configDir).record;
+    if (stored?.tokens === undefined || stored.tokens.access_token === "") {
+      deps.err("The exchange returned no token. Nothing was stored.");
+      return 1;
+    }
+    deps.log(`Authorised "${server.name}" \u2014 ${describeCredential(stored, Date.now())}.`);
+    deps.log(`Stored owner-only in ${credentialsFile(deps.configDir)}.`);
+    return 0;
+  } catch (error) {
+    deps.err(`Authorisation failed: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  } finally {
+    listener.close();
+  }
+}
+async function loadAuthSdk() {
+  const mod = await import("@modelcontextprotocol/sdk/client/auth.js");
+  return mod;
+}
+function resolveInteractive(explicit, stdin, stdout) {
+  return explicit ?? bothStreamsAreATerminal(stdin, stdout);
+}
+function bothStreamsAreATerminal(stdin, stdout) {
+  return stdin.isTTY === true && stdout.isTTY === true;
+}
+function openAuthorisationUrl(url, log, platform = process.platform, env = process.env, open = openVerificationUrl) {
+  const plan = browserOpenPlan(url.toString(), platform, env);
+  if (plan === undefined) {
+    log("No graphical session detected, so nothing was opened.");
+    log(`Open this URL yourself to continue:
+
+  ${url.toString()}
+`);
+    return;
+  }
+  open(url.toString(), { platform, env });
+}
 function removeCommand(args, deps) {
   const own = splitAtSeparator(args).own;
   const unknown = own.filter((arg, index, all) => isUnknownFlag(arg, index, all));
@@ -71928,9 +72815,10 @@ async function doctorCommand(args, deps) {
     const env = deps.env ?? process.env;
     report = await runDoctor2(config, {
       only,
-      connect: deps.connect ?? ((server) => defaultConnect(server, env, dialling.signal, kills)),
+      connect: deps.connect ?? ((server) => defaultConnect(server, env, dialling.signal, kills, deps.configDir)),
       heldForApproval: (server) => requiresApproval(server, approvals),
-      env
+      env,
+      configDir: deps.configDir
     });
   } finally {
     process.removeListener("SIGINT", onInt);
@@ -72037,12 +72925,12 @@ function positional3(args) {
 
 // src/commands/serve-mcp.ts
 init_args();
-import path174 from "path";
+import path175 from "path";
 
 // src/mcp/discovery.ts
 init_fs();
 init_json();
-import path168 from "path";
+import path169 from "path";
 var MODULE_MANIFEST_KEY = {
   gdgraph: "gdgraph",
   security: "security",
@@ -72104,7 +72992,7 @@ function buildDiscovery(manifest) {
   };
 }
 async function loadDiscovery(cwd) {
-  const manifestPath = path168.join(cwd, ".metaproject", "metaproject.json");
+  const manifestPath = path169.join(cwd, ".metaproject", "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return buildDiscovery({});
   }
@@ -72175,17 +73063,17 @@ init_sac();
 init_workspace_service();
 init_store2();
 init_fs();
-import { createHash as createHash34, randomUUID as randomUUID17 } from "crypto";
+import { createHash as createHash35, randomUUID as randomUUID17 } from "crypto";
 import { appendFile as appendFile7, mkdir as mkdir58, open as open2, readFile as readFile93, rename as rename7, rm as rm12, stat as stat16, writeFile as writeFile50 } from "fs/promises";
-import path169 from "path";
+import path170 from "path";
 
 // src/sac/policy-experiment.ts
-import { createHash as createHash33, createHmac as createHmac2 } from "crypto";
+import { createHash as createHash34, createHmac as createHmac2 } from "crypto";
 
 // src/sac/receipt-integrity.ts
 init_sac();
-import { createHash as createHash32 } from "crypto";
-var sha2563 = (value) => createHash32("sha256").update(value, "utf8").digest("hex");
+import { createHash as createHash33 } from "crypto";
+var sha2563 = (value) => createHash33("sha256").update(value, "utf8").digest("hex");
 function bodyOf(receipt) {
   const { integrity: _integrity, ...body } = receipt;
   return body;
@@ -72242,7 +73130,7 @@ function stableValue(value) {
   return value;
 }
 var stableJson2 = (value) => JSON.stringify(stableValue(value));
-var sha2564 = (value) => createHash33("sha256").update(stableJson2(value), "utf8").digest("hex");
+var sha2564 = (value) => createHash34("sha256").update(stableJson2(value), "utf8").digest("hex");
 var workspacePathPattern2 = /^\.\/(?!.*(?:^|\/)\.\.(?:\/|$))(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+$/;
 var trustedOutcomes = new WeakMap;
 var trustedSandboxEvidence = new WeakMap;
@@ -72262,7 +73150,7 @@ function policyCorpusDigest(manifest, rows, quarantine) {
 function splitFor(receiptHash, outcome, split) {
   if (outcome.caseClass === "adversarial")
     return "adversarial";
-  const byte = Number.parseInt(createHash33("sha256").update(`${split.seed}\x00${receiptHash}`).digest("hex").slice(0, 2), 16);
+  const byte = Number.parseInt(createHash34("sha256").update(`${split.seed}\x00${receiptHash}`).digest("hex").slice(0, 2), 16);
   return byte / 256 * 100 < split.holdoutPercent ? "holdout" : "train";
 }
 function quarantineCounts(entries) {
@@ -72346,12 +73234,12 @@ var stableValue2 = (value) => {
   return value;
 };
 var stableJson3 = (value) => JSON.stringify(stableValue2(value));
-var sha2565 = (value) => createHash34("sha256").update(stableJson3(value), "utf8").digest("hex");
+var sha2565 = (value) => createHash35("sha256").update(stableJson3(value), "utf8").digest("hex");
 var isImmutableVersion2 = (value) => typeof value === "string" && value.length >= 3 && value.length <= 256 && /^[A-Za-z0-9][A-Za-z0-9._:+-]*$/.test(value) && /\d/.test(value) && !immutableVersionPattern.test(value);
 var receiptHashPattern2 = /^[a-f0-9]{64}$/;
 var ledgerDigestChunkBytes = 64 * 1024;
 var isMissing = (error) => error instanceof Error && error.code === "ENOENT";
-var checkpointHash = (body) => createHash34("sha256").update(JSON.stringify(body), "utf8").digest("hex");
+var checkpointHash = (body) => createHash35("sha256").update(JSON.stringify(body), "utf8").digest("hex");
 async function ledgerByteLength(ledger) {
   const value = await stat16(ledger, { bigint: true });
   if (value.size > BigInt(Number.MAX_SAFE_INTEGER))
@@ -72359,7 +73247,7 @@ async function ledgerByteLength(ledger) {
   return Number(value.size);
 }
 async function digestLedgerPrefix(handle, byteLength) {
-  const digest = createHash34("sha256");
+  const digest = createHash35("sha256");
   if (byteLength === 0)
     return digest;
   const buffer = Buffer.alloc(Math.min(ledgerDigestChunkBytes, byteLength));
@@ -72483,7 +73371,7 @@ async function auditLedger(ledger, checkpointPath, verifier) {
   const verification = await verifier(receipts);
   if (!verification.ok)
     throw new Error(`invalid access receipt ledger: ${verification.reason} at record ${verification.firstInvalidIndex}`);
-  const digest = createHash34("sha256").update(bytes);
+  const digest = createHash35("sha256").update(bytes);
   const tailOffset = receipts.length === 0 ? 0 : bytes.lastIndexOf(10, bytes.length - 2) + 1;
   const state = { ledgerBytes: bytes.length, recordCount: receipts.length, headHash: verification.headHash, tailOffset, digest };
   await writeCheckpoint(checkpointPath, { schemaVersion: "1.1", ledgerBytes: state.ledgerBytes, recordCount: state.recordCount, headHash: state.headHash, tailOffset, contentDigest: digest.copy().digest("hex") });
@@ -72499,7 +73387,7 @@ async function resolveLedgerState(ledger, checkpointPath, verifier) {
       throw error;
     if (document.present)
       throw new Error("invalid access receipt ledger: orphaned-checkpoint");
-    return { ledgerBytes: 0, recordCount: 0, headHash: "GENESIS", tailOffset: 0, digest: createHash34("sha256") };
+    return { ledgerBytes: 0, recordCount: 0, headHash: "GENESIS", tailOffset: 0, digest: createHash35("sha256") };
   }
   if (document.checkpoint) {
     const fast = await fastCheckpointState(ledger, document.checkpoint, ledgerBytes);
@@ -72518,7 +73406,7 @@ var isConfigRecord = (value) => typeof value.enabled === "boolean" && typeof val
 async function readPinnedJson(input) {
   const ref = await resolveWorkspaceReference({ workspaceRoot: input.workspaceRoot, kind: "artifact", uri: input.uri });
   const raw = await readFile93(ref, "utf8");
-  const digest = createHash34("sha256").update(raw).digest("hex");
+  const digest = createHash35("sha256").update(raw).digest("hex");
   if (digest !== input.digest)
     throw new Error("policy experiment pinned artifact digest mismatch");
   return { artifact: JSON.parse(raw), digest };
@@ -72533,7 +73421,7 @@ function hasReportIntegrity(report) {
   return reportHashPattern.test(reportDigest) && sha2565(body) === reportDigest;
 }
 async function resolvePolicySelection(workspaceRoot, canonicalFallback) {
-  const configPath = path169.join(workspaceRoot, ...policyExperimentConfigPath);
+  const configPath = path170.join(workspaceRoot, ...policyExperimentConfigPath);
   let configJson;
   try {
     const raw = await readFile93(configPath, "utf8").catch((error) => {
@@ -72635,7 +73523,7 @@ async function diagnosePolicyReadiness(workspaceRoot) {
     const integrityReady = steps.every((entry) => entry.step === "activation-flags" || entry.status === "pass");
     return Object.freeze({ configPresent, enabled, killSwitch, integrityReady, candidateWouldActivate: integrityReady && enabled && !killSwitch, steps: Object.freeze([...steps]) });
   };
-  const configPath = path169.join(workspaceRoot, ...policyExperimentConfigPath);
+  const configPath = path170.join(workspaceRoot, ...policyExperimentConfigPath);
   let configJson;
   try {
     const raw = await readFile93(configPath, "utf8").catch((error) => {
@@ -72890,9 +73778,9 @@ class FwkReadService {
     const recordedAt = nowIso2(now);
     const id = `receipt-${randomUUID17().replace(/-/g, "").slice(0, 16)}`;
     const base = { schemaVersion: "1.0", id, workspaceId, actor, action, decision, recordedAt, cost: { tokens: 0, toolCalls: 1, elapsedMs: 0 }, contextAssembly: { traceRef: assembly.traceRef, configurationRevision: assembly.configurationRevision, selected: assembly.selected.map((id) => `./ids/${id}`), omittedOptional: assembly.omittedOptional.map((id) => `./ids/${id}`) }, policy: { ref: assembly.policyRef, revision: assembly.policyRevision }, ...action === "resource" ? { resourceRef: `./ids/${resourceId ?? "unknown"}` } : {} };
-    const ledger = path169.join(this.options.canonical.workspaceRoot, ".metaproject", "context-operations", "access-receipts.jsonl");
-    const checkpointPath = path169.join(path169.dirname(ledger), "access-receipts.checkpoint.json");
-    await mkdir58(path169.dirname(ledger), { recursive: true, mode: 448 });
+    const ledger = path170.join(this.options.canonical.workspaceRoot, ".metaproject", "context-operations", "access-receipts.jsonl");
+    const checkpointPath = path170.join(path170.dirname(ledger), "access-receipts.checkpoint.json");
+    await mkdir58(path170.dirname(ledger), { recursive: true, mode: 448 });
     return withFileLock(`${ledger}.lock`, async () => {
       const state = await resolveLedgerState(ledger, checkpointPath, this.options.verifyReceiptLedger ?? verifyAccessReceiptLedger);
       const receipt = sealAccessReceipt(base, state.headHash);
@@ -72948,7 +73836,7 @@ function createLocalFwkReadService(cwd, opts) {
       const facts = await Promise.all(manifest.resources.filter((resource) => resource.kind === "evidence").map(async (resource, index) => {
         try {
           const raw = await workspaces.readResourceForActor({ actorContext, workspaceId, resource });
-          const revision = createHash34("sha256").update(raw).digest("hex");
+          const revision = createHash35("sha256").update(raw).digest("hex");
           return { id: `fact-${index}`, uri: resource.uri, revision: resource.revision ?? revision, observedAt: manifest.updatedAt, expiresAt: "9999-12-31T23:59:59Z", trust: "primary", visible: true, statement: `Evidence reference ${resource.uri}`, status: resource.revision === revision || resource.revision === undefined ? "fresh" : "stale" };
         } catch (error) {
           withhold(error);
@@ -72958,7 +73846,7 @@ function createLocalFwkReadService(cwd, opts) {
       const knowHow = await Promise.all(manifest.resources.filter((resource) => resource.kind === "wiki" || resource.kind === "memory" || resource.kind === "skill").map(async (resource, index) => {
         try {
           const raw = await workspaces.readResourceForActor({ actorContext, workspaceId, resource, encoding: "utf8" });
-          const revision = createHash34("sha256").update(raw).digest("hex");
+          const revision = createHash35("sha256").update(raw).digest("hex");
           const accepted = /^Status:\s*(accepted|reviewed)\s*$/mi.test(raw);
           return { id: `knowhow-${index}`, kind: resource.kind, uri: resource.uri, revision: resource.revision ?? revision, trust: "accepted", status: resource.revision === revision || resource.revision === undefined ? "fresh" : "stale", accepted, visible: true };
         } catch (error) {
@@ -73004,7 +73892,7 @@ init_workspace_service();
 init_sac();
 import { appendFile as appendFile8, mkdir as mkdir59, readFile as readFile94 } from "fs/promises";
 import { randomUUID as randomUUID18 } from "crypto";
-import path170 from "path";
+import path171 from "path";
 
 class CollaborationServiceError extends Error {
   code;
@@ -73020,7 +73908,7 @@ class CollaborationService {
     this.input = input;
   }
   file(id) {
-    return path170.join(this.input.workspaceRoot, ".metaproject", "workspaces", id, "activity.jsonl");
+    return path171.join(this.input.workspaceRoot, ".metaproject", "workspaces", id, "activity.jsonl");
   }
   async overview(input) {
     const manifest = await this.input.workspaces.show(input);
@@ -73057,7 +73945,7 @@ class CollaborationService {
         occurredAt: (this.input.now ?? (() => new Date))().toISOString(),
         ...suppliedHandoff ? { handoff: { ...suppliedHandoff, from: actor.subject } } : {}
       });
-      await mkdir59(path170.dirname(this.file(manifest.id)), { recursive: true, mode: 448 });
+      await mkdir59(path171.dirname(this.file(manifest.id)), { recursive: true, mode: 448 });
       await appendFile8(this.file(manifest.id), `${JSON.stringify(activity)}
 `, { mode: 384 });
       return normalizeCollaborationResult(activity);
@@ -73112,9 +74000,9 @@ init_workspace_service();
 init_fs();
 init_machine_wrap_up();
 import { mkdir as mkdir60, readdir as readdir31, readFile as readFile95 } from "fs/promises";
-import path171 from "path";
+import path172 from "path";
 function externalSlatesDir(cwd) {
-  return path171.join(cwd, ".keryx", "external-slates");
+  return path172.join(cwd, ".keryx", "external-slates");
 }
 var EXTERNAL_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 function assertValidExternalSessionId(externalSessionId) {
@@ -73124,14 +74012,14 @@ function assertValidExternalSessionId(externalSessionId) {
 }
 function externalSlatePath(cwd, externalSessionId) {
   assertValidExternalSessionId(externalSessionId);
-  return path171.join(externalSlatesDir(cwd), `${externalSessionId}.json`);
+  return path172.join(externalSlatesDir(cwd), `${externalSessionId}.json`);
 }
 function externalSlateLockPath(cwd, externalSessionId) {
   return `${externalSlatePath(cwd, externalSessionId)}.lock`;
 }
 function externalSlateEvidenceDir(cwd, externalSessionId) {
   assertValidExternalSessionId(externalSessionId);
-  return path171.join(externalSlatesDir(cwd), externalSessionId);
+  return path172.join(externalSlatesDir(cwd), externalSessionId);
 }
 async function readExternalSlate(cwd, externalSessionId) {
   try {
@@ -73776,8 +74664,8 @@ function buildToolRegistry() {
 // src/mcp/resources.ts
 init_fs();
 init_contained_read();
-import path172 from "path";
-import { lstat as lstat4, readdir as readdir32, realpath as realpath7, stat as stat17 } from "fs/promises";
+import path173 from "path";
+import { lstat as lstat5, readdir as readdir32, realpath as realpath7, stat as stat17 } from "fs/promises";
 var URI_PREFIX = "metaproject://";
 function mimeForPath(filePath) {
   if (filePath.endsWith(".json") || filePath.endsWith(".jsonl")) {
@@ -73789,20 +74677,20 @@ function mimeForPath(filePath) {
   return "text/plain";
 }
 function dataRoot3(cwd) {
-  return path172.join(cwd, ".metaproject", "data");
+  return path173.join(cwd, ".metaproject", "data");
 }
 function wikiRoot(cwd) {
-  return path172.join(cwd, ".metaproject", "wiki");
+  return path173.join(cwd, ".metaproject", "wiki");
 }
 function memoryRoot2(cwd) {
-  return path172.join(cwd, ".metaproject", "memory");
+  return path173.join(cwd, ".metaproject", "memory");
 }
 var MAX_RESOURCE_BYTES = 8 * 1024 * 1024;
 async function walkFiles(root, ownerRoot = root, ancestors = new Set) {
   if (!await pathExists(root)) {
     return [];
   }
-  const ownerInfo = await lstat4(ownerRoot).catch(() => null);
+  const ownerInfo = await lstat5(ownerRoot).catch(() => null);
   if (!ownerInfo || !ownerInfo.isDirectory() || ownerInfo.isSymbolicLink())
     return [];
   const ownerReal = await realpath7(ownerRoot).catch(() => null);
@@ -73821,7 +74709,7 @@ async function walkFiles(root, ownerRoot = root, ancestors = new Set) {
     return [];
   }
   for (const entry of entries) {
-    const full = path172.join(root, entry.name);
+    const full = path173.join(root, entry.name);
     const info = await stat17(full).catch(() => null);
     if (!info || !isPathInside(ownerReal, await realpath7(full).catch(() => "")))
       continue;
@@ -73849,9 +74737,9 @@ async function listArtifacts(cwd) {
     if (!moduleEntry.isDirectory()) {
       continue;
     }
-    const artifactsDir = path172.join(base, moduleEntry.name, "artifacts");
+    const artifactsDir = path173.join(base, moduleEntry.name, "artifacts");
     for (const file of await walkFiles(artifactsDir)) {
-      const rel = toPosix(path172.relative(artifactsDir, file));
+      const rel = toPosix(path173.relative(artifactsDir, file));
       const relPath = `${moduleEntry.name}/${rel}`;
       listings.push({
         uri: `${URI_PREFIX}artifacts/${relPath}`,
@@ -73865,7 +74753,7 @@ async function listArtifacts(cwd) {
 async function listUnderRoot(cwd, cls, root) {
   const listings = [];
   for (const file of await walkFiles(root)) {
-    const rel = toPosix(path172.relative(root, file));
+    const rel = toPosix(path173.relative(root, file));
     listings.push({
       uri: `${URI_PREFIX}${cls}/${rel}`,
       name: rel,
@@ -73915,12 +74803,12 @@ function resolveConfined(cwd, cls, relPath) {
     if (moduleName.includes("..") || moduleName.length === 0) {
       return null;
     }
-    const root = path172.join(dataRoot3(cwd), moduleName, "artifacts");
-    const absolute = path172.resolve(root, rest);
+    const root = path173.join(dataRoot3(cwd), moduleName, "artifacts");
+    const absolute = path173.resolve(root, rest);
     return isPathInside(root, absolute) ? { root, absolute } : null;
   }
   const root = cls === "wiki" ? wikiRoot(cwd) : memoryRoot2(cwd);
-  const absolute = path172.resolve(root, relPath);
+  const absolute = path173.resolve(root, relPath);
   return isPathInside(root, absolute) ? { root, absolute } : null;
 }
 async function readResource(cwd, roots, uri) {
@@ -74131,7 +75019,7 @@ async function serveMcpCommand(args = [], cwd = process.cwd()) {
     return;
   }
   const http = args.includes("--http");
-  const projectRoot = path174.resolve(resolveServeRoot(optionValue(args, "--cwd"), cwd, process.env));
+  const projectRoot = path175.resolve(resolveServeRoot(optionValue(args, "--cwd"), cwd, process.env));
   try {
     await serveMcp({ cwd: projectRoot, http });
   } catch (error) {
@@ -74207,7 +75095,9 @@ function printMcpHelp() {
     "keryx mcp add <name> --transport http <url>    # a remote one",
     "keryx mcp remove|enable|disable <name>",
     "keryx mcp trust|untrust <name>                 # approve a project-scoped server",
-    "keryx mcp doctor [name] [--json]               # dial it and say what is wrong"
+    "keryx mcp doctor [name] [--json]               # dial it and say what is wrong",
+    "keryx mcp auth <name>                          # authorise a remote server in your browser",
+    "keryx mcp logout <name>                        # forget its stored credential"
   ]);
   heading("Publishing keryx itself (the retired `keryx mcp` spellings)");
   helpUsage([
@@ -74233,14 +75123,14 @@ function printMcpHelp() {
 // src/commands/status.ts
 init_fs();
 init_json();
-import path175 from "path";
+import path176 from "path";
 async function statusCommand(args = []) {
   if (args.includes("--help") || args.includes("-h")) {
     printHelp16();
     return;
   }
-  const root = path175.join(process.cwd(), ".metaproject");
-  const manifestPath = path175.join(root, "metaproject.json");
+  const root = path176.join(process.cwd(), ".metaproject");
+  const manifestPath = path176.join(root, "metaproject.json");
   if (!await pathExists(root)) {
     console.log("Metaproject: not initialized");
     console.log("Run: keryx init");
@@ -74280,7 +75170,7 @@ Reports the workspace root and one enabled/disabled line per module. Use
 
 // src/commands/harness.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
-import path178 from "path";
+import path179 from "path";
 import { randomUUID as randomUUID20 } from "crypto";
 
 // src/security/harness-scan.ts
@@ -74336,7 +75226,7 @@ init_make_provider();
 init_profiles();
 
 // src/harness/run/run.ts
-import { createHash as createHash38 } from "crypto";
+import { createHash as createHash39 } from "crypto";
 
 // src/harness/completion/gate.ts
 var SCHEMA_VERSION3 = 1;
@@ -74387,10 +75277,10 @@ function evaluateCompletion(input, deps) {
 }
 
 // src/harness/evidence/redaction.ts
-import { createHash as createHash35 } from "crypto";
+import { createHash as createHash36 } from "crypto";
 var CLEAN_CATEGORY = "none";
 function hashContent(content) {
-  return createHash35("sha256").update(content, "utf8").digest("hex");
+  return createHash36("sha256").update(content, "utf8").digest("hex");
 }
 function redactForPersistence(content, deps) {
   const scan = deps.scan(content);
@@ -74441,7 +75331,7 @@ async function metaprojectBlastRadius(port, target) {
 }
 
 // src/harness/session/session.ts
-import { createHash as createHash36 } from "crypto";
+import { createHash as createHash37 } from "crypto";
 var SCHEMA_VERSION4 = 1;
 function canonicalStringify(value) {
   if (Array.isArray(value)) {
@@ -74455,7 +75345,7 @@ function canonicalStringify(value) {
   return JSON.stringify(value) ?? "null";
 }
 function sha2566(input) {
-  return createHash36("sha256").update(input, "utf8").digest("hex");
+  return createHash37("sha256").update(input, "utf8").digest("hex");
 }
 function deepFreeze(value) {
   if (value !== null && typeof value === "object") {
@@ -74547,11 +75437,11 @@ class AppendOnlySession {
 }
 
 // src/harness/context/manifest.ts
-import { createHash as createHash37 } from "crypto";
+import { createHash as createHash38 } from "crypto";
 var MAX_CONTEXT_BYTES = 2 * 1024 * 1024;
 var MAX_CONTEXT_TOKENS = 200000;
 function sha2567(input) {
-  return createHash37("sha256").update(input, "utf8").digest("hex");
+  return createHash38("sha256").update(input, "utf8").digest("hex");
 }
 function normalizeSource2(value) {
   const record = typeof value === "object" && value !== null ? value : {};
@@ -74677,7 +75567,7 @@ function canonicalize2(value) {
   return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalize2(record[key])}`).join(",")}}`;
 }
 function sha2568(input) {
-  return createHash38("sha256").update(input, "utf8").digest("hex");
+  return createHash39("sha256").update(input, "utf8").digest("hex");
 }
 function uniqueInOrder2(values) {
   const seen = new Set;
@@ -75115,7 +76005,7 @@ function replayOffline(fixture, run, deps) {
 }
 
 // src/harness/tool/registry.ts
-import { createHash as createHash39 } from "crypto";
+import { createHash as createHash40 } from "crypto";
 function canonicalize3(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value) ?? "null";
@@ -75129,7 +76019,7 @@ function canonicalize3(value) {
   return `{${entries.join(",")}}`;
 }
 function sha2569(input) {
-  return createHash39("sha256").update(input, "utf8").digest("hex");
+  return createHash40("sha256").update(input, "utf8").digest("hex");
 }
 function definitionHash(definition) {
   return sha2569(canonicalize3(definition));
@@ -75280,11 +76170,11 @@ function runContainedProcess(input, deps) {
 
 // src/harness/process/real-process-adapter.ts
 import { spawnSync } from "child_process";
-import { createHash as createHash40 } from "crypto";
+import { createHash as createHash41 } from "crypto";
 var DEFAULT_TIMEOUT_MS = 5000;
 var DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
 function sha256Hex4(input) {
-  return createHash40("sha256").update(input, "utf8").digest("hex");
+  return createHash41("sha256").update(input, "utf8").digest("hex");
 }
 function byteLength(chunk) {
   if (chunk === null || chunk === undefined)
@@ -75353,7 +76243,7 @@ ${command.argv.join(" ")}`);
 }
 
 // src/harness/process/sandbox/profile.ts
-import path176 from "path";
+import path177 from "path";
 var DEFAULT_SECRET_SUBPATHS = [
   ".ssh",
   ".gnupg",
@@ -75378,7 +76268,7 @@ function defaultReadDenyList(home) {
   if (!home) {
     return [];
   }
-  return DEFAULT_SECRET_SUBPATHS.map((sub) => path176.join(home, sub));
+  return DEFAULT_SECRET_SUBPATHS.map((sub) => path177.join(home, sub));
 }
 function defaultSandboxProfile(cwd, tmpDir, home) {
   return {
@@ -75398,10 +76288,10 @@ function dedupe3(values) {
 init_config_dir();
 init_shell_config();
 import { existsSync as existsSync26 } from "fs";
-import path177 from "path";
+import path178 from "path";
 var SECRET_KEY_PATTERN2 = /api[_-]?key|secret|token|password|credential/i;
 function sandboxConfigPath(dir) {
-  return path177.join(path177.dirname(shellConfigPath(dir)), "sandbox.json");
+  return path178.join(path178.dirname(shellConfigPath(dir)), "sandbox.json");
 }
 function isShellDefault(v) {
   return v === "off" || v === "workspace" || v === "strict" || v === "1";
@@ -76520,7 +77410,7 @@ async function harnessExec(args, deps) {
     env: commandEnv,
     cwd
   };
-  const worktreeRoot = path178.parse(path178.resolve(cwd, commandPath)).root || cwd;
+  const worktreeRoot = path179.parse(path179.resolve(cwd, commandPath)).root || cwd;
   const budget = {
     reservationId: idSeq(),
     maxRuntimeMs: maxRuntimeMs ?? EXEC_DEFAULT_RUNTIME_MS
@@ -77201,12 +78091,14 @@ function resolveShellRestrictedMasks(env, sandboxConfigDir, projectRoot) {
     tlsTerminate: result.resolution.tlsTerminate
   };
 }
-async function resolveShellEnv() {
+async function resolveShellEnv(configDir) {
   await Promise.resolve().then(() => init_shell_config());
-  applySavedApiKeys();
+  const passSaved = process.env.KERYX_SHELL_PASS_SAVED_KEYS === "1";
+  const source = passSaved ? envWithSavedApiKeys(process.env, configDir) : process.env;
+  const withheld = passSaved ? new Set : savedCredentialEnvKeys();
   const env = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (typeof value === "string")
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "string" && !withheld.has(key))
       env[key] = value;
   }
   return env;
@@ -77227,7 +78119,8 @@ async function resolveShellSpawn(root, command, baseEnv, detectOpts) {
   }
   let netClose = async () => {};
   if (profile.network === "restricted") {
-    const masks = resolveShellRestrictedMasks(env, undefined, root);
+    await Promise.resolve().then(() => init_shell_config());
+    const masks = resolveShellRestrictedMasks(envWithSavedApiKeys(env), undefined, root);
     if (!masks.ok)
       return { ok: false, error: `shell_exec: ${masks.reason}` };
     const net = await setupNetworkRun(profile, {
@@ -78466,7 +79359,7 @@ function workspaceReadTool(cwd) {
 // src/harness/tool/builtin/workspace-lifecycle-tool.ts
 import { randomUUID as randomUUID22 } from "crypto";
 import { writeFile as writeFile52 } from "fs/promises";
-import path179 from "path";
+import path180 from "path";
 init_slate();
 init_store3();
 init_guard2();
@@ -78612,7 +79505,7 @@ function workspaceProposeTool(cwd, getSessionDir) {
         return { output: `workspace_propose: unrecognized 'kind' \u2014 expected one of: ${PROPOSAL_KINDS.join(", ")}`, isError: true };
       }
       const explicitSessionId = typeof input.sessionId === "string" && input.sessionId.length > 0 ? input.sessionId : undefined;
-      const sessionRef = explicitSessionId ?? path179.basename(getSessionDir() ?? "");
+      const sessionRef = explicitSessionId ?? path180.basename(getSessionDir() ?? "");
       if (sessionRef.length === 0) {
         return { output: "workspace_propose: no 'sessionId' given and no active session in this run", isError: true };
       }
@@ -78784,8 +79677,8 @@ init_shell_config();
 init_command_risk();
 init_shell_syntax();
 import { existsSync as existsSync30 } from "fs";
-import path180 from "path";
-import { createHash as createHash41 } from "crypto";
+import path181 from "path";
+import { createHash as createHash42 } from "crypto";
 var PREFIX_BANNED = new Set([
   "sh",
   "bash",
@@ -78989,7 +79882,7 @@ function emptyShellPermissions() {
   return { allow: [] };
 }
 function shellPermissionsPath(dir) {
-  return path180.join(path180.dirname(shellConfigPath(dir)), "permissions.json");
+  return path181.join(path181.dirname(shellConfigPath(dir)), "permissions.json");
 }
 function loadShellPermissionsWithAudit(dir) {
   try {
@@ -79027,7 +79920,7 @@ function loadShellPermissions(dir) {
 function saveShellPermissions(perms, dir, options = {}) {
   try {
     const file = shellPermissionsPath(dir);
-    ensureKeryxConfigDir(path180.dirname(file));
+    ensureKeryxConfigDir(path181.dirname(file));
     const cleaned = Array.from(new Set(perms.allow.map((p) => p.trim()).filter((p) => p.length > 0)));
     const body = {
       allow: options.skipValidation === true ? cleaned : cleaned.filter((p) => validateShellPattern(p).ok)
@@ -79105,7 +79998,7 @@ function shellPermissionsFingerprint(dir) {
     if (!read.ok) {
       return "";
     }
-    return createHash41("sha256").update(read.text, "utf8").digest("hex");
+    return createHash42("sha256").update(read.text, "utf8").digest("hex");
   } catch {
     return "";
   }
@@ -79466,12 +80359,12 @@ function remoteRequest(providerId, endpoint, query, key) {
 // src/lib/search-config.ts
 init_config_dir();
 import { existsSync as existsSync31 } from "fs";
-import path181 from "path";
+import path182 from "path";
 function searchConfigPath(dir) {
-  return path181.join(keryxConfigDir(dir), "search-providers.json");
+  return path182.join(keryxConfigDir(dir), "search-providers.json");
 }
 function searchCredentialPath(dir) {
-  return path181.join(keryxConfigDir(dir), "search-credentials.json");
+  return path182.join(keryxConfigDir(dir), "search-credentials.json");
 }
 function readJson5(file) {
   try {
@@ -79597,10 +80490,10 @@ function createDefaultSearchProviderController(configDir) {
   return new SearchProviderController(registry, configDir);
 }
 // src/harness/tool/builtin/spawn-subagent-tool.ts
-import { createHash as createHash42, randomUUID as randomUUID24 } from "crypto";
+import { createHash as createHash43, randomUUID as randomUUID24 } from "crypto";
 import { mkdtemp, rm as rm13 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import path182 from "path";
+import path183 from "path";
 init_metaproject_adapter();
 init_ledger();
 init_orchestrate();
@@ -79647,7 +80540,7 @@ function readExternalRuntimeRequest(input) {
   return raw.kind === "external" ? raw : undefined;
 }
 function sha25610(text) {
-  return createHash42("sha256").update(text).digest("hex");
+  return createHash43("sha256").update(text).digest("hex");
 }
 var parentShellPolicy = shellParentProfile;
 var childReadOnlyPolicy = shellChildReadOnlyProfile;
@@ -79863,8 +80756,8 @@ function createSpawnSubagentTool(deps) {
       let dispatchId = "";
       let closing = false;
       try {
-        ephemeralDir = await mkdtemp(path182.join(tmpdir4(), "keryx-subagent-slate-"));
-        dispatchId = path182.basename(ephemeralDir);
+        ephemeralDir = await mkdtemp(path183.join(tmpdir4(), "keryx-subagent-slate-"));
+        dispatchId = path183.basename(ephemeralDir);
         openedChildSlate = await openSlate({
           dir: ephemeralDir,
           cwd,
@@ -80107,7 +81000,7 @@ import { randomUUID as randomUUID25 } from "crypto";
 import { execFile as execFile4 } from "child_process";
 import { mkdir as mkdir61 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import path184 from "path";
+import path185 from "path";
 import { promisify as promisify4 } from "util";
 
 // src/harness/child/git-worktree-port.ts
@@ -80359,7 +81252,7 @@ function readRuntimeBlock(dispatch) {
 // src/harness/external/runtime.ts
 import { mkdtemp as mkdtemp2, rm as rm14, writeFile as writeFile53 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
-import path183 from "path";
+import path184 from "path";
 
 // src/harness/external/prompt.ts
 var EXTERNAL_RUNTIME_DIRECTIVE = [
@@ -81402,8 +82295,8 @@ async function prepareResultSchema() {
   try {
     const schema = await loadSchema("subagent-result");
     const schemaText = JSON.stringify(schema, null, 2);
-    schemaDir = await mkdtemp2(path183.join(tmpdir5(), "keryx-external-result-schema-"));
-    const schemaPath = path183.join(schemaDir, "subagent-result.schema.json");
+    schemaDir = await mkdtemp2(path184.join(tmpdir5(), "keryx-external-result-schema-"));
+    const schemaPath = path184.join(schemaDir, "subagent-result.schema.json");
     await writeFile53(schemaPath, schemaText, "utf8");
     return { ok: true, schema, schemaText, schemaPath, schemaDir };
   } catch (error) {
@@ -81660,7 +82553,7 @@ async function createRunExternal(options) {
   }
   const config = gate.config;
   const idSeq = options.idSeq ?? (() => randomUUID25());
-  const worktreesDir = options.worktreesDir ?? path184.join(tmpdir6(), "keryx-external-worktrees");
+  const worktreesDir = options.worktreesDir ?? path185.join(tmpdir6(), "keryx-external-worktrees");
   const spawn = options.spawn ?? createBunSpawnPort();
   const worktree = options.worktree ?? ensuringParentDir(createGitWorktreePort({ repoRoot: options.cwd, worktreesDir }), worktreesDir);
   const readWorkingDiff = options.readWorkingDiff ?? (() => defaultWorkingDiff(options.cwd));
@@ -81970,7 +82863,7 @@ class LiveMarkdownBlock {
 // src/tui/theme.ts
 init_config_dir();
 import { existsSync as existsSync32 } from "fs";
-import path185 from "path";
+import path186 from "path";
 var THEME_NAMES = ["groknight", "grokday", "tokyonight", "keryx"];
 var THEME_IDS = ["auto", ...THEME_NAMES];
 var DEFAULT_THEME_ID = "groknight";
@@ -82100,7 +82993,7 @@ function onThemeChange(listener) {
   };
 }
 function tuiConfigPath(dir) {
-  return path185.join(keryxConfigDir(dir), "tui.json");
+  return path186.join(keryxConfigDir(dir), "tui.json");
 }
 function loadPersistedThemeId(dir) {
   try {
@@ -82157,7 +83050,7 @@ init_workspace_service();
 init_service8();
 init_store2();
 init_fs();
-import path186 from "path";
+import path187 from "path";
 import { readFile as readFile97 } from "fs/promises";
 var POSITIVE_INTEGER = /^[1-9][0-9]*$/;
 var DEFAULT_AUTO_GOAL_ROUNDS = 8;
@@ -82233,7 +83126,7 @@ function getFlowService() {
 async function autoProvisionFlow(cwd, goalText) {
   const service = getFlowService();
   const result = await service.init({ cwd, title: goalText });
-  const acFile = path186.join(cwd, result.dir, "acceptance-criteria.md");
+  const acFile = path187.join(cwd, result.dir, "acceptance-criteria.md");
   await writeFileAtomic(acFile, [
     "# Acceptance Criteria",
     "",
@@ -83784,7 +84677,7 @@ init_proposal_lifecycle();
 init_workspace_service();
 import { randomUUID as randomUUID27 } from "crypto";
 import { readdir as readdir34, stat as stat18 } from "fs/promises";
-import path187 from "path";
+import path188 from "path";
 
 // src/sac/lifecycle-flag.ts
 init_store();
@@ -83943,7 +84836,7 @@ async function readExternalUnboundCandidates(cwd) {
         }
         return groups;
       }, []));
-      const metaPath = path187.join(extDir, `${id}.json`);
+      const metaPath = path188.join(extDir, `${id}.json`);
       if (await pathExists(unboundDismissedReceiptPath(metaPath)))
         continue;
       candidates.push({
@@ -83957,7 +84850,7 @@ async function readExternalUnboundCandidates(cwd) {
   return candidates;
 }
 async function readNewestUnboundCandidateForExternal(cwd, externalSessionId) {
-  const evidenceDir = path187.join(externalSlatesDir(cwd), externalSessionId);
+  const evidenceDir = path188.join(externalSlatesDir(cwd), externalSessionId);
   let entries;
   try {
     entries = (await readdir34(evidenceDir)).filter((name) => name.endsWith("-unbound-candidate.json"));
@@ -83966,7 +84859,7 @@ async function readNewestUnboundCandidateForExternal(cwd, externalSessionId) {
   }
   entries.sort();
   for (let i = entries.length - 1;i >= 0; i--) {
-    const evidencePath = path187.join(evidenceDir, entries[i]);
+    const evidencePath = path188.join(evidenceDir, entries[i]);
     if (await pathExists(unboundDismissedReceiptPath(evidencePath)))
       continue;
     const result = readConfigFile(evidencePath);
@@ -84009,7 +84902,7 @@ var SESSION_ATTRIBUTION_SLACK_MS = 5 * 60000;
 var MTIME_CLOCK_SKEW_TOLERANCE_MS = 5000;
 async function collectReceiptTargets(cwd, owner) {
   const targets = new Set;
-  const workspacesDir = path187.join(cwd, ".metaproject", "workspaces");
+  const workspacesDir = path188.join(cwd, ".metaproject", "workspaces");
   let workspaceIds;
   try {
     workspaceIds = (await readdir34(workspacesDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -84017,7 +84910,7 @@ async function collectReceiptTargets(cwd, owner) {
     return targets;
   }
   for (const workspaceId of workspaceIds) {
-    const receiptsDir = path187.join(workspacesDir, workspaceId, `${owner}-write-receipts`);
+    const receiptsDir = path188.join(workspacesDir, workspaceId, `${owner}-write-receipts`);
     let files;
     try {
       files = (await readdir34(receiptsDir)).filter((name) => name.endsWith(".json"));
@@ -84025,7 +84918,7 @@ async function collectReceiptTargets(cwd, owner) {
       continue;
     }
     for (const file of files) {
-      const result = readConfigFile(path187.join(receiptsDir, file));
+      const result = readConfigFile(path188.join(receiptsDir, file));
       if (!result.ok)
         continue;
       try {
@@ -84068,7 +84961,7 @@ async function findSkillFiles(dir) {
   }
   const found = [];
   for (const entry of entries) {
-    const full = path187.join(dir, entry.name);
+    const full = path188.join(dir, entry.name);
     if (entry.isDirectory()) {
       found.push(...await findSkillFiles(full));
     } else if (entry.isFile() && entry.name === "SKILL.md") {
@@ -84127,10 +85020,10 @@ async function detectUnreviewedSacPathChanges(cwd, sessions) {
       changedAt: attribution.changedAt
     });
   }
-  const sacSkillsDir = path187.join(cwd, ".metaproject", "project-skills", "sac");
+  const sacSkillsDir = path188.join(cwd, ".metaproject", "project-skills", "sac");
   const skillFiles = await findSkillFiles(sacSkillsDir);
   for (const absolutePath of skillFiles) {
-    const targetRef = path187.relative(path187.join(cwd, ".metaproject"), absolutePath).split(path187.sep).join("/");
+    const targetRef = path188.relative(path188.join(cwd, ".metaproject"), absolutePath).split(path188.sep).join("/");
     if (skillReceipts.has(targetRef))
       continue;
     const attribution = await attributeToSession(absolutePath, scoped);
@@ -84148,12 +85041,12 @@ async function detectUnreviewedSacPathChanges(cwd, sessions) {
   return items;
 }
 async function isSlateEngaged(dir) {
-  if (await pathExists(path187.join(dir, "slate.json")))
+  if (await pathExists(path188.join(dir, "slate.json")))
     return true;
-  if (await pathExists(path187.join(dir, "terminal-state.json")))
+  if (await pathExists(path188.join(dir, "terminal-state.json")))
     return true;
   try {
-    const entries = await readdir34(path187.join(dir, "slate-archive"));
+    const entries = await readdir34(path188.join(dir, "slate-archive"));
     return entries.length > 0;
   } catch {
     return false;
@@ -84167,7 +85060,7 @@ async function safeReadSlate(dir) {
   }
 }
 async function readTerminalState(dir) {
-  const result = readConfigFile(path187.join(dir, "terminal-state.json"));
+  const result = readConfigFile(path188.join(dir, "terminal-state.json"));
   if (!result.ok) {
     return;
   }
@@ -84191,7 +85084,7 @@ async function resolveUnboundCandidateTarget(cwd, target) {
   if (session === undefined) {
     throw new Error(`No session or evidence path matches "${target}"`);
   }
-  const archiveDir = path187.join(sessionDir(session.projectPath, session.id), "slate-archive");
+  const archiveDir = path188.join(sessionDir(session.projectPath, session.id), "slate-archive");
   let entries;
   try {
     entries = (await readdir34(archiveDir)).filter((name) => name.endsWith("-unbound-candidate.json"));
@@ -84201,7 +85094,7 @@ async function resolveUnboundCandidateTarget(cwd, target) {
   if (entries.length === 0)
     throw new Error(`No unbound-candidate artifacts for session ${session.id}`);
   entries.sort();
-  return path187.join(archiveDir, entries[entries.length - 1]);
+  return path188.join(archiveDir, entries[entries.length - 1]);
 }
 async function dismissUnboundByTarget(cwd, target, reason) {
   const evidencePath = await resolveUnboundCandidateTarget(cwd, target);
@@ -84227,7 +85120,7 @@ async function dismissUnboundCandidate(candidatePath, reason) {
   return { removed: candidatePath, receipt: receiptPath };
 }
 async function readNewestUnboundCandidate(dir) {
-  const archiveDir = path187.join(dir, "slate-archive");
+  const archiveDir = path188.join(dir, "slate-archive");
   let entries;
   try {
     entries = (await readdir34(archiveDir)).filter((name) => name.endsWith("-unbound-candidate.json"));
@@ -84236,7 +85129,7 @@ async function readNewestUnboundCandidate(dir) {
   }
   entries.sort();
   for (let i = entries.length - 1;i >= 0; i--) {
-    const evidencePath = path187.join(archiveDir, entries[i]);
+    const evidencePath = path188.join(archiveDir, entries[i]);
     if (await pathExists(unboundDismissedReceiptPath(evidencePath)))
       continue;
     const result = readConfigFile(evidencePath);
@@ -84266,7 +85159,7 @@ function isFailureOutcome(g) {
   return g.outcome === "error" || g.outcome === "no_credential" || g.outcome === "conflict";
 }
 async function readNewestWrapUpOutcome(dir) {
-  const archiveDir = path187.join(dir, "slate-archive");
+  const archiveDir = path188.join(dir, "slate-archive");
   let entries;
   try {
     entries = (await readdir34(archiveDir)).filter((name) => name.endsWith("-wrap-up-outcome.json"));
@@ -84275,7 +85168,7 @@ async function readNewestWrapUpOutcome(dir) {
   }
   entries.sort();
   for (let i = entries.length - 1;i >= 0; i--) {
-    const evidencePath = path187.join(archiveDir, entries[i]);
+    const evidencePath = path188.join(archiveDir, entries[i]);
     const result = readConfigFile(evidencePath);
     if (!result.ok) {
       continue;
@@ -87756,41 +88649,6 @@ init_patch_risk();
 init_catalog();
 init_grants();
 init_login();
-
-// src/lib/oauth/open-url.ts
-import { spawn as spawn5 } from "child_process";
-function browserOpenPlan(url, platform = process.platform, env = process.env) {
-  if (url.length === 0) {
-    return;
-  }
-  if (platform === "darwin") {
-    return { cmd: "open", args: [url] };
-  }
-  if (platform === "win32") {
-    return { cmd: "cmd", args: ["/c", "start", "", url] };
-  }
-  if (typeof env.DISPLAY === "string" && env.DISPLAY.length > 0) {
-    return { cmd: "xdg-open", args: [url] };
-  }
-  if (typeof env.WAYLAND_DISPLAY === "string" && env.WAYLAND_DISPLAY.length > 0) {
-    return { cmd: "xdg-open", args: [url] };
-  }
-  return;
-}
-function openVerificationUrl(url, deps = {}) {
-  const plan = browserOpenPlan(url, deps.platform ?? process.platform, deps.env ?? process.env);
-  if (plan === undefined) {
-    return;
-  }
-  const spawnFn = deps.spawn ?? spawn5;
-  try {
-    const child = spawnFn(plan.cmd, plan.args, { stdio: "ignore", detached: true });
-    child.on("error", () => {});
-    child.unref();
-  } catch {}
-}
-
-// src/tui/tui-shell.ts
 init_shell_config();
 init_provider_config();
 
@@ -87826,10 +88684,10 @@ function describeElicitationPrompt(tool, inputJson) {
 // src/lib/permission-mode-config.ts
 init_permission_mode();
 init_config_dir();
-import path188 from "path";
+import path189 from "path";
 var EMPTY3 = { schemaVersion: 1, projects: {} };
 function permissionModeConfigPath(dir) {
-  return path188.join(keryxConfigDir(dir), "permission-mode.json");
+  return path189.join(keryxConfigDir(dir), "permission-mode.json");
 }
 function withRegistryLock2(dir, fn) {
   return withFileLock2(`${permissionModeConfigPath(dir)}.lock`, fn, {
@@ -88347,7 +89205,7 @@ function showComposerChoice(otui, r, dock, request) {
 // src/lib/version-check.ts
 init_config_dir();
 init_fs();
-import path189 from "path";
+import path190 from "path";
 var REGISTRY_URL = "https://registry.npmjs.org/@mrciphersmith%2Fkeryx/latest";
 var FIXED_INSTALL_COMMAND = "npm install -g @mrciphersmith/keryx@latest";
 var RESPONSE_BODY_LIMIT_BYTES = 64 * 1024;
@@ -88549,7 +89407,7 @@ async function checkVersion(options) {
   const now = options.now ?? Date.now;
   const timestamp = now();
   const configDir = ensureKeryxConfigDir(options.cacheDir);
-  const cacheFile = path189.join(configDir, "version-check.json");
+  const cacheFile = path190.join(configDir, "version-check.json");
   const cache = parseCache(cacheFile);
   if (cache?.latestVersion !== undefined && cache.successAt !== undefined && timestamp - cache.successAt >= 0 && timestamp - cache.successAt < SUCCESS_CACHE_TTL_MS) {
     return resultFor(options.currentVersion, current, cache.latestVersion, "cache");
@@ -92169,6 +93027,9 @@ function promptApiKeyStep(otui, r, opts) {
     const box = overlayBox(otui, r, "key-picker");
     r.root.add(box);
     box.add(new otui.TextRenderable(r, { id: "kp-title", content: otui.t`${otui.bold(`Paste your ${opts.label} API key`)} ${otui.dim("(Enter \xB7 Esc to go back)")}` }));
+    if (opts.notice !== undefined) {
+      box.add(new otui.TextRenderable(r, { id: "kp-notice", content: otui.t`${otui.red("\u2717")} ${opts.notice}`, marginTop: 1 }));
+    }
     box.add(new otui.TextRenderable(r, {
       id: "kp-note",
       content: otui.t`${otui.dim(`Set as ${opts.envKey} \xB7 saved to your keryx config dir (owner-only, 0600)`)}`,
@@ -92288,9 +93149,14 @@ function runDeviceLoginInTui(otui, r, provider) {
     });
   });
 }
-async function modelsForPicker(prov) {
-  const result = await resolveModelsForPicker(globalThis.fetch, prov, process.env);
-  return result.models;
+async function modelsForPicker(prov, deps = {}) {
+  return await resolveModelsForPicker(deps.fetch ?? globalThis.fetch, prov, deps.env ?? process.env);
+}
+function modelPickerNotice(label, result) {
+  if (result.models.length > 0 || result.failure === undefined) {
+    return;
+  }
+  return modelsFailureLine(label, result.failure);
 }
 function pickProviderStep(otui, r, detected) {
   return new Promise((resolve) => {
@@ -92377,44 +93243,66 @@ function selectProviderModelInTui(otui, r, detected, options = {}) {
           continue;
         }
         if (!options.onlyConnected && selectedBaseUrl !== undefined)
-          saveProviderBaseUrl(prov.name, selectedBaseUrl);
+          saveProviderBaseUrl(prov.name, selectedBaseUrl, options.configDir);
         const selectedProvider = selectedBaseUrl === undefined ? prov : { ...prov, baseUrl: selectedBaseUrl };
         const envKey = prov.envKey;
-        if (!options.onlyConnected && envKey !== undefined) {
-          const existingKey = process.env[envKey];
-          const hasOauth = oauthAccessToken(prov.name) !== undefined;
-          if ((existingKey === undefined || existingKey.length === 0) && !hasOauth) {
-            const offered = [];
-            if (catalogAllows(prov.name, "device-code"))
-              offered.push("device-code");
-            if (catalogMethods(prov.name).includes("api-key"))
-              offered.push("api-key");
-            let method = offered.length === 1 ? offered[0] : undefined;
-            if (offered.length > 1) {
-              method = await pickAuthMethodStep(otui, r, prov.label ?? prov.name, offered);
-              if (method === undefined) {
-                continue;
-              }
+        const label = prov.label ?? prov.name;
+        const collectCredential = async (notice) => {
+          if (options.onlyConnected || envKey === undefined) {
+            return "ok";
+          }
+          if (notice === undefined) {
+            const existingKey = (options.env ?? process.env)[envKey];
+            const hasOauth = oauthAccessToken(prov.name, options.configDir) !== undefined;
+            if (existingKey !== undefined && existingKey.length > 0 || hasOauth) {
+              return "ok";
             }
-            if (method === "device-code") {
-              const ok = await runDeviceLoginInTui(otui, r, prov.name);
-              if (!ok) {
-                continue;
-              }
-            } else {
-              const kr = await promptApiKeyStep(otui, r, { label: prov.label ?? prov.name, envKey });
-              if (kr.kind === "back") {
-                continue;
-              }
-              if (kr.kind === "key") {
-                process.env[envKey] = kr.value;
-                saveApiKey(envKey, kr.value);
-              }
+          }
+          const offered = [];
+          if (catalogAllows(prov.name, "device-code"))
+            offered.push("device-code");
+          if (catalogMethods(prov.name).includes("api-key"))
+            offered.push("api-key");
+          let method = offered.length === 1 ? offered[0] : undefined;
+          if (offered.length > 1) {
+            method = await pickAuthMethodStep(otui, r, label, offered);
+            if (method === undefined) {
+              return "back";
             }
           }
+          if (method === "device-code") {
+            return await runDeviceLoginInTui(otui, r, prov.name) ? "ok" : "back";
+          }
+          const kr = await promptApiKeyStep(otui, r, {
+            label,
+            envKey,
+            ...notice === undefined ? {} : { notice }
+          });
+          if (kr.kind === "back") {
+            return "back";
+          }
+          if (kr.kind === "key") {
+            process.env[envKey] = kr.value;
+            noteSavedCredentialEnv([envKey]);
+            saveApiKey(envKey, kr.value, options.configDir);
+          }
+          return "ok";
+        };
+        if (await collectCredential() === "back") {
+          continue;
         }
-        const models = await modelsForPicker(selectedProvider);
-        const model = await pickModelInTui(otui, r, models);
+        const modelDeps = {
+          ...options.fetch === undefined ? {} : { fetch: options.fetch },
+          ...options.env === undefined ? {} : { env: options.env }
+        };
+        let models = await modelsForPicker(selectedProvider, modelDeps);
+        if (models.failure?.kind === "rejected") {
+          if (await collectCredential(modelsFailureLine(label, models.failure)) === "back") {
+            continue;
+          }
+          models = await modelsForPicker(selectedProvider, modelDeps);
+        }
+        const model = await pickModelInTui(otui, r, models.models, modelPickerNotice(label, models));
         if (model === undefined) {
           continue;
         }
@@ -92428,13 +93316,16 @@ function adaptiveSelectHeight(count, available, per = 1) {
   const min = Math.max(1, Math.floor(available / 4));
   return Math.min(available, Math.max(min, count * per));
 }
-function pickModelInTui(otui, r, models) {
+function pickModelInTui(otui, r, models, notice) {
   return new Promise((resolve) => {
     const all = models;
-    const NO_MODELS = "(no models found)";
+    const NO_MODELS = notice ?? "(no models found)";
     const box = overlayBox(otui, r, "model-picker");
     r.root.add(box);
     box.add(new otui.TextRenderable(r, { id: "mp-title", content: otui.t`${otui.bold("Select a model")}` }));
+    if (all.length === 0 && notice !== undefined) {
+      box.add(new otui.TextRenderable(r, { id: "mp-notice", content: otui.t`${otui.red("\u2717")} ${notice}` }));
+    }
     const filterLine = new otui.TextRenderable(r, { id: "mp-filter", content: otui.t`${otui.dim("type to filter \xB7 \u2191/\u2193 Enter \xB7 Esc to go back")}` });
     box.add(filterLine);
     const NO_MATCH = "(no match)";
@@ -94530,8 +95421,9 @@ ${formatThemeList(getThemeId())}`);
           (async () => {
             const detected = opts.redetect !== undefined ? await opts.redetect() : opts.detected;
             const prov = detected.find((d) => d.name === currentSel.provider);
-            const models = prov !== undefined ? await modelsForPicker(prov) : [];
-            const chosen = await chrome.withOverlay(() => pickModelInTui(otui, r, models));
+            const models = prov !== undefined ? await modelsForPicker(prov) : undefined;
+            const notice = prov === undefined || models === undefined ? undefined : modelPickerNotice(prov.label ?? prov.name, models);
+            const chosen = await chrome.withOverlay(() => pickModelInTui(otui, r, models?.models ?? [], notice));
             if (chosen !== undefined) {
               await switchTo(currentSel.baseUrl === undefined ? { provider: currentSel.provider, model: chosen } : { provider: currentSel.provider, model: chosen, baseUrl: currentSel.baseUrl });
               try {
@@ -95206,7 +96098,8 @@ async function launchTuiChatShell(opts) {
           return await selectProviderModelInTui(otui, r, detected);
         }
         const prov = detected.find((d) => d.name === only);
-        const chosen = await pickModelInTui(otui, r, prov !== undefined ? await modelsForPicker(prov) : []);
+        const models = prov === undefined ? undefined : await modelsForPicker(prov);
+        const chosen = await pickModelInTui(otui, r, models?.models ?? [], prov === undefined || models === undefined ? undefined : modelPickerNotice(prov.label ?? prov.name, models));
         if (chosen === undefined) {
           return;
         }
@@ -95596,17 +96489,19 @@ function oauthCredentialsFor(name) {
 }
 function realSelectProviderModel(baseUrl) {
   return async (io, opts) => {
+    const env = envWithSavedApiKeys(process.env);
     const detected = await detectProviders({
       fetch: globalThis.fetch,
-      env: process.env,
+      env,
       platform: process.platform,
       ...baseUrl !== undefined ? { baseUrl } : {}
     });
     const filtered = opts?.onlyProvider !== undefined ? detected.filter((d) => d.name === opts.onlyProvider) : detected;
     const list = filtered.length > 0 ? filtered : detected;
-    return pickProviderModel(io, list, { fetch: globalThis.fetch, env: process.env });
+    return pickProviderModel(io, list, { fetch: globalThis.fetch, env });
   };
 }
+var GRANT_REFRESH_TIMEOUT_MS = 5000;
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var PROMPT_MARK = "\u276F ";
 var GUTTER = "  ";
@@ -96480,14 +97375,6 @@ ${GUTTER}${turnSeparator()}
 }
 async function resolveTuiStartup(opts) {
   const savedCfg = loadShellConfig(opts.configDir);
-  await Promise.resolve().then(() => init_login());
-  const oauthFetch = (input, init) => globalThis.fetch(input, init);
-  await refreshProviderGrant("grok", { fetch: oauthFetch }, opts.configDir).catch(() => {
-    return;
-  });
-  await refreshProviderGrant("github-copilot", { fetch: oauthFetch }, opts.configDir).catch(() => {
-    return;
-  });
   const appliedKeys = applySavedApiKeys(opts.configDir);
   const { providerArg, modelArg, baseUrl } = opts;
   if (providerArg !== undefined && modelArg !== undefined) {
@@ -96666,6 +97553,15 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
   const modelArg = flags.modelArg;
   let baseUrl = flags.baseUrl;
   let modeFlag = flags.modeFlag;
+  {
+    await Promise.resolve().then(() => init_login());
+    const oauthFetch = (input, init) => globalThis.fetch(input, init);
+    const http = { fetch: oauthFetch, signal: AbortSignal.timeout(GRANT_REFRESH_TIMEOUT_MS) };
+    const warnings = await refreshSavedGrants(http, runtime.cacheDir, providerArg === undefined ? undefined : [providerArg]);
+    for (const warning of warnings)
+      process.stderr.write(`keryx: ${warning}
+`);
+  }
   const surface = chooseShellSurface(flags, runtime.isTty ?? process.stdout.isTTY === true);
   if (surface !== "readline") {
     const cwd = process.cwd();
@@ -97125,7 +98021,7 @@ Shell:
 init_fs();
 import { readFile as readFile98 } from "fs/promises";
 import { stdin } from "process";
-import path190 from "path";
+import path191 from "path";
 var MODULES = [
   { name: "gdgraph", flag: "--no-gdgraph", desc: "code graph, symbols, affected context", defaultEnabled: true },
   { name: "gdctx", flag: "--no-gdctx", desc: "token-aware command/read output", defaultEnabled: true },
@@ -97171,8 +98067,8 @@ async function modulesCommand(args = []) {
     return;
   }
   const wantsJson = args.includes("--json") && (sub === undefined || sub === "status" || sub === "list" || sub === "--json");
-  const metaprojectRoot = path190.join(process.cwd(), ".metaproject");
-  const manifestPath = path190.join(metaprojectRoot, "metaproject.json");
+  const metaprojectRoot = path191.join(process.cwd(), ".metaproject");
+  const manifestPath = path191.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     if (wantsJson) {
       console.log(JSON.stringify({ schemaVersion: 1, error: "not-initialized", modules: [] }, null, 2));
@@ -97291,7 +98187,7 @@ init_serve_config();
 
 // src/lib/serve-credential.ts
 init_config_dir();
-import { createHash as createHash43, randomBytes as randomBytes4, randomUUID as randomUUID30 } from "crypto";
+import { createHash as createHash44, randomBytes as randomBytes5, randomUUID as randomUUID30 } from "crypto";
 import {
   chmodSync as chmodSync4,
   closeSync as closeSync3,
@@ -97303,9 +98199,9 @@ import {
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync9
 } from "fs";
-import path191 from "path";
+import path192 from "path";
 function serveCredentialPath(dir) {
-  return path191.join(keryxConfigDir(dir), "serve-credentials.json");
+  return path192.join(keryxConfigDir(dir), "serve-credentials.json");
 }
 function constantTimeEqual(a, b) {
   const width = Math.max(a.length, b.length);
@@ -97318,10 +98214,10 @@ function constantTimeEqual(a, b) {
   return difference === 0;
 }
 function hashToken(salt, token) {
-  return createHash43("sha256").update(Buffer.from(salt, "hex")).update(Buffer.from(token, "utf8")).digest("hex");
+  return createHash44("sha256").update(Buffer.from(salt, "hex")).update(Buffer.from(token, "utf8")).digest("hex");
 }
 function credentialFingerprint(record) {
-  return createHash43("sha256").update(`keryx-serve-fingerprint:${record.hash}`).digest("hex").slice(0, 8);
+  return createHash44("sha256").update(`keryx-serve-fingerprint:${record.hash}`).digest("hex").slice(0, 8);
 }
 function isValidRecord(value) {
   if (typeof value !== "object" || value === null) {
@@ -97411,8 +98307,8 @@ function withServeCredentialLock(dir, fn, onWaiting) {
   });
 }
 function mintRecord(now) {
-  const token = randomBytes4(32).toString("base64url");
-  const salt = randomBytes4(32).toString("hex");
+  const token = randomBytes5(32).toString("base64url");
+  const salt = randomBytes5(32).toString("hex");
   return {
     token,
     record: { id: randomUUID30(), algorithm: "sha256", salt, hash: hashToken(salt, token), createdAt: now }
@@ -97537,24 +98433,24 @@ class AuthFailureThrottle {
 
 // src/lib/serve-turn-store.ts
 init_config_dir();
-import { createHash as createHash44 } from "crypto";
+import { createHash as createHash45 } from "crypto";
 import { existsSync as existsSync34, readdirSync as readdirSync3, rmSync as rmSync2 } from "fs";
-import path192 from "path";
+import path193 from "path";
 var MAX_TURN_EVENTS = 1e4;
 function turnsRoot(dir) {
-  return path192.join(keryxConfigDir(dir), "turns");
+  return path193.join(keryxConfigDir(dir), "turns");
 }
 function turnDir(turnId, dir) {
-  return path192.join(turnsRoot(dir), turnId);
+  return path193.join(turnsRoot(dir), turnId);
 }
 function keyPath(project, idempotencyKey, dir) {
   const projectBytes = Buffer.byteLength(project, "utf8");
-  const digest = createHash44("sha256").update(`${projectBytes}:${project}\x00${idempotencyKey}`, "utf8").digest("hex");
-  return path192.join(turnsRoot(dir), "keys", `${digest}.json`);
+  const digest = createHash45("sha256").update(`${projectBytes}:${project}\x00${idempotencyKey}`, "utf8").digest("hex");
+  return path193.join(turnsRoot(dir), "keys", `${digest}.json`);
 }
 function legacyKeyPath(idempotencyKey, dir) {
-  const digest = createHash44("sha256").update(idempotencyKey, "utf8").digest("hex");
-  return path192.join(turnsRoot(dir), "keys", `${digest}.json`);
+  const digest = createHash45("sha256").update(idempotencyKey, "utf8").digest("hex");
+  return path193.join(turnsRoot(dir), "keys", `${digest}.json`);
 }
 function adoptLegacyClaim(project, idempotencyKey, dir) {
   const legacy = legacyKeyPath(idempotencyKey, dir);
@@ -97618,7 +98514,7 @@ function ensureTurnDir(turnId, dir) {
 }
 function createTurnRecord(record, dir) {
   ensureTurnDir(record.turnId, dir);
-  writeOwnerOnlyFile(path192.join(turnDir(record.turnId, dir), "turn.json"), `${JSON.stringify(record, null, 2)}
+  writeOwnerOnlyFile(path193.join(turnDir(record.turnId, dir), "turn.json"), `${JSON.stringify(record, null, 2)}
 `);
 }
 function appendTurnEvent(event, dir, opts) {
@@ -97627,12 +98523,12 @@ function appendTurnEvent(event, dir, opts) {
   }
   const line = JSON.stringify(event);
   try {
-    appendOwnerOnlyLine(path192.join(turnDir(event.turnId, dir), "events.jsonl"), line);
+    appendOwnerOnlyLine(path193.join(turnDir(event.turnId, dir), "events.jsonl"), line);
   } catch (error) {
     if (error?.code !== "ENOENT") {
       throw error;
     }
-    appendOwnerOnlyLine(path192.join(ensureTurnDir(event.turnId, dir), "events.jsonl"), line);
+    appendOwnerOnlyLine(path193.join(ensureTurnDir(event.turnId, dir), "events.jsonl"), line);
   }
   return true;
 }
@@ -97640,7 +98536,7 @@ function readTurnEvents(turnId, after = -1, dir) {
   if (!isTurnId(turnId)) {
     return { ok: false, reason: "not-a-turn-id" };
   }
-  const read = readTurnFile(path192.join(turnDir(turnId, dir), "events.jsonl"));
+  const read = readTurnFile(path193.join(turnDir(turnId, dir), "events.jsonl"));
   if (!read.ok) {
     if (isDefiniteAbsence2(read.reason)) {
       return { ok: true, value: [] };
@@ -97668,7 +98564,7 @@ function readTurnRecord(turnId, dir) {
   if (!isTurnId(turnId)) {
     return { ok: false, reason: "not-a-turn-id" };
   }
-  const read = readTurnFile(path192.join(turnDir(turnId, dir), "turn.json"));
+  const read = readTurnFile(path193.join(turnDir(turnId, dir), "turn.json"));
   if (!read.ok) {
     return { ok: false, reason: read.reason };
   }
@@ -97687,7 +98583,7 @@ function finishTurn(turnId, result, dir) {
   if (!record.ok) {
     return false;
   }
-  writeOwnerOnlyFile(path192.join(turnDir(turnId, dir), "turn.json"), `${JSON.stringify({ ...record.value, result }, null, 2)}
+  writeOwnerOnlyFile(path193.join(turnDir(turnId, dir), "turn.json"), `${JSON.stringify({ ...record.value, result }, null, 2)}
 `);
   return true;
 }
@@ -97733,7 +98629,7 @@ function releaseIdempotencyKey(project, idempotencyKey, turnId, dir) {
 
 // src/lib/serve-turn.ts
 import { randomUUID as randomUUID31 } from "crypto";
-import path193 from "path";
+import path194 from "path";
 init_service();
 var REMOTE_ORIGIN = "remote:http";
 var MAX_PROMPT_CHARS = 32000;
@@ -97802,9 +98698,9 @@ function isUuid(value) {
   return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value);
 }
 function resolveProject(declared, dir) {
-  const wanted = path193.resolve(declared);
+  const wanted = path194.resolve(declared);
   for (const entry of listProjects(dir, () => {})) {
-    if (path193.resolve(entry.path) === wanted) {
+    if (path194.resolve(entry.path) === wanted) {
       return { ok: true, project: entry.path };
     }
   }
@@ -98840,7 +99736,7 @@ function printHelp19() {
 import { spawn as spawn6 } from "child_process";
 import { chmod as chmod4, mkdir as mkdir62, readFile as readFile99, readdir as readdir35, writeFile as writeFile54 } from "fs/promises";
 import { access as access4, constants as constants2, existsSync as existsSync35 } from "fs";
-import path194 from "path";
+import path195 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 init_config2();
 init_config();
@@ -98857,8 +99753,8 @@ async function updateCommand(args = []) {
     return;
   }
   const projectRoot = process.cwd();
-  const metaprojectRoot = path194.join(projectRoot, ".metaproject");
-  banner("keryx update", `Refreshing the .metaproject workspace in ${path194.basename(projectRoot)}/`);
+  const metaprojectRoot = path195.join(projectRoot, ".metaproject");
+  banner("keryx update", `Refreshing the .metaproject workspace in ${path195.basename(projectRoot)}/`);
   if (!await pathExists(metaprojectRoot)) {
     console.log(`  ${style.red(symbols.cross)} Metaproject is not initialized.`);
     console.log(`  ${style.cyan(symbols.arrow)} Run ${style.cyan("keryx init")} first.`);
@@ -98909,6 +99805,12 @@ async function updateCommand(args = []) {
   if (summary.modules.sac) {
     statusLine("sac", true, "shared agent context: cross-session workspace propose/review (opt-in)");
   }
+  if (summary.gdskillsWarnings.length > 0) {
+    heading("Warnings");
+    for (const warning of summary.gdskillsWarnings) {
+      note(warning);
+    }
+  }
   const steps = [];
   if (options.hooks) {
     await runPostUpdateHooks(projectRoot);
@@ -98919,7 +99821,7 @@ async function updateCommand(args = []) {
   nextSteps(steps);
 }
 async function previewServiceFiles(projectRoot, options) {
-  const metaprojectRoot = path194.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path195.join(projectRoot, ".metaproject");
   const manifestState = await readManifest5(metaprojectRoot);
   const manifest = manifestState.manifest;
   const enableTasks = moduleEnabled2(manifest, "tasks") || !options.noTasks;
@@ -98948,12 +99850,12 @@ async function previewServiceFiles(projectRoot, options) {
   });
 }
 async function refreshServiceFiles(projectRoot, options) {
-  const metaprojectRoot = path194.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path195.join(projectRoot, ".metaproject");
   const manifestState = await readManifest5(metaprojectRoot);
   const manifest = manifestState.manifest;
   const recoveredManifest = !manifestState.exists || !manifestState.valid;
   if (manifestState.migrated) {
-    await writeFile54(path194.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
+    await writeFile54(path195.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
   }
   const enableGdgraph = moduleEnabled2(manifest, "gdgraph");
@@ -98990,9 +99892,9 @@ async function refreshServiceFiles(projectRoot, options) {
     enableSecurity,
     enableSac
   });
-  await writeTextIfChanged4(path194.join(metaprojectRoot, "core", "README.md"), renderMetaprojectCoreReadme());
-  await writeTextIfChanged4(path194.join(metaprojectRoot, "hooks", "README.md"), renderHooksReadme());
-  await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "project-rules", "README.md"), renderProjectRulesSkillReadme({ sources: ruleSources }));
+  await writeTextIfChanged4(path195.join(metaprojectRoot, "core", "README.md"), renderMetaprojectCoreReadme());
+  await writeTextIfChanged4(path195.join(metaprojectRoot, "hooks", "README.md"), renderHooksReadme());
+  await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "project-rules", "README.md"), renderProjectRulesSkillReadme({ sources: ruleSources }));
   await writeRoutingEntrypointPair(metaprojectRoot, {
     enableGdgraph,
     enableGdctx,
@@ -99015,7 +99917,7 @@ async function refreshServiceFiles(projectRoot, options) {
       }
     }
   });
-  await writeTextIfChanged4(path194.join(metaprojectRoot, "keryx-dashboard.html"), renderMetaprojectDashboardHtml({
+  await writeTextIfChanged4(path195.join(metaprojectRoot, "keryx-dashboard.html"), renderMetaprojectDashboardHtml({
     enableGdgraph,
     enableGdctx,
     enableGdwiki,
@@ -99027,7 +99929,7 @@ async function refreshServiceFiles(projectRoot, options) {
     enableSecurity,
     data: dashboardData
   }));
-  await writeTextIfMissing4(path194.join(metaprojectRoot, "README.md"), renderMetaprojectReadme({
+  await writeTextIfMissing4(path195.join(metaprojectRoot, "README.md"), renderMetaprojectReadme({
     enableGdgraph,
     enableGdctx,
     enableGdwiki,
@@ -99040,58 +99942,60 @@ async function refreshServiceFiles(projectRoot, options) {
   }));
   if (enableGdgraph) {
     await installGdgraphCoreScripts2(metaprojectRoot);
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "gdgraph.md"), renderGdgraphManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "core", "gdgraph", "README.md"), renderGdgraphCoreReadme());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "gdgraph", "SKILL.md"), renderGdgraphSkillReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "gdgraph.md"), renderGdgraphManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "core", "gdgraph", "README.md"), renderGdgraphCoreReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "gdgraph", "SKILL.md"), renderGdgraphSkillReadme());
     await seedAssetsLock(metaprojectRoot);
     if (manifest.modules?.gdgraph?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "gdgraph-post-commit", renderGdgraphPostCommitHook());
     }
   }
   if (enableGdctx) {
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "gdctx.config.json"), renderGdctxConfig());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "gdctx.md"), renderGdctxManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "core", "gdctx", "README.md"), renderGdctxCoreReadme());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "gdctx", "SKILL.md"), renderGdctxSkillReadme());
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "gdctx.config.json"), renderGdctxConfig());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "gdctx.md"), renderGdctxManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "core", "gdctx", "README.md"), renderGdctxCoreReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "gdctx", "SKILL.md"), renderGdctxSkillReadme());
   }
   if (enableGdwiki) {
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "wiki", "templates", "page.md"), renderWikiPageTemplate());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "gdwiki.md"), renderGdwikiManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "gdwiki", "SKILL.md"), renderGdwikiSkillReadme());
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "wiki", "templates", "page.md"), renderWikiPageTemplate());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "gdwiki.md"), renderGdwikiManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "gdwiki", "SKILL.md"), renderGdwikiSkillReadme());
     if (manifest.modules?.gdgraph?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "gdwiki-post-commit", renderGdwikiPostCommitHook());
     }
   }
   if (enableSac) {
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "modules", "sac.md"), renderSacManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "sac", "SKILL.md"), renderSacSkillReadme());
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "modules", "sac.md"), renderSacManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "sac", "SKILL.md"), renderSacSkillReadme());
   }
+  let gdskillsWarnings = [];
   if (enableGdskills) {
-    await installGdskills(metaprojectRoot, gdskillsProfile, { createDataDirs: false });
+    const gdskillsInstallResult = await installGdskills(metaprojectRoot, gdskillsProfile, { createDataDirs: false });
+    gdskillsWarnings = gdskillsInstallResult.warnings;
     if (manifest.modules?.gdskills?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "gdskills-post-commit", renderGdskillsPostCommitHook());
     }
   }
   if (enableHealth) {
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "health.config.json"), renderHealthConfig());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "health.md"), renderHealthManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "core", "health", "README.md"), renderHealthCoreReadme());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "health", "SKILL.md"), renderHealthSkillReadme());
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "health.config.json"), renderHealthConfig());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "health.md"), renderHealthManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "core", "health", "README.md"), renderHealthCoreReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "health", "SKILL.md"), renderHealthSkillReadme());
     if (manifest.modules?.health?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "health-post-commit", renderHealthPostCommitHook());
     }
   }
   if (enableTesting) {
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "testing.config.json"), renderTestingConfig({
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "testing.config.json"), renderTestingConfig({
       postCommitRefresh: Boolean(manifest.modules?.testing?.hooks?.gitPostCommit),
       prePushGate: Boolean(manifest.modules?.testing?.hooks?.prePush)
     }));
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "testing.md"), renderTestingManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "core", "testing", "README.md"), renderTestingCoreReadme());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "testing", "SKILL.md"), renderTestingSkillReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "testing.md"), renderTestingManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "core", "testing", "README.md"), renderTestingCoreReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "testing", "SKILL.md"), renderTestingSkillReadme());
     if (enableGdwiki) {
-      await writeTextIfMissing4(path194.join(metaprojectRoot, "wiki", "testing", "README.md"), renderTestingWikiReadme());
-      await writeTextIfMissing4(path194.join(metaprojectRoot, "wiki", "testing", "conventions.md"), renderTestingWikiConventions());
+      await writeTextIfMissing4(path195.join(metaprojectRoot, "wiki", "testing", "README.md"), renderTestingWikiReadme());
+      await writeTextIfMissing4(path195.join(metaprojectRoot, "wiki", "testing", "conventions.md"), renderTestingWikiConventions());
     }
     if (manifest.modules?.testing?.hooks?.gitPostCommit) {
       await installManagedHook2(projectRoot, "post-commit", "testing-post-commit", renderTestingPostCommitHook());
@@ -99104,24 +100008,24 @@ async function refreshServiceFiles(projectRoot, options) {
     await installManagedHook2(projectRoot, "post-commit", "metaproject-dashboard-post-commit", renderMetaprojectDashboardPostCommitHook());
   }
   if (enableMemory) {
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "memory.config.json"), renderMemoryConfig());
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "memory", "templates", "entry.md"), renderMemoryEntryTemplate());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "memory.md"), renderMemoryManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "core", "memory", "README.md"), renderMemoryCoreReadme());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "memory", "SKILL.md"), renderMemorySkillReadme());
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "memory.config.json"), renderMemoryConfig());
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "memory", "templates", "entry.md"), renderMemoryEntryTemplate());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "memory.md"), renderMemoryManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "core", "memory", "README.md"), renderMemoryCoreReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "memory", "SKILL.md"), renderMemorySkillReadme());
   }
   if (enableTasks) {
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "flows", "README.md"), renderFlowsReadme());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "tasks.md"), renderTasksManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "flow", "SKILL.md"), renderFlowSkillRouter());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "flow", "init.md"), renderFlowInitSkill());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "flow", "manage.md"), renderFlowManageSkill());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "skills", "flow", "complete.md"), renderFlowCompleteSkill());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "flows", "README.md"), renderFlowsReadme());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "tasks.md"), renderTasksManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "flow", "SKILL.md"), renderFlowSkillRouter());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "flow", "init.md"), renderFlowInitSkill());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "flow", "manage.md"), renderFlowManageSkill());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "skills", "flow", "complete.md"), renderFlowCompleteSkill());
   }
   if (enableSecurity) {
-    await writeTextIfMissing4(path194.join(metaprojectRoot, "security.config.json"), renderSecurityConfig());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "modules", "security.md"), renderSecurityManifest());
-    await writeTextIfChanged4(path194.join(metaprojectRoot, "core", "security", "README.md"), renderSecurityCoreReadme());
+    await writeTextIfMissing4(path195.join(metaprojectRoot, "security.config.json"), renderSecurityConfig());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "modules", "security.md"), renderSecurityManifest());
+    await writeTextIfChanged4(path195.join(metaprojectRoot, "core", "security", "README.md"), renderSecurityCoreReadme());
     if (manifest.modules?.security?.hooks?.prePush) {
       await installManagedHook2(projectRoot, "pre-push", "security-pre-push", renderSecurityPrePushHook());
     }
@@ -99167,18 +100071,19 @@ async function refreshServiceFiles(projectRoot, options) {
       sac: enableSac
     },
     gdskillsProfile,
+    gdskillsWarnings,
     backfilledTasks: backfillTasks,
     recoveredManifest
   };
 }
 async function buildDashboard(projectRoot = process.cwd()) {
-  const metaprojectRoot = path194.join(projectRoot, ".metaproject");
+  const metaprojectRoot = path195.join(projectRoot, ".metaproject");
   if (!await pathExists(metaprojectRoot)) {
     throw new Error("Metaproject is not initialized. Run: keryx init");
   }
   const manifest = (await readManifest5(metaprojectRoot)).manifest;
   const data = await collectDashboardData(metaprojectRoot);
-  const dashboardPath = path194.join(metaprojectRoot, "keryx-dashboard.html");
+  const dashboardPath = path195.join(metaprojectRoot, "keryx-dashboard.html");
   await writeTextIfChanged4(dashboardPath, renderMetaprojectDashboardHtml({
     enableGdgraph: moduleEnabled2(manifest, "gdgraph"),
     enableGdctx: moduleEnabled2(manifest, "gdctx"),
@@ -99198,7 +100103,7 @@ async function shouldInstallDashboardPostCommitHook(projectRoot, manifest) {
   if (Object.values(modules).some((module) => Boolean(module.hooks?.gitPostCommit))) {
     return true;
   }
-  const hookPath = path194.join(projectRoot, ".git", "hooks", "post-commit");
+  const hookPath = path195.join(projectRoot, ".git", "hooks", "post-commit");
   if (!await pathExists(hookPath)) {
     return false;
   }
@@ -99218,11 +100123,11 @@ async function collectDashboardData(metaprojectRoot) {
   if (testing) {
     data.testing = testing;
   }
-  const wiki = await collectMarkdownPages(path194.join(metaprojectRoot, "wiki"), "wiki");
+  const wiki = await collectMarkdownPages(path195.join(metaprojectRoot, "wiki"), "wiki");
   if (wiki.length > 0) {
     data.wiki = { pages: wiki };
   }
-  const memory = await collectMarkdownPages(path194.join(metaprojectRoot, "memory"), "memory");
+  const memory = await collectMarkdownPages(path195.join(metaprojectRoot, "memory"), "memory");
   if (memory.length > 0) {
     data.memory = { entries: memory };
   }
@@ -99237,7 +100142,7 @@ async function collectDashboardData(metaprojectRoot) {
   return data;
 }
 async function collectTasksDashboardData(metaprojectRoot) {
-  const flowsRoot = path194.join(metaprojectRoot, "flows");
+  const flowsRoot = path195.join(metaprojectRoot, "flows");
   if (!await pathExists(flowsRoot)) {
     return null;
   }
@@ -99249,7 +100154,7 @@ async function collectTasksDashboardData(metaprojectRoot) {
   }
   const flows = [];
   for (const dir of dirEntries) {
-    const flowPath = path194.join(flowsRoot, dir, "flow.json");
+    const flowPath = path195.join(flowsRoot, dir, "flow.json");
     if (!await pathExists(flowPath)) {
       continue;
     }
@@ -99257,7 +100162,7 @@ async function collectTasksDashboardData(metaprojectRoot) {
       const flow = JSON.parse(await readFile99(flowPath, "utf8"));
       const tasks = Array.isArray(flow.tasks) ? flow.tasks : [];
       let acTotal = 0;
-      const acPath = path194.join(flowsRoot, dir, "acceptance-criteria.md");
+      const acPath = path195.join(flowsRoot, dir, "acceptance-criteria.md");
       if (await pathExists(acPath)) {
         const acContent = await readFile99(acPath, "utf8");
         acTotal = (acContent.match(/^- AC\d+:/gm) ?? []).length;
@@ -99311,7 +100216,7 @@ async function collectDashboardDocs(metaprojectRoot, wiki, memory) {
     "data/testing/context.md"
   ];
   for (const href of staticHrefs) {
-    const filePath = path194.join(metaprojectRoot, ...href.split("/"));
+    const filePath = path195.join(metaprojectRoot, ...href.split("/"));
     if (!await pathExists(filePath)) {
       continue;
     }
@@ -99328,7 +100233,7 @@ async function collectDashboardDocs(metaprojectRoot, wiki, memory) {
   return docs;
 }
 async function collectHealthDashboardData(metaprojectRoot) {
-  const reportPath = path194.join(metaprojectRoot, "data", "health", "artifacts", "latest.json");
+  const reportPath = path195.join(metaprojectRoot, "data", "health", "artifacts", "latest.json");
   if (!await pathExists(reportPath)) {
     return;
   }
@@ -99437,8 +100342,8 @@ function metricToScope(metric) {
   };
 }
 async function collectGraphDashboardData(metaprojectRoot) {
-  const nodesPath = path194.join(metaprojectRoot, "data", "gdgraph", "storage", "nodes.jsonl");
-  const edgesPath = path194.join(metaprojectRoot, "data", "gdgraph", "storage", "edges.jsonl");
+  const nodesPath = path195.join(metaprojectRoot, "data", "gdgraph", "storage", "nodes.jsonl");
+  const edgesPath = path195.join(metaprojectRoot, "data", "gdgraph", "storage", "edges.jsonl");
   if (!await pathExists(nodesPath) || !await pathExists(edgesPath)) {
     return;
   }
@@ -99489,8 +100394,8 @@ async function collectGraphDashboardData(metaprojectRoot) {
   };
 }
 async function collectTestingDashboardData(metaprojectRoot) {
-  const reportPath = path194.join(metaprojectRoot, "data", "testing", "artifacts", "latest.json");
-  const contextPath = path194.join(metaprojectRoot, "data", "testing", "context.md");
+  const reportPath = path195.join(metaprojectRoot, "data", "testing", "artifacts", "latest.json");
+  const contextPath = path195.join(metaprojectRoot, "data", "testing", "context.md");
   if (await pathExists(reportPath)) {
     const report = JSON.parse(await readFile99(reportPath, "utf8"));
     const totalTests = numberOrUndefined(report.total);
@@ -99519,7 +100424,7 @@ async function collectMarkdownPages(root, hrefPrefix) {
   const files = await listMarkdownFiles(root);
   const pages = [];
   for (const filePath of files.slice(0, 40)) {
-    const relativePath = path194.relative(root, filePath).split(path194.sep).join("/");
+    const relativePath = path195.relative(root, filePath).split(path195.sep).join("/");
     if (relativePath === "index.md" || relativePath.startsWith("templates/")) {
       continue;
     }
@@ -99540,7 +100445,7 @@ async function listMarkdownFiles(root) {
   const entries = await readdir35(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = path194.join(root, entry.name);
+    const fullPath = path195.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listMarkdownFiles(fullPath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -99588,7 +100493,7 @@ async function writeRecoveredManifest(metaprojectRoot, modules) {
   const manifest = {
     schemaVersion: 1,
     standardVersion: STANDARD_VERSION,
-    name: `${path194.basename(path194.dirname(metaprojectRoot))}-metaproject`,
+    name: `${path195.basename(path195.dirname(metaprojectRoot))}-metaproject`,
     createdBy: "keryx",
     profiles: computeProfiles(enabledModuleKeys),
     paths: {
@@ -99678,11 +100583,11 @@ async function writeRecoveredManifest(metaprojectRoot, modules) {
       metaproject: ".metaproject/index.md"
     }
   };
-  await writeFile54(path194.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
+  await writeFile54(path195.join(metaprojectRoot, "metaproject.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 async function enableTasksInManifest(metaprojectRoot) {
-  const manifestPath = path194.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path195.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return;
   }
@@ -99705,7 +100610,7 @@ async function enableTasksInManifest(metaprojectRoot) {
 `, "utf8");
 }
 async function updateManifestAgentEntrypoints(metaprojectRoot, ruleSources) {
-  const manifestPath = path194.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path195.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return;
   }
@@ -99741,72 +100646,72 @@ async function updateRuntime(projectRoot) {
   }
 }
 async function findRuntimeRoot(projectRoot) {
-  const projectRuntime = path194.join(projectRoot, ".metaproject", "runtime", "keryx");
-  if (await pathExists(path194.join(projectRuntime, ".git"))) {
+  const projectRuntime = path195.join(projectRoot, ".metaproject", "runtime", "keryx");
+  if (await pathExists(path195.join(projectRuntime, ".git"))) {
     return projectRuntime;
   }
   const home = process.env.HOME;
   if (!home) {
     return null;
   }
-  const globalRuntime = path194.join(home, ".keryx", "keryx");
-  if (await pathExists(path194.join(globalRuntime, ".git"))) {
+  const globalRuntime = path195.join(home, ".keryx", "keryx");
+  if (await pathExists(path195.join(globalRuntime, ".git"))) {
     return globalRuntime;
   }
   return null;
 }
 async function createServiceDirs(metaprojectRoot, modules) {
   const dirs = [
-    path194.join(metaprojectRoot, "core"),
-    path194.join(metaprojectRoot, "hooks", "post-update.d"),
-    path194.join(metaprojectRoot, "modules"),
-    path194.join(metaprojectRoot, "rules"),
-    path194.join(metaprojectRoot, "skills", "project-rules"),
+    path195.join(metaprojectRoot, "core"),
+    path195.join(metaprojectRoot, "hooks", "post-update.d"),
+    path195.join(metaprojectRoot, "modules"),
+    path195.join(metaprojectRoot, "rules"),
+    path195.join(metaprojectRoot, "skills", "project-rules"),
     ...modules.enableGdgraph ? [
-      path194.join(metaprojectRoot, "core", "gdgraph"),
-      path194.join(metaprojectRoot, "skills", "gdgraph")
+      path195.join(metaprojectRoot, "core", "gdgraph"),
+      path195.join(metaprojectRoot, "skills", "gdgraph")
     ] : [],
     ...modules.enableGdctx ? [
-      path194.join(metaprojectRoot, "core", "gdctx"),
-      path194.join(metaprojectRoot, "skills", "gdctx")
+      path195.join(metaprojectRoot, "core", "gdctx"),
+      path195.join(metaprojectRoot, "skills", "gdctx")
     ] : [],
     ...modules.enableGdwiki ? [
-      path194.join(metaprojectRoot, "skills", "gdwiki"),
-      path194.join(metaprojectRoot, "wiki", "templates")
+      path195.join(metaprojectRoot, "skills", "gdwiki"),
+      path195.join(metaprojectRoot, "wiki", "templates")
     ] : [],
     ...modules.enableHealth ? [
-      path194.join(metaprojectRoot, "core", "health"),
-      path194.join(metaprojectRoot, "skills", "health")
+      path195.join(metaprojectRoot, "core", "health"),
+      path195.join(metaprojectRoot, "skills", "health")
     ] : [],
     ...modules.enableTesting ? [
-      path194.join(metaprojectRoot, "core", "testing"),
-      path194.join(metaprojectRoot, "skills", "testing")
+      path195.join(metaprojectRoot, "core", "testing"),
+      path195.join(metaprojectRoot, "skills", "testing")
     ] : [],
     ...modules.enableMemory ? [
-      path194.join(metaprojectRoot, "core", "memory"),
-      path194.join(metaprojectRoot, "skills", "memory"),
-      path194.join(metaprojectRoot, "memory", "templates")
+      path195.join(metaprojectRoot, "core", "memory"),
+      path195.join(metaprojectRoot, "skills", "memory"),
+      path195.join(metaprojectRoot, "memory", "templates")
     ] : [],
     ...modules.enableTasks ? [
-      path194.join(metaprojectRoot, "flows"),
-      path194.join(metaprojectRoot, "skills", "flow")
+      path195.join(metaprojectRoot, "flows"),
+      path195.join(metaprojectRoot, "skills", "flow")
     ] : [],
     ...modules.enableSecurity ? [
-      path194.join(metaprojectRoot, "core", "security")
+      path195.join(metaprojectRoot, "core", "security")
     ] : [],
     ...modules.enableSac ? [
-      path194.join(metaprojectRoot, "skills", "sac")
+      path195.join(metaprojectRoot, "skills", "sac")
     ] : []
   ];
   await Promise.all(dirs.map((dir) => mkdir62(dir, { recursive: true })));
 }
 async function installGdgraphCoreScripts2(metaprojectRoot) {
-  const gdgraphCoreRoot = path194.join(metaprojectRoot, "core", "gdgraph");
+  const gdgraphCoreRoot = path195.join(metaprojectRoot, "core", "gdgraph");
   await mkdir62(gdgraphCoreRoot, { recursive: true });
   for (const file of GDGRAPH_CORE_SOURCES) {
-    await copyFileIfChanged2(runtimeSourcePath2(`../gdgraph/${file}`), path194.join(gdgraphCoreRoot, file));
+    await copyFileIfChanged2(runtimeSourcePath2(`../gdgraph/${file}`), path195.join(gdgraphCoreRoot, file));
   }
-  await writeTextIfChanged4(path194.join(gdgraphCoreRoot, "cli.ts"), renderGdgraphCoreCli());
+  await writeTextIfChanged4(path195.join(gdgraphCoreRoot, "cli.ts"), renderGdgraphCoreCli());
 }
 async function installManagedHook2(projectRoot, hookName, blockId, content) {
   const hooksRoot = await resolveGitHooksRoot(projectRoot);
@@ -99814,7 +100719,7 @@ async function installManagedHook2(projectRoot, hookName, blockId, content) {
     return;
   }
   await mkdir62(hooksRoot, { recursive: true });
-  const hookPath = path194.join(hooksRoot, hookName);
+  const hookPath = path195.join(hooksRoot, hookName);
   const blockStart = `# keryx:${blockId}:begin`;
   const blockEnd = `# keryx:${blockId}:end`;
   const managedBlock = `${blockStart}
@@ -99835,7 +100740,7 @@ async function removeManagedHook2(projectRoot, hookName, blockId) {
   if (!hooksRoot) {
     return;
   }
-  const hookPath = path194.join(hooksRoot, hookName);
+  const hookPath = path195.join(hooksRoot, hookName);
   if (!await pathExists(hookPath)) {
     return;
   }
@@ -99857,7 +100762,7 @@ async function prePushHasSecurityBlock2(projectRoot) {
   if (!hooksRoot) {
     return false;
   }
-  const hookPath = path194.join(hooksRoot, "pre-push");
+  const hookPath = path195.join(hooksRoot, "pre-push");
   if (!await pathExists(hookPath)) {
     return false;
   }
@@ -99872,7 +100777,7 @@ async function agentSettingsHasSecuritySentinel2(projectRoot) {
   return (await readFile99(file, "utf8")).includes(AGENT_HOOKS_SENTINEL);
 }
 async function readManifest5(metaprojectRoot) {
-  const manifestPath = path194.join(metaprojectRoot, "metaproject.json");
+  const manifestPath = path195.join(metaprojectRoot, "metaproject.json");
   if (!await pathExists(manifestPath)) {
     return {
       exists: false,
@@ -99941,7 +100846,7 @@ async function inferManifestFromExistingMetaproject(metaprojectRoot) {
 }
 async function anyPathExists(root, candidates) {
   for (const candidate of candidates) {
-    if (await pathExists(path194.join(root, candidate))) {
+    if (await pathExists(path195.join(root, candidate))) {
       return true;
     }
   }
@@ -99964,13 +100869,13 @@ function parseUpdateArgs(args) {
   };
 }
 async function runPostUpdateHooks(projectRoot) {
-  const hooksDir = path194.join(projectRoot, ".metaproject", "hooks", "post-update.d");
+  const hooksDir = path195.join(projectRoot, ".metaproject", "hooks", "post-update.d");
   if (!await pathExists(hooksDir)) {
     return;
   }
   const entries = (await readdir35(hooksDir)).sort();
   for (const entry of entries) {
-    const hookPath = path194.join(hooksDir, entry);
+    const hookPath = path195.join(hooksDir, entry);
     try {
       await accessExecutable(hookPath);
     } catch {
@@ -100011,14 +100916,14 @@ async function writeTextIfChanged4(filePath, content) {
   if (await pathExists(filePath) && await readFile99(filePath, "utf8") === content) {
     return;
   }
-  await mkdir62(path194.dirname(filePath), { recursive: true });
+  await mkdir62(path195.dirname(filePath), { recursive: true });
   await writeFile54(filePath, content, "utf8");
 }
 async function writeTextIfMissing4(filePath, content) {
   if (await pathExists(filePath)) {
     return;
   }
-  await mkdir62(path194.dirname(filePath), { recursive: true });
+  await mkdir62(path195.dirname(filePath), { recursive: true });
   await writeFile54(filePath, content, "utf8");
 }
 async function copyFileIfChanged2(from, to) {
@@ -100026,7 +100931,7 @@ async function copyFileIfChanged2(from, to) {
   if (await pathExists(to) && await readFile99(to, "utf8") === next) {
     return;
   }
-  await mkdir62(path194.dirname(to), { recursive: true });
+  await mkdir62(path195.dirname(to), { recursive: true });
   await writeFile54(to, next, "utf8");
 }
 function runtimeSourcePath2(relativePath) {
@@ -100035,7 +100940,7 @@ function runtimeSourcePath2(relativePath) {
     return directPath;
   }
   if (relativePath.startsWith("../")) {
-    const packagedSourcePath = path194.join(path194.dirname(fileURLToPath7(import.meta.url)), "..", "src", relativePath.slice(3));
+    const packagedSourcePath = path195.join(path195.dirname(fileURLToPath7(import.meta.url)), "..", "src", relativePath.slice(3));
     if (existsSync35(packagedSourcePath)) {
       return packagedSourcePath;
     }
@@ -100070,7 +100975,7 @@ function printHelp20() {
 
 // src/commands/dashboard.ts
 import { spawn as spawn7 } from "child_process";
-import path195 from "path";
+import path196 from "path";
 init_args();
 async function dashboardCommand(args = []) {
   const options = parseOptions(args);
@@ -100081,7 +100986,7 @@ async function dashboardCommand(args = []) {
   }
   if (subcommand === "build") {
     const result = await buildDashboard();
-    const rel = path195.relative(process.cwd(), result.path);
+    const rel = path196.relative(process.cwd(), result.path);
     console.log(`  ${style.green(symbols.ok)} Dashboard built ${style.cyan(symbols.arrow)} ${style.cyan(rel)}`);
     note(`Open it: keryx dashboard open`);
     return;
@@ -100089,7 +100994,7 @@ async function dashboardCommand(args = []) {
   if (subcommand === "open") {
     const result = await buildDashboard();
     await openFile(result.path);
-    const rel = path195.relative(process.cwd(), result.path);
+    const rel = path196.relative(process.cwd(), result.path);
     console.log(`  ${style.green(symbols.ok)} Opened ${style.cyan(rel)}`);
     return;
   }
@@ -100138,7 +101043,7 @@ import { readFileSync as readFileSync8 } from "fs";
 // src/agents/bootstrap.ts
 import { mkdir as mkdir63, readFile as readFile100, writeFile as writeFile55 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import path196 from "path";
+import path197 from "path";
 init_fs();
 var AGENT_BOOTSTRAP_START = "<!-- keryx:global-bootstrap -->";
 var AGENT_BOOTSTRAP_END = "<!-- /keryx:global-bootstrap -->";
@@ -100148,35 +101053,35 @@ var AGENT_BOOTSTRAP_RUNTIMES = [
     aliases: ["claude-code"],
     label: "Claude Code",
     fileName: "CLAUDE.md",
-    filePath: (homeRoot) => path196.join(homeRoot, ".claude", "CLAUDE.md")
+    filePath: (homeRoot) => path197.join(homeRoot, ".claude", "CLAUDE.md")
   },
   {
     id: "opencode",
     aliases: ["open-code"],
     label: "OpenCode",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path196.join(homeRoot, ".config", "opencode", "AGENTS.md")
+    filePath: (homeRoot) => path197.join(homeRoot, ".config", "opencode", "AGENTS.md")
   },
   {
     id: "zcode",
     aliases: ["zed", "zed-code"],
     label: "ZCode",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path196.join(homeRoot, ".zcode", "AGENTS.md")
+    filePath: (homeRoot) => path197.join(homeRoot, ".zcode", "AGENTS.md")
   },
   {
     id: "codex",
     aliases: [],
     label: "Codex",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path196.join(homeRoot, ".codex", "AGENTS.md")
+    filePath: (homeRoot) => path197.join(homeRoot, ".codex", "AGENTS.md")
   },
   {
     id: "antigravity",
     aliases: ["antigravuty", "antigravity-code"],
     label: "Antigravity",
     fileName: "AGENTS.md",
-    filePath: (homeRoot) => path196.join(homeRoot, ".config", "antigravity", "AGENTS.md")
+    filePath: (homeRoot) => path197.join(homeRoot, ".config", "antigravity", "AGENTS.md")
   }
 ];
 function agentBootstrapRuntimeIds() {
@@ -100224,7 +101129,7 @@ async function installAgentBootstrap(runtime, options = {}) {
   const dryRun = options.dryRun === true;
   const wrote = next !== current;
   if (wrote && !dryRun) {
-    await mkdir63(path196.dirname(filePath), { recursive: true });
+    await mkdir63(path197.dirname(filePath), { recursive: true });
     await writeFile55(filePath, next, "utf8");
   }
   const status = dryRun ? statusFromContent(runtime, filePath, exists, next) : await agentBootstrapStatus(runtime, homeRoot);
@@ -100761,7 +101666,7 @@ function printBootstrapHelp() {
 // src/commands/metrics.ts
 init_args();
 import { readFile as readFile101 } from "fs/promises";
-import path198 from "path";
+import path199 from "path";
 
 // src/metrics/benchmark.ts
 var RELIABILITIES2 = new Set(["exact", "estimated", "unknown"]);
@@ -101578,7 +102483,7 @@ function buildContainmentManifest(inputs, options = {}) {
 
 // src/metrics/oracle-runner.ts
 import { mkdir as mkdir64, writeFile as writeFile56 } from "fs/promises";
-import path197 from "path";
+import path198 from "path";
 
 // src/metrics/ir.ts
 function toIdSet(ids) {
@@ -102024,9 +102929,9 @@ function buildEvidenceBundle(input, options = {}) {
 async function persistEvidenceBundle(outDir, bundle, ladder = "metastore") {
   const safeTarget = bundle.target.replace(/[^A-Za-z0-9._/-]/g, "_");
   const safeCase = bundle.caseId.replace(/[^A-Za-z0-9._-]/g, "_");
-  const dir = path197.join(outDir, "bench", ladder, safeTarget, safeCase, bundle.variant, String(bundle.seed));
+  const dir = path198.join(outDir, "bench", ladder, safeTarget, safeCase, bundle.variant, String(bundle.seed));
   await mkdir64(dir, { recursive: true });
-  const write = (name, value) => writeFile56(path197.join(dir, name), `${JSON.stringify(value, null, 2)}
+  const write = (name, value) => writeFile56(path198.join(dir, name), `${JSON.stringify(value, null, 2)}
 `, "utf8");
   await Promise.all([
     write("inputs.json", bundle.inputs),
@@ -102066,7 +102971,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
     console.log("# metrics status");
     console.log("");
     console.log(`root: ${root}`);
-    console.log(`enabled: ${await Bun.file(path198.join(projectRoot, ".metaproject", "metaproject.json")).exists() ? "yes" : "no"}`);
+    console.log(`enabled: ${await Bun.file(path199.join(projectRoot, ".metaproject", "metaproject.json")).exists() ? "yes" : "no"}`);
     const latest = await readLatestPointer(root);
     console.log(`latest: ${latest.status}`);
     return;
@@ -102078,7 +102983,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const record = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+    const record = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
     const result = validateRunRecord(record);
     console.log(result.valid ? "valid: yes" : "valid: no");
     for (const error of result.errors)
@@ -102103,7 +103008,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const file = path198.join(metricsRoot(projectRoot), "runs", `${runId}.json`);
+    const file = path199.join(metricsRoot(projectRoot), "runs", `${runId}.json`);
     if (!await Bun.file(file).exists()) {
       console.error(`Run not found: ${runId}`);
       process.exitCode = 1;
@@ -102120,8 +103025,8 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const a = JSON.parse(await readFile101(path198.join(metricsRoot(projectRoot), "runs", `${runA}.json`), "utf8"));
-    const b = JSON.parse(await readFile101(path198.join(metricsRoot(projectRoot), "runs", `${runB}.json`), "utf8"));
+    const a = JSON.parse(await readFile101(path199.join(metricsRoot(projectRoot), "runs", `${runA}.json`), "utf8"));
+    const b = JSON.parse(await readFile101(path199.join(metricsRoot(projectRoot), "runs", `${runB}.json`), "utf8"));
     const comparison = compareExecutionRuns(a, b);
     console.log(stableJson(comparison));
     return;
@@ -102155,8 +103060,8 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       return;
     }
     const template = createPairedBenchmarkTemplate(taskIds);
-    await Bun.write(path198.resolve(projectRoot, out), stableJson(template));
-    console.log(`manifest: ${path198.relative(projectRoot, path198.resolve(projectRoot, out))}`);
+    await Bun.write(path199.resolve(projectRoot, out), stableJson(template));
+    console.log(`manifest: ${path199.relative(projectRoot, path199.resolve(projectRoot, out))}`);
     return;
   }
   if (subcommand === "benchmark" && args[1] === "run") {
@@ -102170,7 +103075,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
       process.exitCode = 1;
       return;
     }
-    const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+    const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
     const input = Array.isArray(raw) ? raw : raw.runs ?? [];
     const result = validatePairedBenchmark(input);
     console.log(stableJson(result));
@@ -102182,7 +103087,7 @@ async function metricsCommand(args = [], projectRoot = process.cwd()) {
   process.exitCode = 1;
 }
 async function loadAffectedSets(projectRoot, file) {
-  const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
   const map = new Map;
   for (const entry of raw.targets ?? []) {
     if (typeof entry.target === "string")
@@ -102253,7 +103158,7 @@ async function runHarnessLayer(projectRoot, args, ladder) {
   let tasks;
   let model;
   try {
-    const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, resultsPath), "utf8"));
     tasks = raw.tasks ?? [];
     model = raw.model;
   } catch (error) {
@@ -102284,7 +103189,7 @@ async function runSafetyCompletionHonestyLayer(projectRoot, args, ladder) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -102309,7 +103214,7 @@ async function runSafetyFalsePremiseLayer(projectRoot, args, ladder) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -102334,7 +103239,7 @@ async function runSafetyContainmentLayer(projectRoot, args, ladder, caseClass) {
   let cases;
   let model;
   try {
-    const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, resultsPath), "utf8"));
+    const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, resultsPath), "utf8"));
     cases = raw.cases ?? [];
     model = raw.model;
   } catch (error) {
@@ -102396,12 +103301,12 @@ async function runGdgraphLayer(projectRoot, args, ladder) {
   }
   const manifests = buildOracleManifestsByGold(inputs, { ladder });
   if (outDir) {
-    const resolvedOut = path198.resolve(projectRoot, outDir);
+    const resolvedOut = path199.resolve(projectRoot, outDir);
     for (const input of inputs) {
       for (const named of input.golds) {
         const bundle = buildEvidenceBundle({ target: input.target, system: input.system, gold: named.gold }, { ladder, goldReference: goldPathFor(named.kind), timestamp: new Date().toISOString() });
-        const dir = await persistEvidenceBundle(path198.join(resolvedOut, named.kind), bundle, ladder);
-        console.error(`bundle[${named.kind}]: ${path198.relative(projectRoot, dir)}`);
+        const dir = await persistEvidenceBundle(path199.join(resolvedOut, named.kind), bundle, ladder);
+        console.error(`bundle[${named.kind}]: ${path199.relative(projectRoot, dir)}`);
       }
     }
   }
@@ -102425,7 +103330,7 @@ async function runGdgraphLayer(projectRoot, args, ladder) {
   return allValid;
 }
 async function loadCoverageMap2(projectRoot, file) {
-  const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
   return raw.coverageMap ?? {};
 }
 async function runTestingLayer(projectRoot, args, ladder) {
@@ -102462,7 +103367,7 @@ async function runTestingLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadMemoryGoldK(projectRoot, file) {
-  const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
   return typeof raw.k === "number" && raw.k > 0 ? raw.k : 3;
 }
 async function runMemoryLayer(projectRoot, args, ladder) {
@@ -102499,11 +103404,11 @@ async function runMemoryLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadWikiGoldK(projectRoot, file) {
-  const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
   return typeof raw.k === "number" && raw.k > 0 ? raw.k : 5;
 }
 async function loadWikiGroundedness(projectRoot, file) {
-  const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
   const map = new Map;
   for (const entry of raw.targets ?? []) {
     if (typeof entry.target !== "string" || !Array.isArray(entry.scores) || entry.scores.length !== 3)
@@ -102559,7 +103464,7 @@ async function runWikiLayer(projectRoot, args, ladder) {
   return result.valid;
 }
 async function loadGdctxFacts(projectRoot, file) {
-  const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, file), "utf8"));
+  const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, file), "utf8"));
   const inputs = [];
   for (const entry of raw.inputs ?? []) {
     if (typeof entry.input === "string") {
@@ -102597,7 +103502,7 @@ async function collect(projectRoot, args) {
     process.exitCode = 1;
     return;
   }
-  const raw = JSON.parse(await readFile101(path198.resolve(projectRoot, eventFile), "utf8"));
+  const raw = JSON.parse(await readFile101(path199.resolve(projectRoot, eventFile), "utf8"));
   const events = Array.isArray(raw) ? raw : raw.events;
   const startedAt = optionValue(args, "--started-at") ?? events[0]?.timestamp_utc ?? new Date().toISOString();
   const finishedAt = optionValue(args, "--finished-at") ?? events.at(-1)?.timestamp_utc ?? startedAt;
@@ -102613,11 +103518,11 @@ async function collect(projectRoot, args) {
     parentRunId: optionValue(args, "--parent-run-id") ?? null
   });
   const result = await writeRunArtifacts(metricsRoot(projectRoot), record, { cwd: projectRoot });
-  console.log(`json: ${path198.relative(projectRoot, result.jsonPath)}`);
-  console.log(`markdown: ${path198.relative(projectRoot, result.markdownPath)}`);
+  console.log(`json: ${path199.relative(projectRoot, result.jsonPath)}`);
+  console.log(`markdown: ${path199.relative(projectRoot, result.markdownPath)}`);
 }
 function metricsRoot(projectRoot) {
-  return path198.join(projectRoot, ".metaproject", "data", "metrics");
+  return path199.join(projectRoot, ".metaproject", "data", "metrics");
 }
 function printMetricsHelp() {
   console.log(`keryx metrics
@@ -103090,7 +103995,7 @@ Providers with a sanctioned subscription login: grok (SuperGrok), openai (ChatGP
 Claude Pro/Max, Gemini Google-account login, and DeepSeek OAuth are not offered.
 `);
 }
-async function authCommand(args) {
+async function authCommand2(args) {
   const command = args[0];
   if (!command || command === "--help" || command === "-h") {
     printAuthHelp();
@@ -103484,7 +104389,7 @@ var CLI_ROUTES = {
   modules: modulesCommand,
   projects: projectsCommand,
   providers: providersCommand,
-  auth: authCommand,
+  auth: authCommand2,
   serve: serveCommand,
   update: updateCommand,
   dashboard: dashboardCommand,