blun-king-cli 9.1.589 → 9.1.595

package/agent-spine-plugin/src/lib/gateway-runs.js

@@ -1,7 +1,9 @@
 import { loadChannelPolicy, loadChannelRuntime } from "./channel-runtime.js";
+import { executionBlocks, heldExecution, newExecutionHold, requireHostQuiescence,
+  settleHostExecution } from "./gateway-host-fencing.js";
 import { reviewGroupResponse } from "./gateway-group-response.js";
 import {
-  assertGatewayCompletionMode, exactGatewayLeaseGeneration, failGatewayLane,
+  AMBIGUOUS_HOST_OUTCOME, assertGatewayCompletionMode, exactGatewayLeaseGeneration, failGatewayLane,
   markHostStarted, newGatewayLease, normalizeGatewayExecutionMode,
   requireExactGatewayLease, requireExactHostLease
 } from "./gateway-host-lifecycle.js";
@@ -20,11 +22,22 @@ import { reviewExecutionResult } from "./gateway-execution.js";
 import {
   activateNextPlanStep, conflictingResources, currentPlanStep, effectiveQueuePriority,
   newGoalQueue, normalizePolicy, normalizeRuntime, pathsFor, planQueueKey,
-  planStepAgentId, readJson, withLock, writeJson
+  planStepAgentId, planStepResources, queuePlanStep, readJson, withLock, writeJson
 } from "./gateway-state.js";
 
+export function gatewayWorkMatcher({ agentId = null, projectId = null, groupId, goalOnly = false } = {}) {
+  agentId = exactId(agentId, "agentId", true);
+  projectId = exactId(projectId, "projectId", true);
+  groupId = groupId === undefined ? undefined : exactId(groupId, "groupId", true);
+  return (item) => Boolean(item && (agentId === null || item.agentId === agentId)
+    && (projectId === null || item.projectId === projectId)
+    && (groupId === undefined || item.groupId === groupId)
+    && (!goalOnly || (item.goalId && !item.channelEventId)));
+}
+
 export async function claimGatewayWork({ root = process.cwd(), workerId, leaseSeconds = 120,
-  executionMode = "host-effect", now = new Date() }) {
+  executionMode = "host-effect", agentId = null, projectId = null, groupId, goalOnly = false, now = new Date() }) {
+  const matchesWork = gatewayWorkMatcher({ agentId, projectId, groupId, goalOnly });
   const paths = await pathsFor(root);
   return withLock(paths, async () => {
     const [policy, runtime, personas] = await Promise.all([
@@ -38,6 +51,7 @@ export async function claimGatewayWork({ root = process.cwd(), workerId, leaseSe
     const seconds = Number(leaseSeconds);
     if (!Number.isInteger(seconds) || seconds < 15 || seconds > 900) throw new Error("leaseSeconds must be 15-900");
     const items = runtime.queue.filter((item) => item.status === "pending" && new Date(item.availableAt) <= new Date(current)
+      && matchesWork(item)
       && !currentLane(runtime, item.agentId));
     items.sort((a, b) => effectiveQueuePriority(policy, b) - effectiveQueuePriority(policy, a)
       || a.createdAt.localeCompare(b.createdAt) || a.queueId.localeCompare(b.queueId));
@@ -67,6 +81,8 @@ export async function claimGatewayWork({ root = process.cwd(), workerId, leaseSe
       const resourceConflict = runtime.queue.some((leased) => leased.status === "leased"
         && leased.queueId !== candidate.queueId && conflictingResources(policy, candidate, leased).length > 0);
       if (resourceConflict) continue;
+      if (runtime.queue.some((held) => executionBlocks(held, candidate,
+        planStepResources(queuePlanStep(policy, candidate))))) continue;
       item = candidate;
       break;
     }
@@ -75,6 +91,8 @@ export async function claimGatewayWork({ root = process.cwd(), workerId, leaseSe
     preserve(runtime, "queue", item, "leased", current);
     item.status = "leased"; item.attempts += 1; item.updatedAt = current;
     item.lease = newGatewayLease(workerId, current, seconds, executionMode);
+    if (executionMode === "host-effect") item.executionHold = newExecutionHold(item,
+      [...planStepResources(queuePlanStep(policy, item))]);
     runtime.lanes = runtime.lanes.filter((lane) => lane.agentId !== item.agentId || lane.status !== "leased");
     runtime.lanes.push({ agentId: item.agentId, queueId: item.queueId, workerId, status: "leased", claimedAt: current,
       expiresAt: item.lease.expiresAt, updatedAt: current, authority: "execution-state-only" });
@@ -86,7 +104,7 @@ export async function claimGatewayWork({ root = process.cwd(), workerId, leaseSe
   });
 }
 
-export async function markGatewayHostStarted({ root = process.cwd(), queueId, workerId, claimedAt, attempt,
+export async function markGatewayHostStarted({ root = process.cwd(), queueId, workerId, claimedAt, attempt, hostSessionId,
   now = new Date() }) {
   const paths = await pathsFor(root);
   return withLock(paths, async () => {
@@ -99,14 +117,17 @@ export async function markGatewayHostStarted({ root = process.cwd(), queueId, wo
     workerId = exactId(workerId, "workerId"); claimedAt = exactGatewayLeaseGeneration(claimedAt, attempt, "host start");
     const current = timestamp(now);
     const lane = requireExactHostLease(runtime, item, { workerId, claimedAt, attempt, current });
+    const sessionId = hostSessionId === undefined ? null : exactId(hostSessionId, "hostSessionId");
     const receipt = markHostStarted(runtime, item, lane, workerId, current, { preserve, appendReceipt });
+    item.executionHold.hostSessionId = sessionId;
+    item.executionHold.hostStartedAt = current;
     await writeJson(paths.gatewayRuntimePath, runtime);
     return { item: structuredClone(item), receipt };
   });
 }
 
 export async function completeGatewayRun({ root = process.cwd(), queueId, workerId, claimedAt, attempt,
-  result, now = new Date() }) {
+  result, quiescence, now = new Date() }) {
   const paths = await pathsFor(root);
   return withLock(paths, async () => {
     const [policy, runtime, channelPolicy, channelRuntime, personas] = await Promise.all([
@@ -120,11 +141,25 @@ export async function completeGatewayRun({ root = process.cwd(), queueId, worker
     workerId = exactId(workerId, "workerId");
     claimedAt = exactGatewayLeaseGeneration(claimedAt, attempt, "run completion"); const current = timestamp(now);
     const lane = requireExactGatewayLease(runtime, item,
-      { workerId, claimedAt, attempt, current, action: "run completion" });
-    const markedHostRun = assertGatewayCompletionMode(item.lease, result);
+      { workerId, claimedAt, attempt, current, action: "run completion", allowHeld: true });
+    const hold = heldExecution(item);
+    const hostProof = requireHostQuiescence(item, quiescence, result, current);
+    const markedHostRun = assertGatewayCompletionMode(item.lease ??
+      { executionMode: "host-effect", hostStartedAt: hold?.hostStartedAt }, result);
     const runIdentity = assertActivePersona(personas.policy, personas.runtime, item.agentId, item.projectId, item.groupId);
     const boundGoal = item.goalId ? policy.goals.find((entry) => entry.goalId === item.goalId) : null;
+    const previousGoal = boundGoal ? structuredClone(boundGoal) : null;
     const boundStep = item.goalStepId ? boundGoal && currentPlanStep(boundGoal) : null;
+    if (hostProof && boundGoal && policy.goals.some((goal) => goal.goalId !== boundGoal.goalId
+      && goal.agentId === boundGoal.agentId && goal.status === "active")) {
+      result = { ...result, completed: false, blocked: true, knowledgeGap: null, selfHelp: null,
+        blocker: "Checkpoint saved; another focused goal was assigned while this host was unresolved." };
+    }
+    if (hostProof && boundGoal?.status === "blocked" && boundGoal.blocker === AMBIGUOUS_HOST_OUTCOME
+      && (!boundStep || boundStep.blocker === AMBIGUOUS_HOST_OUTCOME)) {
+      boundGoal.status = "active"; boundGoal.blocker = null;
+      if (boundStep) { boundStep.status = "active"; boundStep.blocker = null; }
+    }
     if (item.goalStepId) {
       if (!boundGoal?.plan || boundGoal.status !== "active" || boundStep?.stepId !== item.goalStepId
         || boundStep.status !== "active" || item.agentId !== planStepAgentId(boundGoal, boundStep)) {
@@ -191,7 +226,7 @@ export async function completeGatewayRun({ root = process.cwd(), queueId, worker
         ? "blocked" : "completed"; item.completedAt = current;
       const goal = boundGoal;
       if (goal) {
-        policy.history.push({ kind: "goal", at: current, value: structuredClone(goal), authority: "authenticated-goal-policy" });
+        policy.history.push({ kind: "goal", at: current, value: previousGoal, authority: "authenticated-goal-policy" });
         const checkpoint = resultCheckpoint;
         goal.checkpoint = checkpoint; goal.heartbeatAt = current;
         goal.blocker = result?.blocked ? safeText(result.blocker || "Run blocked.", "blocker", 500)
@@ -275,12 +310,13 @@ export async function completeGatewayRun({ root = process.cwd(), queueId, worker
       }
     }
     item.lease = null; item.updatedAt = current; lane.status = "completed"; lane.updatedAt = current;
+    const hostSettlement = settleHostExecution(runtime, item, hostProof, current, appendReceipt);
     if (markedHostRun) runtime.health.host = "healthy";
     runtime.health.worker = "healthy"; runtime.health.lastTickAt = current;
     appendReceipt(runtime, "run-terminal", item.queueId, current, { status: item.status, goalStepId: item.goalStepId || null }); runtime.revision += 1;
     await writeGatewayStatePair(policy, runtime);
     return { item, outbox: runtime.outbox.find((entry) => entry.queueId === item.queueId) || null,
-      clarification, exploration, selfHelp, selfHelpRequired, executionReview, premortemReview, communication };
+      clarification, exploration, selfHelp, selfHelpRequired, executionReview, premortemReview, communication, hostSettlement };
   });
 }
 
@@ -296,7 +332,7 @@ export async function failGatewayRun({ root = process.cwd(), queueId, workerId,
     workerId = exactId(workerId, "workerId"); claimedAt = exactGatewayLeaseGeneration(claimedAt, attempt, "run failure");
     const current = timestamp(now);
     const lane = requireExactGatewayLease(runtime, item,
-      { workerId, claimedAt, attempt, current, action: "run failure" });
+      { workerId, claimedAt, attempt, current, action: "run failure", allowHeld: true });
     const message = safeText(String(error || "host runtime unavailable"), "runError", 500);
     const delay = Number(retryAfterMs);
     if (!Number.isFinite(delay) || delay < 250 || delay > 300000) throw new Error("retryAfterMs must be 250-300000");

package/agent-spine-plugin/src/lib/gateway-runtime.js

@@ -6,7 +6,7 @@ export {
 export { executionAttemptForStep } from "./gateway-execution.js";
 export {
   assignGoal, enqueueGatewayWake, reconcileGateway, resolveGoalKnowledgeGap,
-  setGatewayControl
+  reviewLegacyGatewayHold, setGatewayControl
 } from "./gateway-control.js";
 export {
   claimGatewayWork, completeGatewayRun, failGatewayRun, markGatewayHostStarted

package/agent-spine-plugin/src/lib/gateway-state.js

@@ -1,4 +1,5 @@
 import { join } from "node:path";
+import { retainLegacyExecutionHolds, validExecutionHold } from "./gateway-host-fencing.js";
 import { buildCatalog } from "./catalog.js";
 import { matchesGatewayLaneLease, validGatewayLeaseExecution } from "./gateway-host-lifecycle.js";
 import * as goalPremortem from "./gateway-premortem.js";
@@ -181,6 +182,7 @@ export function validQueue(item) {
     && Number.isFinite(new Date(item.availableAt).getTime()) && Number.isFinite(new Date(item.updatedAt).getTime())
     && (item.completedAt === null || Number.isFinite(new Date(item.completedAt).getTime()))
     && (item.lastError === null || (typeof item.lastError === "string" && item.lastError.length <= 500 && !SECRET_RE.test(item.lastError)))
+    && validExecutionHold(item)
     && (item.lease === null || (item.status === "leased" && ID_RE.test(item.lease.workerId || "")
       && Number.isFinite(new Date(item.lease.claimedAt).getTime())
       && Number.isFinite(new Date(item.lease.expiresAt).getTime())
@@ -269,6 +271,7 @@ export function normalizeRuntime(value, root) {
   if (receiptIndex >= 0) invalid.push("receipts:" + receiptIndex);
   if (historyIndex >= 0) invalid.push("history:" + historyIndex);
   if (invalid.length) throw new Error("gateway runtime is invalid (" + invalid.join(",") + "); worker is disabled");
+  retainLegacyExecutionHolds(value);
   return value;
 }
 
@@ -339,4 +342,3 @@ export function gatewayRuntimeFindings(policy, runtime) {
   if (!validHealth(runtime.health)) findings.push("invalid-gateway-health");
   return findings;
 }
-

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

@@ -7,6 +7,7 @@ import { resolveSessionJob, startOrResumeJob } from "./selfstarter.js";
 
 const STANDARD_HOST_CONTEXT_BYTES = 9500;
 const MAX_CLAUDE_OVERFLOW_CONTEXT_BYTES = 32 * 1024;
+const CODEX_CONTEXT_ENVELOPE_BYTES = 32 * 1024;
 const ID_RE = /^[A-Za-z0-9][A-Za-z0-9:_.@/-]{0,127}$/;
 export const ATTENTION_WRITE_EVENTS = new Set(["UserPromptSubmit", "PostToolUse", "Stop", "SubagentStop"]);
 const SELFSTART_EVENTS = new Set(["SessionStart", "PostCompact"]);
@@ -43,9 +44,13 @@ export function promptFromInput(input) {
 }
 
 export function hostContextLimit(preflight) {
-  return preflight?.receipt?.instructionBudget?.mode === "claude-required-overflow"
-    ? MAX_CLAUDE_OVERFLOW_CONTEXT_BYTES
-    : STANDARD_HOST_CONTEXT_BYTES;
+  // Source budgets bound the content; JSON escaping must not create another gate.
+  if (preflight?.receipt?.instructionHost === "codex") {
+    return CODEX_CONTEXT_ENVELOPE_BYTES + Buffer.byteLength(JSON.stringify(preflight.briefing || {}));
+  }
+  const mode = preflight?.receipt?.instructionBudget?.mode;
+  if (mode === "claude-required-overflow") return MAX_CLAUDE_OVERFLOW_CONTEXT_BYTES;
+  return STANDARD_HOST_CONTEXT_BYTES;
 }
 
 export function hostFromInput(input) {

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

@@ -208,7 +208,7 @@ export function blunRuntimeMessage(context) {
 
 export function hookOutput(event, context, env = process.env) {
   if (env.BLUN_PLUGIN_ROOT) {
-    return { hookSpecificOutput: { hookEventName: event, message: blunRuntimeMessage(context) } };
+    return { hookSpecificOutput: { hookEventName: event, additionalContext: blunRuntimeMessage(context) } };
   }
   return { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
 }
@@ -259,6 +259,5 @@ export function lifecycleOutput(event, artifactGuard, premortem, deliveryVerific
     }));
   }
   if (!messages.length) return {};
-  const field = env.BLUN_PLUGIN_ROOT ? "message" : "additionalContext";
-  return { hookSpecificOutput: { hookEventName: event, [field]: messages.join("\n") } };
+  return { hookSpecificOutput: { hookEventName: event, additionalContext: messages.join("\n") } };
 }

package/agent-spine-plugin/src/lib/hook-process-advisory.js

@@ -29,9 +29,8 @@ export async function processAdvisory(input, payload, root, scope, details) {
     diagnostic: fresh ? diagnostic : null
   };
   if (payload) return result;
-  const field = process.env.BLUN_PLUGIN_ROOT ? "message" : "additionalContext";
   const output = fresh ? { hookSpecificOutput: {
-    hookEventName: event, [field]: JSON.stringify(diagnostic)
+    hookEventName: event, additionalContext: JSON.stringify(diagnostic)
   } } : {};
   process.stdout.write(`${JSON.stringify(output)}\n`);
 }

package/agent-spine-plugin/src/lib/host-instruction-budget.js

@@ -0,0 +1,17 @@
+const STANDARD_BYTES = 8 * 1024;
+export const KING_SOURCE_MAX_BYTES = 4 * 1024 * 1024;
+export const KING_TOTAL_MAX_BYTES = 8 * 1024 * 1024;
+
+export function isKingHost(env = process.env) {
+  return Boolean(env.BLUN_PLUGIN_ROOT && env.BLUN_HOME);
+}
+
+export function instructionBudget(host, usedBytes = 0, env = process.env) {
+  const hardLimitBytes = host === "codex" && isKingHost(env) ? KING_TOTAL_MAX_BYTES
+    : host === "claude" ? 16 * 1024 : host === "codex" ? 32 * 1024 : STANDARD_BYTES;
+  const overflowBytes = Math.max(0, usedBytes - STANDARD_BYTES);
+  return {
+    mode: overflowBytes ? `${host}-required-overflow` : "standard",
+    standardBytes: STANDARD_BYTES, hardLimitBytes, usedBytes, overflowBytes
+  };
+}

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

@@ -7,6 +7,7 @@ import { isFileLockContention, replaceFileWithRetry } from "./filesystem-retry.j
 import { ancestorsBetween, isInside, stateRoot } from "./paths.js";
 import { preflightDeliveryId } from "./preflight-delivery-id.js";
 import { resolveHostSourceCatalog } from "./source-roots.js";
+import { instructionBudget } from "./host-instruction-budget.js";
 
 export const PREFLIGHT_SCHEMA = "agentspine.preflight/v2";
 export const PREFLIGHT_POLICY_SCHEMA = "agentspine.preflight-policy/v1";
@@ -22,8 +23,6 @@ const ENV_RE = /^[A-Z_][A-Z0-9_]{0,127}$/;
 const MAX_POLICY_BYTES = 1024 * 1024;
 const MAX_STATE_BYTES = 8 * 1024 * 1024;
 const MAX_PROVIDER_BYTES = 1024 * 1024;
-const STANDARD_REQUIRED_INSTRUCTIONS_BYTES = 8 * 1024;
-const MAX_CLAUDE_REQUIRED_INSTRUCTIONS_BYTES = 16 * 1024;
 const MAX_REQUIRED_MEMORY_BYTES = 6 * 1024;
 const RECEIPT_TTL_MS = 60_000;
 const FORBIDDEN_MEMORY = /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk|gh[opusu])_[A-Za-z0-9_-]{20,}\b|\b(?:password|passwort|secret|token|api[-_ ]?key|credential|permission|rights?|roles?|delegat|authoriz|berechtig|freigabe|approval|tool access|file access|network|production|payment|zahlung|policy)\b/i;
@@ -378,19 +377,6 @@ function instructionDocuments(catalog, host) {
   return catalog.documents.filter((item) => item.layer === "constitution" && pattern.test(item.relativePath))
     .sort((left, right) => left.precedence - right.precedence || left.relativePath.localeCompare(right.relativePath));
 }
-function instructionBudget(host, usedBytes = 0) {
-  const hardLimitBytes = host === "claude"
-    ? MAX_CLAUDE_REQUIRED_INSTRUCTIONS_BYTES
-    : STANDARD_REQUIRED_INSTRUCTIONS_BYTES;
-  const overflowBytes = Math.max(0, usedBytes - STANDARD_REQUIRED_INSTRUCTIONS_BYTES);
-  return {
-    mode: overflowBytes ? "claude-required-overflow" : "standard",
-    standardBytes: STANDARD_REQUIRED_INSTRUCTIONS_BYTES,
-    hardLimitBytes,
-    usedBytes,
-    overflowBytes
-  };
-}
 async function rejectKnownInstructionSymlinks(resolvedSources, host) {
   const candidates = host === "claude"
     ? [join(resolvedSources.hostHome, "CLAUDE.md"), ...ancestorsBetween(resolvedSources.projectRoot, resolvedSources.cwd)
@@ -505,7 +491,7 @@ export async function runPreflight({ input, scope, resolvedSources, prompt, now
   const documents = instructionDocuments(resolvedSources.catalog, instructionHost);
   const requiredInstructions = [];
   let instructionBytes = 0;
-  const maximumInstructionBytes = instructionBudget(instructionHost).hardLimitBytes;
+  const maximumInstructionBytes = instructionBudget(instructionHost, 0, env).hardLimitBytes;
   for (const document of documents) {
     const allowedRoot = document.sourceScope === "user" ? resolvedSources.hostHome : resolvedSources.projectRoot;
     const snapshot = await safeReadRequired(document.path, allowedRoot, maximumInstructionBytes, fileHooks);
@@ -517,7 +503,7 @@ export async function runPreflight({ input, scope, resolvedSources, prompt, now
     requiredInstructions.push({ path: document.path, displayPath: document.relativePath, scope: document.sourceScope,
       bytes: snapshot.bytes, sha256: snapshot.sha256, identity: snapshot.identity, content: snapshot.content });
   }
-  const appliedInstructionBudget = instructionBudget(instructionHost, instructionBytes);
+  const appliedInstructionBudget = instructionBudget(instructionHost, instructionBytes, env);
   const memoryState = validateMemories(await readJson(paths.memories, MAX_STATE_BYTES, emptyMemories));
   const mustRemember = memoryState.entries.filter((item) => memoryMatches(item, exactScope));
   if (Buffer.byteLength(JSON.stringify(mustRemember.map((item) => item.claim))) > MAX_REQUIRED_MEMORY_BYTES) {
@@ -620,7 +606,7 @@ export async function verifyPreflightReceipt({ receipt, input, scope, resolvedSo
     if (currentDocuments.length !== receipt.instructionFiles.length
       || currentDocuments.some((document, index) => document.path !== receipt.instructionFiles[index]?.path)) return false;
     let instructionBytes = 0;
-    const maximumInstructionBytes = instructionBudget(receipt.instructionHost).hardLimitBytes;
+    const maximumInstructionBytes = instructionBudget(receipt.instructionHost, 0, env).hardLimitBytes;
     for (const instruction of receipt.instructionFiles) {
       const allowedRoot = instruction.scope === "user" ? freshSources.hostHome : freshSources.projectRoot;
       const currentSnapshot = await safeReadRequired(instruction.path, allowedRoot, maximumInstructionBytes);
@@ -629,7 +615,7 @@ export async function verifyPreflightReceipt({ receipt, input, scope, resolvedSo
       instructionBytes += currentSnapshot.bytes;
     }
     if (instructionBytes > maximumInstructionBytes
-      || canonical(receipt.instructionBudget) !== canonical(instructionBudget(receipt.instructionHost, instructionBytes))) return false;
+      || canonical(receipt.instructionBudget) !== canonical(instructionBudget(receipt.instructionHost, instructionBytes, env))) return false;
   } catch { return false; }
   if (consume) {
     const paths = storagePaths(env);

package/agent-spine-plugin/src/lib/source-roots.js

@@ -8,6 +8,7 @@ import { isFileLockContention, replaceFileWithRetry } from "./filesystem-retry.j
 import { purgeIndexedMemoryCache, resolveIndexedMemory } from "./indexed-memory.js";
 import { hookMemoryQuery, loadLessonRecallSelection, rememberLessonRecallSelection } from "./lesson-recall-session.js";
 import { catalogScanPolicy } from "./catalog.js";
+import { isKingHost, KING_SOURCE_MAX_BYTES } from "./host-instruction-budget.js";
 import {
   SOURCE_SCAN_INCOMPLETE, boundedMarkdownTree, existingDirectory, existingRegular, sourceScanError
 } from "./source-tree-scan.js";
@@ -358,10 +359,10 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
   let hostDetails = {};
   let rootResolution = "explicit-root";
   if (host === "codex") {
-    const codexHome = env.BLUN_PLUGIN_ROOT && env.BLUN_HOME
-      ? env.BLUN_HOME : env.CODEX_HOME || env.BLUN_HOME || join(homedir(), ".codex");
+    const codexHome = isKingHost(env) ? env.BLUN_HOME : env.CODEX_HOME || env.BLUN_HOME || join(homedir(), ".codex");
     hostHome = await existingDirectory(resolve(codexHome)) || resolve(codexHome);
     const config = await codexConfig(hostHome);
+    if (isKingHost(env)) config.maxBytes = KING_SOURCE_MAX_BYTES;
     if (env.AGENTSPINE_ROOT) projectRoot = await canonicalPath(env.AGENTSPINE_ROOT);
     else ({ root: projectRoot, resolution: rootResolution } = await findRoot(canonicalCwd, config.rootMarkers));
     sources = await codexSources({ cwd: canonicalCwd, projectRoot, codexHome: hostHome, config });

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

@@ -14,6 +14,8 @@ import { groupResponseContract, settleSuppressedGroupEvents } from "./lib/gatewa
 import { loadPersonaRuntime, syncPersonaRosterFromEnvironment } from "./lib/persona-runtime.js";
 import { selfHelpPolicyForWorkItem } from "./lib/knowledge-evidence.js";
 import { isMainModule } from "./lib/runtime.js";
+import { executePreparedHost } from "./lib/gateway-prepared-host.js";
+import { gatewayWorkMatcher } from "./lib/gateway-runs.js";
 
 const MAX_FRAME = 64 * 1024;
 const WAKE_FILES = new Set(["attention.json", "channel-runtime.json", "gateway-policy.json", "persona-policy.json", "persona-runtime.json"]);
@@ -140,8 +142,14 @@ async function hostWorkItem(root, item) {
   };
 }
 
-export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-worker:local", now = new Date(),
-  hostRunner = invokeHostRunner, adapter = null, env = process.env } = {}) {
+export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-worker:local", now = null,
+  hostRunner = invokeHostRunner, hostFactory = null, agentId = null, projectId = null, groupId, goalOnly = false,
+  clock = null, adapter = null, env = process.env } = {}) {
+  // Explicit `now` remains a deterministic test clock; production reads the clock at each boundary.
+  const fixedTime = now;
+  const currentTime = clock ?? (fixedTime === null ? () => new Date() : () => fixedTime);
+  const matchesWork = gatewayWorkMatcher({ agentId, projectId, groupId, goalOnly });
+  now = currentTime();
   const deliveryAdapter = adapter || createTelegramAdapter({ root, env });
   await syncPersonaRosterFromEnvironment({ root, env, now });
   const initial = await loadGatewayRuntime(root);
@@ -157,7 +165,9 @@ export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-
   await reconcileGateway({ root, now });
   await updateGatewayHealth({ root, worker: "healthy", adapter: "healthy", now });
   const afterReconcile = await loadGatewayRuntime(root);
+  const queueById = new Map(afterReconcile.runtime.queue.map((item) => [item.queueId, item]));
   const dueOutbox = afterReconcile.runtime.outbox.filter((item) => ["prepared", "failed"].includes(item.status)
+    && matchesWork(queueById.get(item.queueId))
     && new Date(item.nextAttemptAt) <= new Date(now)).sort((a, b) => a.nextAttemptAt.localeCompare(b.nextAttemptAt)
       || a.createdAt.localeCompare(b.createdAt) || a.outboxId.localeCompare(b.outboxId))[0] || null;
   if (dueOutbox) {
@@ -168,20 +178,28 @@ export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-
     return { status: delivery.outbox.status, processed: true, outboxId: delivery.outbox.outboxId,
       recoveredDelivery: true };
   }
-  const claim = await claimGatewayWork({ root, workerId, executionMode: "host-effect", now });
+  const claim = await claimGatewayWork({ root, workerId, agentId, projectId, groupId, goalOnly, executionMode: "host-effect", now });
   if (!claim.item) return { status: claim.reason, processed: false };
-  await markGatewayHostStarted({ root, queueId: claim.item.queueId, workerId,
-    claimedAt: claim.item.lease.claimedAt, attempt: claim.item.attempts, now });
-  let result;
-  try { result = await hostRunner(await hostWorkItem(root, claim.item), { env }); }
+  let result; let quiescence;
+  try {
+    const item = await hostWorkItem(root, claim.item);
+    if (hostFactory) ({ result, quiescence } = await executePreparedHost({
+      root, item, hostFactory, env, clock: currentTime
+    }));
+    else {
+      await markGatewayHostStarted({ root, queueId: item.queueId, workerId,
+        claimedAt: item.lease.claimedAt, attempt: item.attempts, now });
+      result = await hostRunner(item, { env });
+    }
+  }
   catch (error) {
     const failed = await failGatewayRun({ root, queueId: claim.item.queueId, workerId,
       claimedAt: claim.item.lease.claimedAt, attempt: claim.item.attempts,
-      error: "Host runtime unavailable: " + String(error.message).slice(0, 400), now });
+      error: "Host runtime unavailable: " + String(error.message).slice(0, 400), now: currentTime() });
     return { status: failed.item.status, processed: true, queueId: failed.item.queueId, retryAt: failed.item.availableAt };
   }
   const completed = await completeGatewayRun({ root, queueId: claim.item.queueId, workerId,
-    claimedAt: claim.item.lease.claimedAt, attempt: claim.item.attempts, result, now });
+    claimedAt: claim.item.lease.claimedAt, attempt: claim.item.attempts, result, quiescence, now: currentTime() });
   if (completed.communication?.suppressed) {
     await settleSuppressedGroupEvents({ root, now });
     return { status: "silent", processed: true, queueId: completed.item.queueId,
@@ -191,17 +209,17 @@ export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-
     status: completed.clarification ? "needs-clarification"
       : completed.exploration ? "exploring" : completed.selfHelp ? "self-help-resolved"
         : completed.selfHelpRequired ? "self-help-required" : completed.item.status,
-    processed: true, queueId: completed.item.queueId,
+    processed: true, queueId: completed.item.queueId, hostSettlement: completed.hostSettlement,
     ...(completed.clarification ? { clarification: completed.clarification } : {}),
     ...(completed.exploration ? { exploration: completed.exploration } : {}),
     ...(completed.selfHelp ? { selfHelp: completed.selfHelp } : {}),
     ...(completed.selfHelpRequired ? { selfHelpRequired: completed.selfHelpRequired } : {})
   };
   const delivery = await deliverPrepared({ root, outboxId: completed.outbox.outboxId,
-    adapter: deliveryAdapter, now });
+    adapter: deliveryAdapter, now: currentTime() });
   if (delivery.outbox.status === "delivered") await acknowledgeChannelDelivery({ root,
     eventId: delivery.outbox.eventId, bindingId: delivery.outbox.bindingId,
-    deliveryReceiptId: delivery.receipt.id, now });
+    deliveryReceiptId: delivery.receipt.id, now: currentTime() });
   return { status: delivery.outbox.status, processed: true, queueId: completed.item.queueId, outboxId: delivery.outbox.outboxId };
 }
 

package/bin/agentspine-king-goal-inbox.mjs

@@ -0,0 +1,127 @@
+import { open, lstat, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+import { ingestGoalInstruction, parseGoalInstruction } from './agentspine-king-goal-intake.mjs';
+
+const CHECKPOINT_SCHEMA = 'blun.king-goal-queue-checkpoint/v1';
+const MAX_READ_BYTES = 4 * 1024 * 1024;
+
+function queueIdentity(metadata) {
+  return `${metadata.dev}:${metadata.ino}:${metadata.birthtimeMs}`;
+}
+
+async function readCheckpoint(filePath) {
+  try {
+    const value = JSON.parse(await readFile(filePath, 'utf8'));
+    if (value?.schema === CHECKPOINT_SCHEMA && typeof value.fileId === 'string'
+      && Number.isSafeInteger(value.offset) && value.offset >= 0 && Array.isArray(value.accepted)
+      && value.accepted.length <= 512 && value.accepted.every(item => item && /^[a-f0-9]{64}$/.test(item.sha256)
+        && typeof item.goalId === 'string' && item.goalId.length > 0)) return value;
+    throw new Error('GOAL_QUEUE_CHECKPOINT_INVALID');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+  return { schema: CHECKPOINT_SCHEMA, fileId: '', offset: 0, lastMessageId: null, accepted: [] };
+}
+
+async function writeCheckpoint(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, {
+    encoding: 'utf8', flag: 'wx', mode: 0o600,
+  });
+  await rename(temporary, filePath);
+}
+
+function parseQueueLine(line) {
+  let envelope;
+  try { envelope = JSON.parse(line); } catch { return null; }
+  if (!envelope || typeof envelope.text !== 'string' || !envelope.meta || Array.isArray(envelope.meta)
+    || typeof envelope.meta !== 'object') return null;
+  return envelope;
+}
+
+function isAuthorizedInstruction(envelope, input) {
+  const addressed = envelope.meta.addressed === true || envelope.meta.addressed === 'true';
+  const threads = ['thread_id', 'telegram_thread_id', 'message_thread_id']
+    .map(key => envelope.meta[key]).filter(value => value !== null && value !== undefined && value !== '').map(String);
+  const thread = input.instructionThreadId === null || input.instructionThreadId === undefined ? null : String(input.instructionThreadId);
+  return addressed && String(envelope.meta.user_id) === String(input.instructionSenderId)
+    && String(envelope.meta.chat_id) === String(input.instructionChatId)
+    && (threads.length > 0 ? threads.every(value => value === thread) : thread === null);
+}
+
+async function queueChunk(filePath, checkpoint) {
+  const metadata = await lstat(filePath);
+  if (!metadata.isFile() || metadata.isSymbolicLink()) throw new Error('GOAL_QUEUE_NOT_REGULAR');
+  const fileId = queueIdentity(metadata);
+  const offset = checkpoint.fileId === fileId && metadata.size >= checkpoint.offset ? checkpoint.offset : 0;
+  const bytes = Math.min(MAX_READ_BYTES, metadata.size - offset);
+  if (bytes <= 0) return { fileId, offset, lines: [] };
+  const handle = await open(filePath, 'r');
+  try {
+    const buffer = Buffer.alloc(bytes);
+    const { bytesRead } = await handle.read(buffer, 0, bytes, offset);
+    const content = buffer.subarray(0, bytesRead);
+    const lastNewline = content.lastIndexOf(10);
+    if (lastNewline < 0) {
+      if (bytesRead >= MAX_READ_BYTES) throw new Error('GOAL_QUEUE_LINE_TOO_LARGE');
+      return { fileId, offset, lines: [] };
+    }
+    const complete = content.subarray(0, lastNewline + 1);
+    return { fileId, offset, lines: complete.toString('utf8').split('\n').slice(0, -1) };
+  } finally { await handle.close(); }
+}
+
+async function ingestGoalInbox(input) {
+  const checkpoint = await readCheckpoint(input.checkpointFile);
+  let cursor = checkpoint.offset;
+  const results = [];
+  const chunk = await queueChunk(input.queueFile, checkpoint);
+  if (chunk.offset !== checkpoint.offset || chunk.fileId !== checkpoint.fileId) cursor = chunk.offset;
+  for (const line of chunk.lines) {
+    cursor += Buffer.byteLength(line, 'utf8') + 1;
+    const envelope = parseQueueLine(line);
+    if (!envelope || !isAuthorizedInstruction(envelope, input)
+      || !/\bZIEL-[A-Za-z0-9._-]+\.json\b/u.test(envelope.text)) continue;
+    try {
+      const instruction = parseGoalInstruction(envelope.text);
+      const accepted = checkpoint.accepted.find((item) => item.sha256 === instruction.sha256);
+      if (accepted) {
+        results.push({ status: 'duplicate', messageId: String(envelope.meta.message_id),
+          sha256: instruction.sha256, goal: { goalId: accepted.goalId } });
+        continue;
+      }
+      const ingested = await ingestGoalInstruction({ ...input, instructionText: envelope.text });
+      results.push({ status: ingested.duplicate ? 'duplicate' : 'ingested',
+        messageId: String(envelope.meta.message_id), ...ingested });
+      checkpoint.accepted.push({ sha256: ingested.sha256, goalId: ingested.goal.goalId });
+      checkpoint.accepted = checkpoint.accepted.slice(-512);
+    } catch (error) {
+      results.push({ status: 'rejected', messageId: String(envelope.meta.message_id),
+        error: String(error?.message || error).slice(0, 200) });
+    }
+    const result = results.at(-1);
+    result.eventId = createHash('sha256').update(line).digest('hex');
+    // Keep status persistence outside the ingestion catch and before advancing the durable cursor.
+    await input.recordResult?.(result);
+  }
+  await writeCheckpoint(input.checkpointFile, {
+    schema: CHECKPOINT_SCHEMA,
+    fileId: chunk.fileId,
+    offset: cursor,
+    lastMessageId: results.at(-1)?.messageId || checkpoint.lastMessageId || null,
+    accepted: checkpoint.accepted,
+    updatedAt: new Date().toISOString(),
+  });
+  return results;
+}
+
+export {
+  CHECKPOINT_SCHEMA,
+  ingestGoalInbox,
+  isAuthorizedInstruction,
+  parseQueueLine,
+  queueIdentity,
+};