blun-king-cli 9.1.510 → 9.1.511

package/agent-spine-plugin/src/hook.js

@@ -13,12 +13,13 @@ import {
 } from "./lib/selfstarter.js";
 import { claimChannelEvent } from "./lib/channel-runtime.js";
 import { syncPersonaRosterFromEnvironment } from "./lib/persona-runtime.js";
+import { captureMustRememberPrompt, recordPreflightFailure, runPreflight, verifyPreflightReceipt } from "./lib/preflight.js";
 import { isMainModule } from "./lib/runtime.js";
 
 const MAX_STDIN_BYTES = 64 * 1024;
 const CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit", "PreCompact", "PostCompact"]);
 const KNOWN_EVENTS = new Set([
-  ...CONTEXT_EVENTS, "PreToolUse", "PostToolUse", "Stop", "SubagentStop"
+  ...CONTEXT_EVENTS, "InstructionsLoaded", "PreToolUse", "PostToolUse", "Stop", "SubagentStop"
 ]);
 const ID_RE = /^[A-Za-z0-9][A-Za-z0-9:_.@/-]{0,127}$/;
 const ATTENTION_WRITE_EVENTS = new Set(["UserPromptSubmit", "PostToolUse", "Stop", "SubagentStop"]);
@@ -43,29 +44,29 @@ function boundedId(value, field) {
   return value;
 }
 
-function promptFromInput(input) {
-  for (const key of ["prompt", "user_prompt", "message", "input"]) {
-    const value = input[key];
-    if (typeof value === "string") return value;
-    if (Array.isArray(value)) {
-      const text = value
-        .filter((part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string")
-        .map((part) => part.text)
-        .join("\n")
-        .trim();
-      if (text) return text;
-    }
-  }
-  return null;
-}
-
-function hostFromInput(input) {
-  const explicit = input.host || input.provider || process.env.AGENTSPINE_HOST;
-  if (["claude", "codex", "generic"].includes(explicit)) return explicit;
-  if ((typeof input.model === "string" && input.model.trim()) || process.env.PLUGIN_ROOT || process.env.CODEX_HOME
-    || process.env.BLUN_PLUGIN_ROOT || process.env.BLUN_HOME) return "codex";
-  return "claude";
-}
+function promptFromInput(input) {
+  for (const key of ["prompt", "user_prompt", "message", "input"]) {
+    const value = input[key];
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      const text = value
+        .filter((part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+      if (text) return text;
+    }
+  }
+  return null;
+}
+
+function hostFromInput(input) {
+  const explicit = input.host || input.provider || process.env.AGENTSPINE_HOST;
+  if (["claude", "codex", "generic"].includes(explicit)) return explicit;
+  if ((typeof input.model === "string" && input.model.trim()) || process.env.PLUGIN_ROOT || process.env.CODEX_HOME
+    || process.env.BLUN_PLUGIN_ROOT || process.env.BLUN_HOME) return "codex";
+  return "claude";
+}
 
 function gatewayEnvironmentContext(env = process.env) {
   if (env.AGENTSPINE_GATEWAY_CONTEXT !== "agentspine.gateway-start/v1") return null;
@@ -109,7 +110,7 @@ async function runtimeScope(input, root, userStateRoot = null) {
   };
 }
 
-function renderContext(event, catalog, briefing, signal = null, attentionEvent = null, selfstarter = null, channelEvent = null, sourceDiagnostics = null) {
+function renderContext(event, catalog, briefing, signal = null, attentionEvent = null, selfstarter = null, channelEvent = null, sourceDiagnostics = null, preflight = null) {
   const loaded = sourceDiagnostics?.status === "loaded";
   const packet = {
     schema: "agentspine.hook-context/v1",
@@ -175,6 +176,23 @@ function renderContext(event, catalog, briefing, signal = null, attentionEvent =
     } : null,
     indexedSources: catalog.summary.total,
     sourceResolution: sourceDiagnostics,
+    preflight: preflight ? {
+      schema: preflight.receipt.schema,
+      receiptId: preflight.receipt.id,
+      promptDigest: preflight.receipt.promptDigest,
+      briefingDigest: preflight.receipt.briefingDigest,
+      createdAt: preflight.receipt.createdAt,
+      expiresAt: preflight.receipt.expiresAt,
+      policy: preflight.policy,
+      pendingMustRemember: preflight.pendingMustRemember ? {
+        id: preflight.pendingMustRemember.candidate?.id || null,
+        status: preflight.pendingMustRemember.candidate?.status || (preflight.pendingMustRemember.rejected ? "rejected" : null),
+        reason: preflight.pendingMustRemember.reason || null
+      } : null,
+      briefing: preflight.briefing,
+      instruction: "This exact turn passed the mandatory pre-answer gate. Host-native instruction files were verified but not duplicated; apply the host-loaded instructions and the remaining preflight briefing before answering.",
+      authority: "preflight-proof-only"
+    } : null,
     briefing,
     authority: "context-only"
   };
@@ -344,65 +362,65 @@ async function captureAttentionLifecycle(input, event, root, scope) {
   });
 }
 
-export function blunRuntimeContext(context) {
-  const detailed = JSON.parse(context);
-  const sourceResolution = detailed.sourceResolution ? {
-    status: detailed.sourceResolution.status || null,
-    reason: detailed.sourceResolution.reason || null
-  } : null;
-  const runtime = {
-    schema: "agentspine.blun-runtime-context/v1",
-    event: detailed.event,
-    loaded: Boolean(detailed.loaded),
-    failedClosed: detailed.failedClosed ? true : undefined,
-    indexedSources: detailed.indexedSources || 0,
-    sourceResolution,
-    instruction: detailed.loaded
-      ? "Detailed AgentSpine context is available on demand through session_briefing. Load it only when the current request needs continuity."
-      : detailed.instruction,
-    authority: "context-only"
-  };
-  if (detailed.signal && (detailed.signal.captured || detailed.signal.accepted || detailed.signal.reason)) {
-    runtime.signal = detailed.signal;
-  }
-  if (detailed.attentionEvent
-    && (detailed.attentionEvent.captured || detailed.attentionEvent.duplicate || detailed.attentionEvent.reason)) {
-    runtime.attentionEvent = detailed.attentionEvent;
-  }
-  if (detailed.selfstarter && (detailed.selfstarter.active || detailed.selfstarter.blocked)) {
-    runtime.selfstarter = detailed.selfstarter;
-  }
-  if (detailed.channelEvent?.active) runtime.channelEvent = detailed.channelEvent;
-  return JSON.stringify(runtime);
-}
-
-export function blunRuntimeMessage(context) {
-  const runtime = JSON.parse(blunRuntimeContext(context));
-  const base = runtime.loaded
-    ? `AgentSpine ready: ${runtime.indexedSources} sources indexed. Load detailed continuity only on demand through session_briefing.`
-    : `AgentSpine unavailable${runtime.sourceResolution?.reason ? `: ${runtime.sourceResolution.reason}` : ""}. ${runtime.instruction}`;
-  const active = {};
-  if (runtime.signal && (runtime.signal.captured || runtime.signal.accepted
-    || String(runtime.signal.reason || "").startsWith("rejected:"))) {
-    active.signal = runtime.signal;
-  }
-  if (runtime.attentionEvent && (runtime.attentionEvent.captured || runtime.attentionEvent.duplicate
-    || String(runtime.attentionEvent.reason || "").startsWith("rejected:"))) {
-    active.attentionEvent = runtime.attentionEvent;
-  }
-  if (runtime.selfstarter) active.selfstarter = runtime.selfstarter;
-  if (runtime.channelEvent) active.channelEvent = runtime.channelEvent;
-  return Object.keys(active).length === 0
-    ? base
-    : `${base}\nActive AgentSpine runtime data: ${JSON.stringify(active)}`;
-}
-
-function hookOutput(event, context) {
-  if (process.env.BLUN_PLUGIN_ROOT) {
-    return { hookSpecificOutput: { hookEventName: event, message: blunRuntimeMessage(context) } };
-  }
-  return { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
-}
+export function blunRuntimeContext(context) {
+  const detailed = JSON.parse(context);
+  const sourceResolution = detailed.sourceResolution ? {
+    status: detailed.sourceResolution.status || null,
+    reason: detailed.sourceResolution.reason || null
+  } : null;
+  const runtime = {
+    schema: "agentspine.blun-runtime-context/v1",
+    event: detailed.event,
+    loaded: Boolean(detailed.loaded),
+    failedClosed: detailed.failedClosed ? true : undefined,
+    indexedSources: detailed.indexedSources || 0,
+    sourceResolution,
+    instruction: detailed.loaded
+      ? "Detailed AgentSpine context is available on demand through session_briefing. Load it only when the current request needs continuity."
+      : detailed.instruction,
+    authority: "context-only"
+  };
+  if (detailed.signal && (detailed.signal.captured || detailed.signal.accepted || detailed.signal.reason)) {
+    runtime.signal = detailed.signal;
+  }
+  if (detailed.attentionEvent
+    && (detailed.attentionEvent.captured || detailed.attentionEvent.duplicate || detailed.attentionEvent.reason)) {
+    runtime.attentionEvent = detailed.attentionEvent;
+  }
+  if (detailed.selfstarter && (detailed.selfstarter.active || detailed.selfstarter.blocked)) {
+    runtime.selfstarter = detailed.selfstarter;
+  }
+  if (detailed.channelEvent?.active) runtime.channelEvent = detailed.channelEvent;
+  return JSON.stringify(runtime);
+}
+
+export function blunRuntimeMessage(context) {
+  const runtime = JSON.parse(blunRuntimeContext(context));
+  const base = runtime.loaded
+    ? `AgentSpine ready: ${runtime.indexedSources} sources indexed. Load detailed continuity only on demand through session_briefing.`
+    : `AgentSpine unavailable${runtime.sourceResolution?.reason ? `: ${runtime.sourceResolution.reason}` : ""}. ${runtime.instruction}`;
+  const active = {};
+  if (runtime.signal && (runtime.signal.captured || runtime.signal.accepted
+    || String(runtime.signal.reason || "").startsWith("rejected:"))) {
+    active.signal = runtime.signal;
+  }
+  if (runtime.attentionEvent && (runtime.attentionEvent.captured || runtime.attentionEvent.duplicate
+    || String(runtime.attentionEvent.reason || "").startsWith("rejected:"))) {
+    active.attentionEvent = runtime.attentionEvent;
+  }
+  if (runtime.selfstarter) active.selfstarter = runtime.selfstarter;
+  if (runtime.channelEvent) active.channelEvent = runtime.channelEvent;
+  return Object.keys(active).length === 0
+    ? base
+    : `${base}\nActive AgentSpine runtime data: ${JSON.stringify(active)}`;
+}
+
+function hookOutput(event, context) {
+  if (process.env.BLUN_PLUGIN_ROOT) {
+    return { hookSpecificOutput: { hookEventName: event, message: blunRuntimeMessage(context) } };
+  }
+  return { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
+}
 
 function candidatePaths(value, output = []) {
   if (!value) return output;
@@ -459,16 +477,44 @@ function deny(reason) {
   })}\n`);
 }
 
+function blockPrompt(reason) {
+  process.stdout.write(`${JSON.stringify({
+    decision: "block",
+    reason,
+    hookSpecificOutput: { hookEventName: "UserPromptSubmit", decision: "block", reason }
+  })}\n`);
+}
+
 export async function runHook(payload = null) {
   const input = payload || await readStdin();
   if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("hook input must be one JSON object");
   const event = input.hook_event_name || input.event_name || "";
   if (!KNOWN_EVENTS.has(event)) throw new Error(`unsupported hook event: ${event || "missing"}`);
+  if (event === "InstructionsLoaded") {
+    const file = input.file_path;
+    if (typeof file !== "string" || !file || !["User", "Project", "Local", "Managed"].includes(input.memory_type)
+      || !["session_start", "nested_traversal", "path_glob_match", "include", "compact"].includes(input.load_reason)) {
+      throw new Error("InstructionsLoaded payload is invalid");
+    }
+    if (payload) return { blocked: false, observed: true };
+    process.stdout.write("{}\n");
+    return;
+  }
   const cwd = await canonicalPath(input.cwd || process.cwd());
   const host = hostFromInput(input);
+  const instructionHost = host === "generic" ? input.instruction_host : host;
+  if (host === "generic" && !["claude", "codex"].includes(instructionHost)) {
+    const reason = "AgentSpine generic hosts must bind instruction_host to claude or codex";
+    if (event === "UserPromptSubmit") {
+      if (payload) return { blocked: true, failedClosed: true, reason };
+      blockPrompt(reason);
+      return;
+    }
+    throw new Error(reason);
+  }
   let resolvedSources;
   try {
-    resolvedSources = await resolveHostSourceCatalog({ host, cwd, input });
+    resolvedSources = await resolveHostSourceCatalog({ host: instructionHost, cwd, input });
   } catch (error) {
     const reason = `AgentSpine source resolution failed closed: ${error.message}`;
     if (event === "PreToolUse" && isMutationTool(input.tool_name)) {
@@ -476,6 +522,11 @@ export async function runHook(payload = null) {
       deny(reason);
       return;
     }
+    if (event === "UserPromptSubmit") {
+      if (payload) return { blocked: true, failedClosed: true, reason };
+      blockPrompt(reason);
+      return;
+    }
     const context = JSON.stringify({
       schema: "agentspine.hook-context/v1", event, loaded: false, failedClosed: true,
       indexedSources: 0, sourceResolution: { status: "failed-closed", reason: error.message },
@@ -580,6 +631,7 @@ export async function runHook(payload = null) {
 
   if (CONTEXT_EVENTS.has(event)) {
     let signal = null;
+    let preflight = null;
     try {
       await syncPersonaRosterFromEnvironment({ root, env: process.env, now: input.timestamp || new Date() });
       scope ||= await runtimeScope(input, root, resolvedSources.userStateRoot);
@@ -588,6 +640,15 @@ export async function runHook(payload = null) {
       if (selfstarter?.job && !scope.currentTaskId) scope.currentTaskId = selfstarter.job.taskId;
       if (event === "UserPromptSubmit") {
         const prompt = promptFromInput(input);
+        if (prompt === null) throw new Error("mandatory preflight requires the exact current prompt");
+        preflight = await runPreflight({
+          input, scope, resolvedSources, prompt, now: input.timestamp || new Date(), env: process.env
+        });
+        if (!await verifyPreflightReceipt({
+          receipt: preflight.receipt, input, scope, resolvedSources, prompt,
+          now: input.timestamp || new Date(), env: process.env
+        })) throw new Error("newly created preflight receipt failed exact turn verification");
+        preflight.pendingMustRemember = await captureMustRememberPrompt({ prompt, receipt: preflight.receipt, env: process.env });
         try {
           attentionEvent = await captureAttentionLifecycle(input, event, root, scope);
         } catch (error) {
@@ -609,17 +670,32 @@ export async function runHook(payload = null) {
         root, cwd, host: scope.host, entityId: scope.entityId, groupId: scope.groupId,
         projectId: scope.projectId, currentTaskId: scope.currentTaskId,
         includePrivate: Boolean(scope.entityId && !scope.groupId),
-        focusActive: true, includeSourceContent: !scope.groupId,
-        maxBytes: scope.config.maxBriefingBytes,
+        focusActive: true, includeSourceContent: event === "UserPromptSubmit" ? false : !scope.groupId,
+        maxBytes: event === "UserPromptSubmit" ? 4096 : scope.config.maxBriefingBytes,
         now: input.timestamp || new Date(),
         catalog, userStateRoot: resolvedSources.userStateRoot, sourceDiagnostics: resolvedSources.diagnostics,
         prompt: event === "UserPromptSubmit" ? promptFromInput(input) : null
       });
-      const context = renderContext(event, catalog, briefing, signal, attentionEvent, selfstarter, channelEvent, resolvedSources.diagnostics);
-      if (payload) return { blocked: false, context, briefing, signal, attentionEvent, channelEvent, catalogPath };
+      const context = renderContext(event, catalog, briefing, signal, attentionEvent, selfstarter, channelEvent, resolvedSources.diagnostics, preflight);
+      if (event === "UserPromptSubmit" && Buffer.byteLength(context) > 9500) {
+        throw new Error("mandatory preflight context exceeds the host hook injection limit");
+      }
+      if (event === "UserPromptSubmit" && !await verifyPreflightReceipt({
+        receipt: preflight.receipt, input, scope, resolvedSources, prompt: promptFromInput(input),
+        now: input.timestamp || new Date(), env: process.env, consume: true
+      })) throw new Error("preflight receipt could not be consumed atomically for this exact turn");
+      if (payload) return { blocked: false, context, briefing, preflight, signal, attentionEvent, channelEvent, catalogPath };
       process.stdout.write(`${JSON.stringify(hookOutput(event, context))}\n`);
       return;
     } catch (error) {
+      if (event === "UserPromptSubmit") {
+        await recordPreflightFailure({ receiptId: preflight?.receipt?.id || null, input, host,
+          error, now: input.timestamp || new Date(), env: process.env }).catch(() => {});
+        const reason = `AgentSpine pre-answer preflight blocked this turn: ${error.message}`;
+        if (payload) return { blocked: true, failedClosed: true, reason, error: error.message, catalogPath };
+        blockPrompt(reason);
+        return;
+      }
       const context = JSON.stringify({
         schema: "agentspine.hook-context/v1", event, loaded: false, failedClosed: true,
         indexedSources: catalog.summary.total,
@@ -641,6 +717,8 @@ export async function runHook(payload = null) {
 if (isMainModule(import.meta.url)) {
   runHook().catch((error) => {
     process.stderr.write(`AgentSpine hook: ${String(error.message).slice(0, 2048)}\n`);
-    process.exitCode = 1;
+    // Claude command hooks treat exit 2 as a blocking failure. Exit 1 is
+    // fail-open, which is unsafe for malformed pre-answer payloads.
+    process.exitCode = 2;
   });
 }

package/agent-spine-plugin/src/index.js

@@ -49,6 +49,12 @@ export {
 } from "./lib/gateway-runtime.js";
 export { createTelegramAdapter } from "./lib/telegram-adapter.js";
 export { evaluateVoiceOutput, voiceCue } from "./lib/voice-runtime.js";
+export {
+  MUST_REMEMBER_SCHEMA, PREFLIGHT_POLICY_SCHEMA, PREFLIGHT_SCHEMA, RETRIEVAL_QUERY_SCHEMA,
+  RETRIEVAL_RESULT_SCHEMA, captureMustRememberPrompt, configurePreflightPolicy, confirmMustRemember, preflightStatus,
+  recordPreflightFailure,
+  proposeMustRemember, purgeMustRemember, rollbackMustRemember, runPreflight, verifyPreflightReceipt
+} from "./lib/preflight.js";
 export { runWorker, runWorkerTick } from "./worker.js";
 export {
   configureSharing, deleteShared, initDirectoryAdapter, inspectSharing, loadSharing,

package/agent-spine-plugin/src/lib/acceptance.js

@@ -8,6 +8,7 @@ import { configureContinuity, purgeContinuity } from "./continuity.js";
 import { createTask } from "./coordination.js";
 import { linkEntities, upsertEntity } from "./graph.js";
 import { loadLearning, rollbackLearning } from "./learning.js";
+import { configurePreflightPolicy } from "./preflight.js";
 import {
   grantExecution, loadSelfstarter, registerJob
 } from "./selfstarter.js";
@@ -74,6 +75,28 @@ export async function runVisibleAcceptance() {
   const expectedSources = sourceHashes(sources);
   try {
     for (const [name, content] of Object.entries(sources)) await writeFile(join(projectRoot, name), content, "utf8");
+    const adapterPath = join(projectRoot, "mnemo-acceptance.mjs");
+    const adapterSource = `let body = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => { body += chunk; });
+process.stdin.on("end", () => {
+  const query = JSON.parse(body);
+  process.stdout.write(JSON.stringify({
+    schema: "agentspine.retrieval-result/v1", providerId: query.providerId,
+    queryDigest: query.queryDigest, status: "ok", rejected: 1,
+    items: [{ id: "mnemo:aurora-finding", revision: "1", claim: "Prüfe die bestehenden Findings vor neuen Änderungen.",
+      source: "mnemo", scope: { agentId: query.agentId, userId: query.userId, tenantId: query.tenantId,
+        projectId: query.projectId }, validity: "current", confidence: 1, whyLoaded: "exact project scope" }]
+  }));
+});
+`;
+    await writeFile(adapterPath, adapterSource, "utf8");
+    await configurePreflightPolicy({ confirmation: "local-owner-confirmed", env: process.env, profile: {
+      id: "preflight-policy:acceptance-freja", agentId: "person:freja", host: "claude", profileId: "default",
+      tenantId: "local-tenant", enabled: true, providers: [{ schema: "agentspine.retrieval-provider/v1",
+        id: "mnemo:acceptance", adapter: "mnemo-command/v1", required: true, failClosed: true,
+        timeoutMs: 2000, command: process.execPath, args: [adapterPath], credentialEnv: [] }]
+    } });
     const entities = [
       ["person:freja", "person", "Freja Åström"],
       ["person:lucia", "person", "Lucía Ortega"],
@@ -109,6 +132,23 @@ export async function runVisibleAcceptance() {
       prompt: "Responde siempre de forma clara y breve."
     });
     requireCondition(swedish.signal?.accepted && spanish.signal?.accepted, "multilingual style signals were not accepted");
+    requireCondition(swedish.preflight?.briefing.instructions.some((item) => item.displayPath.endsWith("CLAUDE.md")
+      && item.delivery === "host-native" && item.bytes === Buffer.byteLength(sources["CLAUDE.md"]) && !("content" in item)),
+      "mandatory CLAUDE.md identity was not verified without duplicate injection");
+    requireCondition(swedish.preflight?.briefing.retrieval[0]?.items[0]?.id === "mnemo:aurora-finding",
+      "required Mnemo retrieval was not present before the turn");
+    await rm(adapterPath);
+    const blockedRecall = await runHook({
+      hook_event_name: "UserPromptSubmit", host: "claude", cwd: projectRoot,
+      entity_id: "person:freja", project_id: "project:aurora", task_id: "task:aurora",
+      session_id: "session:freja:blocked", event_id: "prompt:freja:blocked", timestamp: "2031-04-05T09:00:30.000Z",
+      prompt: "Det här svaret får inte skapas utan minne."
+    });
+    requireCondition(blockedRecall.blocked && blockedRecall.failedClosed, "missing required recall did not block the turn");
+    await writeFile(adapterPath, adapterSource, "utf8");
+    addCheck(checks, "pre-answer-recall", "Verpflichtender Pre-Answer-Recall",
+      "Vollständige CLAUDE.md und Mnemo wurden vor dem Turn geladen; fehlendes Mnemo blockierte sichtbar.",
+      [swedish.preflight.receipt.id, swedish.preflight.receipt.briefingDigest, blockedRecall.blocked]);
     addCheck(checks, "languages", "Mehrsprachige Stilkontinuität", "Schwedische und spanische Stilwünsche wurden nach Opt-in minimal und belegt angenommen.", [swedish.signal.learningId, spanish.signal.learningId]);
 
     await runHook({

package/agent-spine-plugin/src/lib/audit.js

@@ -21,6 +21,7 @@ import { gatewayHealthFindings, gatewayRuntimeFindings, inspectGatewayRuntime }
 import { fileURLToPath } from "node:url";
 import { checkHosts } from "../../scripts/check-hosts.js";
 import { resolveHostSourceCatalog } from "./source-roots.js";
+import { preflightStatus } from "./preflight.js";
 
 function gate(id, name, ok, detail, severity = "error") {
   return { id, name, ok, severity, detail };
@@ -73,6 +74,9 @@ function forbiddenEntityKeys(graph) {
 }
 
 export async function runAudit(root = process.cwd(), { host = null } = {}) {
+  let preflight = null;
+  let preflightError = null;
+  try { preflight = await preflightStatus(); } catch (error) { preflightError = error.message; }
   let sourceResolution = null;
   let sourceResolutionError = null;
   let resolvedHostSources = null;
@@ -270,7 +274,9 @@ export async function runAudit(root = process.cwd(), { host = null } = {}) {
     gate(4, "Native hierarchy", nativeMapped.every((document) => document.hosts.length > 0), `${nativeMapped.length} host-native documents mapped`),
     gate(5, "Link integrity", brokenLinks.length === 0, brokenLinks.length ? `${brokenLinks.length} broken Markdown links` : "All indexed Markdown links resolve"),
     gate(6, "Conflict visibility", Array.isArray(catalog.conflicts), `${reviewConflicts.length} precedence or classification findings exposed`, "warning"),
-    gate(7, "Authority boundary", authority.length === 0 && forbidden.length === 0 && policyIssues.length === 0 && coordinationAuthorityIssues.length === 0 && executionPolicyIssues.length === 0 && selfstarterAuthorityIssues.length === 0 && channelPolicyIssues.length === 0 && personaPolicyIssues.length === 0 && gatewayPolicyIssues.length === 0 && sharingAuthorityIssues.length === 0, `${authority.length} context authority violations; ${forbidden.length} forbidden entity records; ${policyIssues.length} delegation policy findings; ${coordinationAuthorityIssues.length} assignment findings; ${executionPolicyIssues.length} execution policy findings; ${selfstarterAuthorityIssues.length} self-starter authority findings; ${channelPolicyIssues.length} channel policy findings; ${personaPolicyIssues.length} persona policy findings; ${gatewayPolicyIssues.length} gateway policy findings; ${sharingAuthorityIssues.length} shared authority findings`),
+    gate(7, "Authority boundary", authority.length === 0 && forbidden.length === 0 && policyIssues.length === 0 && coordinationAuthorityIssues.length === 0 && executionPolicyIssues.length === 0 && selfstarterAuthorityIssues.length === 0 && channelPolicyIssues.length === 0 && personaPolicyIssues.length === 0 && gatewayPolicyIssues.length === 0 && sharingAuthorityIssues.length === 0 && !preflightError, preflightError
+      ? `preflight policy or receipt state failed closed: ${preflightError}`
+      : `${authority.length} context authority violations; ${forbidden.length} forbidden entity records; ${policyIssues.length} delegation policy findings; ${coordinationAuthorityIssues.length} assignment findings; ${executionPolicyIssues.length} execution policy findings; ${selfstarterAuthorityIssues.length} self-starter authority findings; ${channelPolicyIssues.length} channel policy findings; ${personaPolicyIssues.length} persona policy findings; ${gatewayPolicyIssues.length} gateway policy findings; ${sharingAuthorityIssues.length} shared authority findings; preflight ${preflight.status}`),
     gate(8, "Context privacy", privacyInvalid.length === 0 && attentionGroupInvalid.length === 0 && attentionConfigValid && attentionIssues.length === 0 && learningIssues.length === 0 && continuityIssues.length === 0 && coordinationContextIssues.length === 0 && selfstarterStateIssues.length === 0 && channelRuntimeIssues.length === 0 && personaStateIssues.length === 0 && gatewayStateIssues.length === 0 && sharingContextIssues.length === 0 && authenticationIssues.length === 0, `${graph.entities.length} entities, ${graph.entityEdges.length} relationships, ${attention.signals.length} attention cues, ${attention.events.length} lifecycle events, ${learning.candidates.length} learning records, ${continuity.signals.length} continuity signals, ${coordination.tasks.length} coordination items, ${selfstarter.jobs.length} self-starter jobs, ${channelRuntime.events.length} channel events, ${personaRuntime.personas.length} authenticated personas, ${gatewayRuntime.queue.length} gateway queue items, ${gatewayRuntime.outbox.length} delivery records, ${sharing.records.length} shared records, ${trust.records.length} trusted keys, ${registry.signers.length} local signers, and ${feedState.feeds.length} feed receipts checked`),
     gate(9, "Context budget", loadedBytes <= context.budget.maxBytes && briefingBudgetValid, briefingError
       ? `${loadedBytes}/${context.budget.maxBytes} source bytes; briefing failed closed: ${briefingError}`
@@ -303,6 +309,7 @@ export async function runAudit(root = process.cwd(), { host = null } = {}) {
     trustPath,
     registryPath,
     feedStatePath,
-    sourceResolution
+    sourceResolution,
+    preflight
   };
 }

package/agent-spine-plugin/src/lib/graph.js

@@ -239,11 +239,11 @@ function relationshipAudience(graph, groupId) {
   return ids;
 }
 
-export async function relationshipContext({
+async function assembleRelationshipContext({
   root = process.cwd(), entityId, includePrivate = false, groupId = null, catalog: providedCatalog = null
-}) {
+}, loadGraphImpl) {
   if (!entityId) throw new Error("entityId is required");
-  const { graph } = await loadGraph(root, providedCatalog);
+  const { graph } = await loadGraphImpl(root, providedCatalog);
   if (groupId !== null) {
     const group = graph.entities.find((item) => item.id === groupId && item.kind === "group");
     if (!group) throw new Error(`unknown group entity: ${groupId}`);
@@ -254,6 +254,7 @@ export async function relationshipContext({
   const audience = groupId === null ? null : relationshipAudience(graph, groupId);
   if (audience && !audience.has(entityId)) throw new Error(`entity is not a visible member of group: ${groupId}`);
   const visible = (item) => {
+    if (item.attributes?.identityBindingId && item.attributes.identityStatus !== "active") return false;
     if (item.privacy === "private") return includePrivate && groupId === null;
     if (item.privacy === "group" && !audience) return false;
     if (audience && item.id && !audience.has(item.id)) return false;
@@ -264,7 +265,12 @@ export async function relationshipContext({
   const visibleEdge = (edge) => visible(edge)
     && (!audience || [edge.from, edge.to].every((id) => audience.has(id)))
     && [edge.from, edge.to].every((id) => !entities.has(id) || visible(entities.get(id)));
-  const edges = graph.entityEdges.filter((edge) => (edge.from === entityId || edge.to === entityId) && visibleEdge(edge));
+  const directEdges = graph.entityEdges.filter((edge) => (edge.from === entityId || edge.to === entityId) && visibleEdge(edge));
+  const teamEdges = groupId === null ? [] : graph.entityEdges.filter((edge) => edge.relation === "member-of"
+    && (edge.from === groupId || edge.to === groupId) && visibleEdge(edge));
+  const edgeKey = (edge) => `${edge.from}\0${edge.to}\0${edge.relation}`;
+  const edges = [...new Map([...directEdges, ...teamEdges].map((edge) => [edgeKey(edge), edge])).values()]
+    .sort((left, right) => edgeKey(left).localeCompare(edgeKey(right)));
   const ids = new Set(edges.flatMap((edge) => [edge.from, edge.to]));
   ids.add(entityId);
   return {
@@ -282,3 +288,15 @@ export async function relationshipContext({
     authority: "context-only"
   };
 }
+
+export async function relationshipContext(options = {}, { loadGraphImpl = loadGraph, timeoutMs = 5000 } = {}) {
+  let timer;
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(`relationship context exceeded its ${timeoutMs} ms local read limit`)), timeoutMs);
+  });
+  try {
+    return await Promise.race([assembleRelationshipContext(options, loadGraphImpl), deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}