blun-king-cli 9.1.587 → 9.1.588

package/agent-spine-plugin/src/lib/world-model.js

@@ -10,12 +10,14 @@ const ASSERTION_SCHEMA = "agentspine.world-assertion/v1";
 const MAX_STATE_BYTES = 5 * 1024 * 1024;
 const MAX_VALUE_BYTES = 8192;
 const EVIDENCE_KINDS = new Set([
-  "objective-measurement", "explicit-user-feedback", "model-suggestion"
+  "objective-measurement", "explicit-user-feedback", "model-suggestion", "uninterpreted-user-message"
 ]);
 const PRIVACY = new Set(["private", "shared", "group"]);
 const STABLE_ID = /^[a-z][a-z0-9-]{0,31}:[A-Za-z0-9][A-Za-z0-9._/-]{0,190}$/;
 const PREDICATE = /^[a-z][a-z0-9.-]{0,127}$/;
 const DIGEST = /^[a-f0-9]{64}$/;
+const PORTAL_REF = /^portal-ref:[a-f0-9]{32}$/;
+const THREAD_REF = /^thread-ref:[a-f0-9]{32}$/;
 const FORBIDDEN = /(^|[-_.])(permissions?|rights?|authori[sz]ation|credentials?|secrets?|tokens?|api[-_]?keys?|delegation|tool[-_]?access|production[-_]?access|payments?|spending)([-_.]|$)/i;
 
 function sha256(value) {
@@ -59,6 +61,23 @@ function optionalStableId(value, field) {
   return value === null || value === undefined ? null : stableId(value, field);
 }
 
+function routeBinding(input) {
+  const portalRef = input.portalRef ?? null;
+  const threadRef = input.threadRef ?? null;
+  if (Boolean(portalRef) !== Boolean(threadRef)) {
+    throw new Error("portalRef and threadRef must be provided together");
+  }
+  if (portalRef !== null && (!PORTAL_REF.test(portalRef) || !THREAD_REF.test(threadRef))) {
+    throw new Error("portalRef and threadRef must be opaque gateway references");
+  }
+  return portalRef ? { portalRef, threadRef } : {};
+}
+
+function sameRoute(left, right) {
+  return (left.portalRef ?? null) === (right.portalRef ?? null)
+    && (left.threadRef ?? null) === (right.threadRef ?? null);
+}
+
 function emptyModel(root) {
   return { schema: SCHEMA, root, revision: 0, assertions: [], events: [], authority: "context-only" };
 }
@@ -72,6 +91,8 @@ function validateStoredAssertion(assertion, validKnowledgeFields) {
   if ((assertion.privacy === "group") !== Boolean(assertion.groupId)
     || (assertion.groupId && !STABLE_ID.test(assertion.groupId))
     || (assertion.projectId && !STABLE_ID.test(assertion.projectId))
+    || Boolean(assertion.portalRef) !== Boolean(assertion.threadRef)
+    || (assertion.portalRef && (!PORTAL_REF.test(assertion.portalRef) || !THREAD_REF.test(assertion.threadRef)))
     || !STABLE_ID.test(assertion.evidenceId || "") || !Array.isArray(assertion.supersedes)
     || assertion.supersedes.some((item) => !STABLE_ID.test(item))) return false;
   if (!validKnowledgeFields(assertion)) return false;
@@ -83,7 +104,8 @@ function validateStoredAssertion(assertion, validKnowledgeFields) {
   } catch {
     return false;
   }
-  return assertion.status === (assertion.evidenceKind === "model-suggestion" ? "proposed" : "established");
+  return assertion.status === (["model-suggestion", "uninterpreted-user-message"].includes(assertion.evidenceKind)
+    ? "proposed" : "established");
 }
 
 function normalizeModel(value, root, validKnowledgeFields) {
@@ -156,8 +178,9 @@ function assertionInput(input, now, normalizeKnowledgeFields) {
     evidenceId, evidenceDigest: input.evidenceDigest, observedAt, expiresAt,
     projectId: optionalStableId(input.projectId, "projectId"), groupId, privacy,
     supersedes, reason: typeof input.reason === "string" ? input.reason.trim().slice(0, 500) : "",
-    status: input.evidenceKind === "model-suggestion" ? "proposed" : "established",
+    status: ["model-suggestion", "uninterpreted-user-message"].includes(input.evidenceKind) ? "proposed" : "established",
     recordedAt: new Date(now).toISOString(), authority: "context-only",
+    ...routeBinding(input),
     ...(knowledge.knowledgeKind ? knowledge : {})
   };
 }
@@ -179,12 +202,29 @@ export async function recordWorldAssertion(input = {}) {
       if (assertionDigest(existing) !== assertionDigest(candidate)) throw new Error(`world assertion id is already used: ${candidate.id}`);
       return { status: "duplicate", assertion: structuredClone(existing), revision: model.revision, authority: "context-only" };
     }
+    if (input.requireActiveSupersedes === true) {
+      if (!candidate.supersedes.length) throw new Error("active supersession requires at least one assertion");
+      const cutoff = new Date(now).getTime();
+      const live = model.assertions.filter((item) => item.status === "established"
+        && item.subjectId === candidate.subjectId && item.predicate === candidate.predicate
+        && item.projectId === candidate.projectId && item.groupId === candidate.groupId
+        && item.privacy === candidate.privacy && sameRoute(item, candidate)
+        && (!item.expiresAt || new Date(item.expiresAt).getTime() > cutoff));
+      const replaced = new Set(live.flatMap((item) => item.supersedes));
+      const activeIds = live.filter((item) => !replaced.has(item.id)).map((item) => item.id).sort();
+      if (activeIds.join("\0") !== candidate.supersedes.join("\0")) {
+        throw new Error("active supersession compare-and-swap failed");
+      }
+    }
     for (const id of candidate.supersedes) {
       const previous = model.assertions.find((item) => item.id === id);
       if (!previous) throw new Error(`superseded assertion does not exist: ${id}`);
       if (previous.subjectId !== candidate.subjectId || previous.predicate !== candidate.predicate) {
         throw new Error("supersession must keep the same subject and predicate");
       }
+      if (!sameRoute(previous, candidate)) {
+        throw new Error("supersession must keep the same portal and thread scope");
+      }
       if (candidate.status !== "established") throw new Error("model suggestions cannot supersede established context");
     }
     model.revision += 1;
@@ -196,10 +236,18 @@ export async function recordWorldAssertion(input = {}) {
   });
 }
 
-function visible(assertion, { includePrivate, groupId, projectId }) {
+function visible(assertion, { includePrivate, groupId, projectId, portalRef, threadRef, continuationTaskId }) {
   if (assertion.privacy === "private" && (!includePrivate || groupId)) return false;
   if (assertion.privacy === "group" && assertion.groupId !== groupId) return false;
-  return assertion.projectId === null || assertion.projectId === projectId;
+  if (assertion.projectId !== null && assertion.projectId !== projectId) return false;
+  const currentRoute = Boolean(portalRef && threadRef);
+  const assertionRoute = Boolean(assertion.portalRef && assertion.threadRef);
+  if (assertionRoute) return currentRoute && sameRoute(assertion, { portalRef, threadRef });
+  // A portal-bound task must not silently inherit an older unbound checkpoint
+  // or task-local correction. General user/project knowledge remains portable.
+  if (currentRoute && continuationTaskId && assertion.knowledgeKind
+    && assertion.subjectId === continuationTaskId) return false;
+  return true;
 }
 
 function publicAssertion(assertion) {
@@ -209,7 +257,7 @@ function publicAssertion(assertion) {
 export async function worldContext({
   root = process.cwd(), subjectId = null, projectId = null, groupId = null,
   includePrivate = false, includeKnowledgeHistory = false, continuationTaskId = null,
-  maxItems = 100, now = new Date()
+  portalRef = null, threadRef = null, maxItems = 100, now = new Date()
 } = {}) {
   if (groupId !== null && includePrivate) throw new Error("private world context cannot be assembled for a group audience");
   if (!Number.isInteger(maxItems) || maxItems < 1 || maxItems > 500) throw new Error("maxItems must be between 1 and 500");
@@ -217,12 +265,15 @@ export async function worldContext({
   projectId = optionalStableId(projectId, "projectId");
   groupId = optionalStableId(groupId, "groupId");
   continuationTaskId = optionalStableId(continuationTaskId, "continuationTaskId");
+  ({ portalRef = null, threadRef = null } = routeBinding({ portalRef, threadRef }));
   const names = await stateNames(root);
   const model = await readModel(names);
   const { structuredKnowledgeView } = await import("./world-knowledge.js");
   const cutoff = new Date(now).getTime();
   if (!Number.isFinite(cutoff)) throw new Error("now is invalid");
-  const candidates = model.assertions.filter((item) => visible(item, { includePrivate, groupId, projectId })
+  const candidates = model.assertions.filter((item) => visible(item, {
+    includePrivate, groupId, projectId, portalRef, threadRef, continuationTaskId
+  })
     && (!subjectId || item.subjectId === subjectId));
   const stale = candidates.filter((item) => item.expiresAt && new Date(item.expiresAt).getTime() <= cutoff);
   const current = candidates.filter((item) => !item.expiresAt || new Date(item.expiresAt).getTime() > cutoff);
@@ -251,7 +302,9 @@ export async function worldContext({
     facts.push({ subjectId: newest.subjectId, predicate: newest.predicate, value: structuredClone(newest.value),
       assertionIds: assertions.map((item) => item.id).sort(), evidenceKinds: [...new Set(assertions.map((item) => item.evidenceKind))].sort(),
       latestObservedAt: newest.observedAt, expiresAt: newest.expiresAt, privacy: newest.privacy,
-      groupId: newest.groupId, projectId: newest.projectId, authority: "context-only" });
+      groupId: newest.groupId, projectId: newest.projectId,
+      ...(newest.portalRef ? { portalRef: newest.portalRef, threadRef: newest.threadRef } : {}),
+      authority: "context-only" });
   }
   const order = (left, right) => left.subjectId.localeCompare(right.subjectId) || left.predicate.localeCompare(right.predicate);
   facts.sort(order); conflicts.sort(order); proposals.sort(order); stale.sort(order);
@@ -261,6 +314,8 @@ export async function worldContext({
   });
   return {
     schema: "agentspine.world-context/v1", root: names.root, revision: model.revision,
+    scope: { projectId, groupId, includePrivate,
+      ...(portalRef ? { portalRef, threadRef } : {}) },
     facts: facts.slice(0, maxItems), conflicts: conflicts.slice(0, maxItems),
     proposals: proposals.slice(0, maxItems).map(publicAssertion), stale: stale.slice(0, maxItems).map(publicAssertion),
     knowledge,
@@ -269,7 +324,7 @@ export async function worldContext({
     uncertainty: { requiresResolution: conflicts.length > 0, conflicts: conflicts.length,
       proposals: proposals.length, stale: stale.length },
     authority: "context-only",
-    note: "Only unexpired, non-conflicting measured or explicitly user-confirmed assertions are facts. Model suggestions remain proposals and grant no authority."
+    note: "Only unexpired, non-conflicting measured or explicitly user-confirmed assertions are facts. Model suggestions and uninterpreted user messages remain proposals and grant no authority."
   };
 }
 

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

@@ -9,6 +9,8 @@ import {
 } from "./lib/gateway-runtime.js";
 import { createTelegramAdapter } from "./lib/telegram-adapter.js";
 import { acknowledgeChannelDelivery, loadChannelRuntime } from "./lib/channel-runtime.js";
+import { channelTimelineContinuity } from "./lib/channel-continuity.js";
+import { groupResponseContract, settleSuppressedGroupEvents } from "./lib/gateway-group-response.js";
 import { loadPersonaRuntime, syncPersonaRosterFromEnvironment } from "./lib/persona-runtime.js";
 import { selfHelpPolicyForWorkItem } from "./lib/knowledge-evidence.js";
 import { isMainModule } from "./lib/runtime.js";
@@ -101,12 +103,14 @@ async function hostWorkItem(root, item) {
   const event = item.channelEventId === null ? null
     : channel.runtime.events.find((entry) => entry.eventId === item.channelEventId) || null;
   if (item.channelEventId && !event) throw new Error("claimed channel work lost its exact event");
+  const continuity = channelTimelineContinuity(event);
   return {
     ...structuredClone(item), host: identity.host, profileId: identity.profileId, projectRoot: root,
     goal: goal ? structuredClone(goal) : null,
     goalStep: goalStep ? { ...structuredClone(goalStep),
       ...(executionAttempt === null ? {} : { executionAttempt }) } : null,
     selfHelpPolicy: goalStep ? selfHelpPolicyForWorkItem(goalStep) : null,
+    groupResponseContract: groupResponseContract(event),
     hostEnvironment: {
       AGENTSPINE_GATEWAY_CONTEXT: "agentspine.gateway-start/v1",
       AGENTSPINE_ENTITY_ID: item.agentId,
@@ -122,7 +126,9 @@ async function hostWorkItem(root, item) {
       } : {}),
       ...(event ? {
         AGENTSPINE_CHANNEL_EVENT_ID: event.eventId,
-        AGENTSPINE_CHANNEL_PROVIDER: event.provider
+        AGENTSPINE_CHANNEL_PROVIDER: event.provider,
+        AGENTSPINE_PORTAL_REF: continuity.portalRef,
+        AGENTSPINE_THREAD_REF: continuity.threadRef
       } : {})
     },
     channelStart: event ? {
@@ -140,6 +146,7 @@ export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-
   await syncPersonaRosterFromEnvironment({ root, env, now });
   const initial = await loadGatewayRuntime(root);
   if (!initial.policy.enabled || initial.policy.killSwitch) return { status: "stopped", processed: false };
+  await settleSuppressedGroupEvents({ root, now });
   if (typeof deliveryAdapter.poll === "function") {
     try { await deliveryAdapter.poll(); }
     catch (error) {
@@ -175,6 +182,11 @@ export async function runWorkerTick({ root = process.cwd(), workerId = "gateway-
   }
   const completed = await completeGatewayRun({ root, queueId: claim.item.queueId, workerId,
     claimedAt: claim.item.lease.claimedAt, attempt: claim.item.attempts, result, now });
+  if (completed.communication?.suppressed) {
+    await settleSuppressedGroupEvents({ root, now });
+    return { status: "silent", processed: true, queueId: completed.item.queueId,
+      communication: completed.communication, deliveryConfirmed: false, completionVerified: false };
+  }
   if (!completed.outbox) return {
     status: completed.clarification ? "needs-clarification"
       : completed.exploration ? "exploring" : completed.selfHelp ? "self-help-resolved"

package/bin/blun.js

@@ -325,40 +325,55 @@ async function connectExistingRuntimeLease(timeoutMs = 3_000) {
 }
 
 async function main() {
-	let noticeResult = await acquireNoticeLease();
-	let runtimeResult;
-	try {
-		const installClear = await installLeaseIsClear();
-		if (!installClear || !noticeResult.acquired) {
-			runtimeResult = await connectExistingRuntimeLease();
-			if (!runtimeResult.acquired && !installClear) {
-				if (!await installLeaseIsClear()) {
-					process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
-					process.exitCode = 1;
-					return;
-				}
-				runtimeResult = undefined;
-			}
-			if (!runtimeResult?.acquired && !noticeResult.acquired) {
-				noticeResult = await acquireNoticeLease();
-				if (!noticeResult.acquired) {
-					process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
-					process.exitCode = 1;
-					return;
-				}
-			}
-		}
+  const explicitUpdateRequest = process.argv.length === 3
+    && /^(?:update|upgrade)$/iu.test(process.argv[2] || '');
+  let noticeResult = await acquireNoticeLease();
+  let runtimeResult;
+  try {
+    if (explicitUpdateRequest) {
+      runtimeResult = await connectExistingRuntimeLease(750);
+      if (!runtimeResult.acquired) {
+        runtimeResult = undefined;
+        if (!noticeResult.acquired || !await installLeaseIsClear()) {
+          process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+          process.exitCode = 1;
+          return;
+        }
+      }
+    } else {
+      const installClear = await installLeaseIsClear();
+      if (!installClear || !noticeResult.acquired) {
+        runtimeResult = await connectExistingRuntimeLease();
+        if (!runtimeResult.acquired && !installClear) {
+          if (!await installLeaseIsClear()) {
+            process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+            process.exitCode = 1;
+            return;
+          }
+          runtimeResult = undefined;
+        }
+        if (!runtimeResult?.acquired && !noticeResult.acquired) {
+          noticeResult = await acquireNoticeLease();
+          if (!noticeResult.acquired) {
+            process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+            process.exitCode = 1;
+            return;
+          }
+        }
+      }
+    }
     noticeResult.lease?.assertOwned();
     runtimeResult?.lease?.assertOwned();
     const { runLauncher } = require('./launcher-runtime');
     noticeResult.lease?.assertOwned();
     runtimeResult?.lease?.assertOwned();
     const filename = path.basename(__filename).toLowerCase();
-		await runLauncher({
-			mode: filename.startsWith('king') ? 'king' : 'blun',
-			noticeLease: noticeResult.lease,
-			runtimeLease: runtimeResult?.lease,
-		});
+    await runLauncher({
+      mode: filename.startsWith('king') ? 'king' : 'blun',
+      noticeLease: noticeResult.lease,
+      runtimeLease: runtimeResult?.lease,
+      skipUpdateNotice: runtimeResult?.acquired === true || !noticeResult.acquired,
+    });
   } finally {
     await runtimeResult?.lease?.release();
     await noticeResult.lease?.release();

package/bin/core-bootstrap.js

@@ -5,15 +5,12 @@ const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 
 const { acquireSharedRuntimeLease } = require('./update-lease');
-const { installWindowsNodeCrashDump } = require('./windows-node-crash-dump.cjs');
 
 const CORE_LOADED_MESSAGE = 'blun-core-bootstrap-loaded';
 
 async function runCoreBootstrap() {
   const packageRoot = path.resolve(__dirname, '..');
   const mainPath = path.join(packageRoot, 'blun.mjs');
-  const informational = process.argv.slice(2).some(arg => ['-h', '--help', '-V', '--version'].includes(arg));
-  if (!informational) installWindowsNodeCrashDump({ homeDir: process.env.BLUN_HOME });
   const leaseResult = await acquireSharedRuntimeLease({ packageRoot });
   if (!leaseResult.acquired) throw new Error('RUNTIME_PROTECTION_UNAVAILABLE');
 
@@ -34,7 +31,11 @@ async function runCoreBootstrap() {
 
   if (process.connected) {
     try {
-      process.send({ type: CORE_LOADED_MESSAGE });
+      process.send({ type: CORE_LOADED_MESSAGE }, () => {
+        try {
+          process.disconnect();
+        } catch {}
+      });
     } catch {}
   }
 }

package/bin/king.js

@@ -325,40 +325,55 @@ async function connectExistingRuntimeLease(timeoutMs = 3_000) {
 }
 
 async function main() {
-	let noticeResult = await acquireNoticeLease();
-	let runtimeResult;
-	try {
-		const installClear = await installLeaseIsClear();
-		if (!installClear || !noticeResult.acquired) {
-			runtimeResult = await connectExistingRuntimeLease();
-			if (!runtimeResult.acquired && !installClear) {
-				if (!await installLeaseIsClear()) {
-					process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
-					process.exitCode = 1;
-					return;
-				}
-				runtimeResult = undefined;
-			}
-			if (!runtimeResult?.acquired && !noticeResult.acquired) {
-				noticeResult = await acquireNoticeLease();
-				if (!noticeResult.acquired) {
-					process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
-					process.exitCode = 1;
-					return;
-				}
-			}
-		}
+  const explicitUpdateRequest = process.argv.length === 3
+    && /^(?:update|upgrade)$/iu.test(process.argv[2] || '');
+  let noticeResult = await acquireNoticeLease();
+  let runtimeResult;
+  try {
+    if (explicitUpdateRequest) {
+      runtimeResult = await connectExistingRuntimeLease(750);
+      if (!runtimeResult.acquired) {
+        runtimeResult = undefined;
+        if (!noticeResult.acquired || !await installLeaseIsClear()) {
+          process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+          process.exitCode = 1;
+          return;
+        }
+      }
+    } else {
+      const installClear = await installLeaseIsClear();
+      if (!installClear || !noticeResult.acquired) {
+        runtimeResult = await connectExistingRuntimeLease();
+        if (!runtimeResult.acquired && !installClear) {
+          if (!await installLeaseIsClear()) {
+            process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+            process.exitCode = 1;
+            return;
+          }
+          runtimeResult = undefined;
+        }
+        if (!runtimeResult?.acquired && !noticeResult.acquired) {
+          noticeResult = await acquireNoticeLease();
+          if (!noticeResult.acquired) {
+            process.stderr.write('Der geschuetzte BLUN-Start ist gerade nicht verfuegbar.\n');
+            process.exitCode = 1;
+            return;
+          }
+        }
+      }
+    }
     noticeResult.lease?.assertOwned();
     runtimeResult?.lease?.assertOwned();
     const { runLauncher } = require('./launcher-runtime');
     noticeResult.lease?.assertOwned();
     runtimeResult?.lease?.assertOwned();
     const filename = path.basename(__filename).toLowerCase();
-		await runLauncher({
-			mode: filename.startsWith('king') ? 'king' : 'blun',
-			noticeLease: noticeResult.lease,
-			runtimeLease: runtimeResult?.lease,
-		});
+    await runLauncher({
+      mode: filename.startsWith('king') ? 'king' : 'blun',
+      noticeLease: noticeResult.lease,
+      runtimeLease: runtimeResult?.lease,
+      skipUpdateNotice: runtimeResult?.acquired === true || !noticeResult.acquired,
+    });
   } finally {
     await runtimeResult?.lease?.release();
     await noticeResult.lease?.release();

package/bin/launcher-mode.js

@@ -10,8 +10,6 @@ const LAUNCHER_HELP_TEXT = [
   'Launchers:',
   '  blun  Starts the CLI without automatically attaching Telegram.',
   '  king  Starts the same CLI and automatically attaches the configured Telegram channel.',
-  '  king <profile> starts an isolated named King profile.',
-  '  king -c <profile> continues the last session in that profile.',
   '  Both use the same version, account, model, and commands.',
   '  blun tools list shows optional tools; enable writes only explicit choices.',
   '',
@@ -27,19 +25,13 @@ function launcherModeFromArgv(argv) {
 function createLauncherEnvironment(sourceEnv, mode, publicPackageVersion) {
   return {
     ...sourceEnv,
+    BLUN_NO_AUTO_UPDATE: '1',
     BLUN_PUBLIC_PACKAGE_VERSION: publicPackageVersion,
     BLUN_TELEGRAM_ATTACH: mode === LAUNCHER_MODES.KING ? 'on' : 'off',
     BLUN_TELEGRAM_HEADLESS: 'off',
   };
 }
 
-function createProtectedCoreEnvironment(sourceEnv) {
-  return {
-    ...sourceEnv,
-    BLUN_NO_AUTO_UPDATE: '1',
-  };
-}
-
 function isNpmPackageUpdateRequest(args) {
   if (!Array.isArray(args) || args.length !== 1) return false;
   const command = String(args[0] || '').toLowerCase();
@@ -53,7 +45,6 @@ function launcherHelpText() {
 module.exports = {
   LAUNCHER_MODES,
   createLauncherEnvironment,
-  createProtectedCoreEnvironment,
   isNpmPackageUpdateRequest,
   launcherHelpText,
   launcherModeFromArgv,