@askexenow/exe-os 0.9.382 → 0.9.384

package/dist/{chunk-IUCWOI4Y.js → chunk-RDWIKDMY.js}

@@ -1,6 +1,8 @@
 // src/lib/registry-proxy.ts
 import { createServer } from "http";
 import { readFileSync } from "fs";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { Readable } from "stream";
 
 // src/lib/stack-release-publish.ts
@@ -136,7 +138,7 @@ async function assertManifestSignature(manifest, publicKeyPem) {
       "manifest carries no `signature`. Fleets that enforce EXE_STACK_PUBLIC_KEY reject unsigned manifests, so publishing one would ship a release no host can install. Re-sign with the custodied key: node scripts/sign-stack-manifest.mjs deploy/stack-manifests/v0.9.json"
     );
   }
-  const { verifyStackManifestSignature } = await import("./stack-update-Z53KG2P5.js");
+  const { verifyStackManifestSignature } = await import("./stack-update-ZQQ5YYPJ.js");
   try {
     verifyStackManifestSignature(manifest, publicKeyPem);
   } catch (err) {
@@ -228,6 +230,94 @@ async function publishStackRelease(db, body, options) {
   await assertManifestSignature(validated.manifest, options.publicKeyPem);
   return insertStackRelease(db, validated);
 }
+async function promoteStackRelease(db, body) {
+  const version = typeof body.version === "string" ? body.version.trim() : "";
+  if (!version) {
+    throw reject(400, "version_missing", "`version` is required and must be a non-empty string.");
+  }
+  const declaredSha = typeof body.manifestSha256 === "string" ? body.manifestSha256.trim().toLowerCase() : "";
+  if (!/^[a-f0-9]{64}$/.test(declaredSha)) {
+    throw reject(
+      400,
+      "manifest_sha256_missing",
+      "`manifestSha256` is required (64 hex chars): a promotion must name the exact bytes it promotes, so it can never land on content the caller has not seen."
+    );
+  }
+  const existing = await db.query(
+    "SELECT manifest, manifest_sha256, status FROM billing.stack_releases WHERE version = $1",
+    [version]
+  );
+  const row = existing.rows[0];
+  if (!row) {
+    throw reject(
+      409,
+      "version_not_published",
+      `stack version ${version} has no row in billing.stack_releases. Publish it first \u2014 promotion changes an existing release's status, it does not create one.`
+    );
+  }
+  const existingSha = String(row.manifest_sha256 ?? "");
+  if (existingSha !== declaredSha) {
+    throw reject(
+      409,
+      "promote_content_mismatch",
+      `stack version ${version} holds sha256 ${existingSha || "<none>"} but this promotion declares ${declaredSha}. Refusing: the row does not contain the bytes you are promoting.`
+    );
+  }
+  const existingStatus = String(row.status ?? "");
+  if (existingStatus === "released") {
+    return { outcome: "already-released", version, manifestSha256: existingSha, status: "released" };
+  }
+  if (existingStatus !== "canary") {
+    throw reject(
+      409,
+      "promote_status_invalid",
+      `stack version ${version} has status "${existingStatus || "<none>"}" \u2014 only a "canary" row can be promoted to released.`
+    );
+  }
+  const manifest = row.manifest;
+  let latest;
+  let rolloutStage;
+  try {
+    const parsed = (typeof manifest === "string" ? JSON.parse(manifest) : manifest) ?? {};
+    latest = parsed.latest;
+    rolloutStage = (parsed.stacks?.[version] ?? {}).rolloutStage;
+  } catch {
+    throw reject(
+      409,
+      "promote_manifest_unreadable",
+      `stack version ${version} holds a manifest that could not be parsed, so its \`latest\` could not be checked. Refusing to promote something unverifiable.`
+    );
+  }
+  if (latest !== version) {
+    throw reject(
+      409,
+      "promote_would_not_be_latest",
+      `stack version ${version} holds a manifest whose latest is "${String(latest)}". Promoting it would serve a released manifest that does not declare itself latest. A canary cut with --canary deliberately does not bump \`latest\` and is NOT promotable in place: re-cut it for GA with \`exe-os stack-promote --version ` + version + "`, which edits the manifest and publishes a new released row. Only a canary published from a latest-bumping manifest (publish --status canary) can be promoted by status alone."
+    );
+  }
+  if (rolloutStage === "canary") {
+    throw reject(
+      409,
+      "promote_entry_declares_canary",
+      `stack version ${version} holds a SIGNED manifest whose stacks["${version}"].rolloutStage is "canary". Promotion changes status only \u2014 it cannot edit the signed bytes \u2014 so flipping this row would serve a release every updater refuses to install implicitly (assertRolloutStageAllowed). Re-cut it for GA with \`exe-os stack-promote --version ` + version + "`, which edits rolloutStage and re-signs. Status-only promotion is for an artifact that is already GA in its own bytes and was staged with `--status canary`."
+    );
+  }
+  const updated = await db.query(
+    `UPDATE billing.stack_releases
+        SET status = 'released'
+      WHERE version = $1 AND manifest_sha256 = $2 AND status = 'canary'
+      RETURNING version`,
+    [version, declaredSha]
+  );
+  if (updated.rows.length !== 1) {
+    throw reject(
+      409,
+      "promote_race",
+      `stack version ${version} changed underneath this promotion (hash or status moved between read and write). Re-read the row and retry.`
+    );
+  }
+  return { outcome: "promoted", version, manifestSha256: declaredSha, status: "released" };
+}
 
 // src/lib/registry-proxy.ts
 function readJsonSafe(url) {
@@ -244,16 +334,41 @@ function nonPlaceholderString(value) {
   if (!trimmed || trimmed === "unknown") return void 0;
   return trimmed;
 }
+var BUILD_IDENTITY_MAX_WALK = 6;
+function readJsonAt(file) {
+  return readJsonSafe(pathToFileURL(file));
+}
 function resolveRegistryProxyBuildIdentity(moduleUrl = import.meta.url) {
-  const pkg = readJsonSafe(new URL("../../package.json", moduleUrl));
-  const stamp = readJsonSafe(new URL("../version.json", moduleUrl));
+  const startDir = path.dirname(fileURLToPath(new URL(String(moduleUrl))));
+  let pkg;
+  let appRoot;
+  let dir = startDir;
+  for (let level = 0; level <= BUILD_IDENTITY_MAX_WALK; level++) {
+    const candidate = readJsonAt(path.join(dir, "package.json"));
+    if (candidate && typeof candidate.version === "string") {
+      pkg = candidate;
+      appRoot = dir;
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const stamp = readJsonAt(path.join(startDir, "version.json")) ?? readJsonAt(path.join(path.dirname(startDir), "version.json")) ?? (appRoot ? readJsonAt(path.join(appRoot, "dist", "version.json")) : void 0);
   return {
     version: nonPlaceholderString(pkg?.version) ?? "unknown",
     buildSha: nonPlaceholderString(stamp?.sha),
-    builtAt: nonPlaceholderString(stamp?.built)
+    builtAt: nonPlaceholderString(stamp?.built),
+    ...stamp?.ref !== void 0 ? { buildRef: nonPlaceholderString(stamp.ref) } : {},
+    ...stamp?.repo !== void 0 ? { buildRepo: nonPlaceholderString(stamp.repo) } : {}
   };
 }
 var BUILD_IDENTITY = resolveRegistryProxyBuildIdentity();
+if (BUILD_IDENTITY.version === "unknown") {
+  console.error(
+    `[registry-proxy] BUILD IDENTITY UNRESOLVED \u2014 no package.json with a \`version\` was found within ${BUILD_IDENTITY_MAX_WALK} levels above ${import.meta.url}. GET /health and GET /__version will report version:"unknown", which leaves the serving-code drift axis of scripts/check-stack-release-drift.mjs blind (bug b01bbe35). This is a packaging defect in the image, not a runtime condition to wait out.`
+  );
+}
 function parsePullTokens(raw) {
   return (raw ?? "").split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
 }
@@ -343,6 +458,18 @@ function unauthorized(res, scheme = "Basic") {
 }
 var READ_ONLY_METHODS = ["GET", "HEAD"];
 var STACK_RELEASE_PUBLISH_PATH = "/v1/stack-releases";
+var SERVED_VERSION_PATH = "/__version";
+var STACK_RELEASE_PROMOTE_PATH = "/v1/stack-releases/promote";
+var STACK_MANIFEST_CHANNELS = ["released", "canary"];
+function resolveStackManifestChannel(raw) {
+  if (raw === null || raw === "") return { channel: "released" };
+  if (STACK_MANIFEST_CHANNELS.includes(raw)) {
+    return { channel: raw };
+  }
+  return {
+    error: `unknown channel "${raw}" \u2014 expected one of ${STACK_MANIFEST_CHANNELS.join(", ")}. Refusing rather than falling back to the released channel: a caller that asked for something this endpoint does not understand must not be handed something else.`
+  };
+}
 function isReadOnlyRegistryMethod(method) {
   return readOnlyRegistryMethod(method) !== null;
 }
@@ -423,9 +550,15 @@ function classifyRegistryProxyRequest(req, namespace) {
   if (url.pathname === "/health") {
     return method ? { kind: "health", method, url } : { kind: "method-not-allowed", method: req.method, url };
   }
+  if (url.pathname === SERVED_VERSION_PATH) {
+    return method ? { kind: "served-version", method, url } : { kind: "method-not-allowed", method: req.method, url };
+  }
   if (url.pathname === "/v1/stack-manifest.json") {
     return method ? { kind: "stack-manifest", method, url } : { kind: "method-not-allowed", method: req.method, url };
   }
+  if (url.pathname === STACK_RELEASE_PROMOTE_PATH) {
+    return (req.method ?? "").toUpperCase() === "POST" ? { kind: "stack-release-promote", url } : { kind: "method-not-allowed", method: req.method, url, allow: ["POST"] };
+  }
   if (url.pathname === STACK_RELEASE_PUBLISH_PATH) {
     return (req.method ?? "").toUpperCase() === "POST" ? { kind: "stack-release-publish", url } : { kind: "method-not-allowed", method: req.method, url, allow: ["POST"] };
   }
@@ -434,7 +567,7 @@ function classifyRegistryProxyRequest(req, namespace) {
     return method ? { kind: "registry-read", method, url } : { kind: "method-not-allowed", method: req.method, url };
   }
   if (pathKind === "write" && !method) {
-    return { kind: "method-not-allowed", method: req.method, url };
+    return { kind: "method-not-allowed", method: req.method, url, attemptedWrite: true };
   }
   return { kind: "not-found", url };
 }
@@ -530,6 +663,15 @@ function createRegistryProxyServer(options) {
       unauthorized(res, "Bearer");
       return;
     }
+    const resolved = resolveStackManifestChannel(
+      new URL(req.url ?? "/", "http://localhost").searchParams.get("channel")
+    );
+    if ("error" in resolved) {
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: resolved.error, code: "channel_invalid" }));
+      return;
+    }
+    const channel = resolved.channel;
     const pool = await getManifestPool();
     if (!pool) {
       res.writeHead(503, { "content-type": "application/json" });
@@ -539,11 +681,15 @@ function createRegistryProxyServer(options) {
     try {
       const result = await pool.query(
         "SELECT manifest FROM billing.stack_releases WHERE status = $1 ORDER BY string_to_array(version, '.')::int[] DESC LIMIT 1",
-        ["released"]
+        [channel]
       );
       if (result.rows.length === 0) {
         res.writeHead(503, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: "no released stack manifest available" }));
+        res.end(JSON.stringify({
+          error: `no ${channel} stack manifest available`,
+          code: "no_manifest_for_channel",
+          channel
+        }));
         return;
       }
       const manifest = result.rows[0].manifest;
@@ -635,12 +781,72 @@ function createRegistryProxyServer(options) {
       res.end(JSON.stringify({ error: "stack release publish failed", code: "publish_failed", detail }));
     }
   }
+  async function handleStackReleasePromote(req, res) {
+    const publisherTokens = options.publisherTokens ?? [];
+    const token = parseBearerToken(req.headers.authorization);
+    if (publisherTokens.length === 0) {
+      console.error(
+        "[registry-proxy] promote attempt refused: EXE_REGISTRY_PROXY_PUBLISHER_TOKENS is not configured."
+      );
+      res.writeHead(503, { "content-type": "application/json" });
+      res.end(JSON.stringify({
+        error: "stack release publishing is not enabled on this host",
+        code: "publisher_not_configured"
+      }));
+      return;
+    }
+    if (!token || !constantTimeTokenMatch(token, publisherTokens)) {
+      console.warn(
+        `[registry-proxy] REFUSED stack-release promote: bad or missing publisher token from ${req.socket.remoteAddress ?? "unknown"}.`
+      );
+      res.writeHead(401, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "publisher authentication required", code: "publisher_unauthorized" }));
+      return;
+    }
+    try {
+      const body = await readJsonBody(req, 64 * 1024);
+      const pool = await getManifestPool();
+      if (!pool) {
+        throw new StackReleasePublishError({
+          httpStatus: 503,
+          code: "release_store_unavailable",
+          detail: "no database configured/reachable for billing.stack_releases"
+        });
+      }
+      const result = await promoteStackRelease(pool, body);
+      console.log(
+        `[registry-proxy] stack release ${result.version} ${result.outcome} (status=${result.status}, manifest_sha256=${result.manifestSha256}).`
+      );
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      if (err instanceof StackReleasePublishError) {
+        const { httpStatus, code, detail: detail2 } = err.rejection;
+        console.error(`[registry-proxy] stack-release promote REFUSED (${httpStatus} ${code}): ${detail2}`);
+        res.writeHead(httpStatus, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: detail2, code }));
+        return;
+      }
+      const detail = err instanceof Error ? err.message : String(err);
+      console.error(`[registry-proxy] stack-release promote FAILED: ${detail}`);
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "stack release promote failed", code: "promote_failed", detail }));
+    }
+  }
   return createServer(async (req, res) => {
     const route = classifyRegistryProxyRequest(req, namespace);
     if (route.kind === "method-not-allowed") {
-      console.warn(
-        `[registry-proxy] BLOCKED write attempt: ${req.method} ${route.url?.pathname ?? "<unparseable>"} from ${req.socket.remoteAddress ?? "unknown"} \u2014 proxy is pull-through only.`
-      );
+      const addr = req.socket.remoteAddress ?? "unknown";
+      const pathname = route.url?.pathname ?? "<unparseable>";
+      if (route.attemptedWrite) {
+        console.warn(
+          `[registry-proxy] BLOCKED write attempt: ${req.method} ${pathname} from ${addr} \u2014 proxy is pull-through only.`
+        );
+      } else {
+        console.warn(
+          `[registry-proxy] 405 method not allowed: ${req.method} ${pathname} from ${addr} (allow: ${(route.allow ?? READ_ONLY_METHODS).join(", ")})`
+        );
+      }
       methodNotAllowed(res, req.method, route.allow);
       return;
     }
@@ -648,6 +854,18 @@ function createRegistryProxyServer(options) {
       notFound(res);
       return;
     }
+    if (route.kind === "served-version") {
+      res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+      res.end(JSON.stringify({
+        service: "exe-registry-proxy",
+        version: BUILD_IDENTITY.version,
+        ...BUILD_IDENTITY.buildSha ? { sha: BUILD_IDENTITY.buildSha } : {},
+        ...BUILD_IDENTITY.buildRef ? { ref: BUILD_IDENTITY.buildRef } : {},
+        ...BUILD_IDENTITY.buildRepo ? { repo: BUILD_IDENTITY.buildRepo } : {},
+        ...BUILD_IDENTITY.builtAt ? { built: BUILD_IDENTITY.builtAt } : {}
+      }));
+      return;
+    }
     if (route.kind === "health") {
       res.writeHead(200, { "content-type": "application/json" });
       res.end(JSON.stringify({
@@ -669,6 +887,10 @@ function createRegistryProxyServer(options) {
       await handleStackReleasePublish(req, res);
       return;
     }
+    if (route.kind === "stack-release-promote") {
+      await handleStackReleasePromote(req, res);
+      return;
+    }
     const auth = parseBasicAuth(req.headers.authorization);
     if (!auth) {
       unauthorized(res);
@@ -715,7 +937,7 @@ async function runRegistryProxy(options = registryProxyOptionsFromEnv()) {
   await new Promise((resolve) => server.listen(options.port, options.host, resolve));
   console.log(`exe-registry-proxy listening on ${options.host ?? "0.0.0.0"}:${options.port}`);
   console.log(`proxying /v2/${options.allowedNamespace ?? "askexe"}/* -> ${options.upstream ?? "https://ghcr.io"}`);
-  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-ZCZ2LIHK.js");
+  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-BVSG3WMW.js");
   const syncConfig = licenseSyncConfigFromEnv();
   if (syncConfig) {
     startLicenseSyncScheduler(syncConfig);
@@ -731,6 +953,10 @@ export {
   registryProxyOptionsFromEnv,
   assertRegistryProxyConfig,
   STACK_RELEASE_PUBLISH_PATH,
+  SERVED_VERSION_PATH,
+  STACK_RELEASE_PROMOTE_PATH,
+  STACK_MANIFEST_CHANNELS,
+  resolveStackManifestChannel,
   isReadOnlyRegistryMethod,
   createRegistryProxyServer,
   runRegistryProxy

package/dist/{chunk-ENN6DY4T.js → chunk-RVO5O5SR.js}

@@ -5,26 +5,26 @@ import {
   behaviorTruncationNotice,
   fetchInjectableBehaviors,
   selectInjectedBehaviors
-} from "./chunk-VZT66WWP.js";
+} from "./chunk-4AAMFWJT.js";
 import {
   countActiveBehaviors,
   listBehaviors
-} from "./chunk-2YIB75UQ.js";
+} from "./chunk-S26CV7BE.js";
 import {
   lightweightSearch
-} from "./chunk-TXTXC3QG.js";
+} from "./chunk-3RGTLZNO.js";
 import {
   getCurrentSessionScope
-} from "./chunk-ZVBVPX4W.js";
+} from "./chunk-7UHZBVP3.js";
 import {
   getSessionKey
 } from "./chunk-CVYC6DUW.js";
 import {
   getProjectName
-} from "./chunk-22LNFCDF.js";
+} from "./chunk-UX2EO653.js";
 import {
   getClient
-} from "./chunk-AY2U4NZ5.js";
+} from "./chunk-GL47M7NY.js";
 
 // src/lib/session-summary.ts
 var MAX_CHARS = 800;
@@ -160,17 +160,23 @@ function sanitizeSegment(s) {
 function sanitizeSessionKey(sessionKey) {
   return sanitizeSegment(sessionKey) || `unknown-${process.pid}`;
 }
-function sessionScratchDir(sessionKey, homeDir = os.homedir(), agentId) {
+var MAIN_LOOP_INSTANCE = "main";
+function scratchInstanceSegment(instanceId) {
+  if (typeof instanceId !== "string") return "";
+  return sanitizeSegment(instanceId);
+}
+function sessionScratchDir(sessionKey, homeDir = os.homedir(), agentId, instanceId) {
   const base = path.join(homeDir, ".exe-os", "session-cache", "scratch", sanitizeSessionKey(sessionKey));
-  if (agentId === void 0) return base;
-  const agentSegment = sanitizeSegment(agentId);
-  return agentSegment ? path.join(base, agentSegment) : base;
+  const agentSegment = agentId === void 0 ? "" : sanitizeSegment(agentId);
+  const instanceSegment = scratchInstanceSegment(instanceId);
+  const segments = [agentSegment, instanceSegment].filter((s) => s.length > 0);
+  return segments.length > 0 ? path.join(base, ...segments) : base;
 }
-function resolveSessionScratchDir(homeDir = os.homedir(), agentId) {
-  return sessionScratchDir(getSessionKey(), homeDir, agentId);
+function resolveSessionScratchDir(homeDir = os.homedir(), agentId, instanceId) {
+  return sessionScratchDir(getSessionKey(), homeDir, agentId, instanceId);
 }
-function ensureSessionScratchDir(sessionKey, homeDir = os.homedir(), agentId) {
-  const dir = sessionKey === void 0 ? resolveSessionScratchDir(homeDir, agentId) : sessionScratchDir(sessionKey, homeDir, agentId);
+function ensureSessionScratchDir(sessionKey, homeDir = os.homedir(), agentId, instanceId) {
+  const dir = sessionKey === void 0 ? resolveSessionScratchDir(homeDir, agentId, instanceId) : sessionScratchDir(sessionKey, homeDir, agentId, instanceId);
   try {
     mkdirSync(dir, { recursive: true });
   } catch {
@@ -320,6 +326,28 @@ async function activeBehaviorBrief(agentId, projectName) {
   const injected = selectInjectedBehaviors(behaviors, BEHAVIOR_LIMIT);
   return renderBehaviorSection(injected, counts);
 }
+function renderScratchSection(scratchDir, isolated) {
+  const shared = [
+    "The `scratchpad` path in your harness system prompt (e.g. /tmp/claude-*/<project>/<session>/scratchpad) is a DIFFERENT directory and is SHARED by every agent in this session, including the one that dispatched you. Do not put commit messages, PR bodies or anything you will consume back into it.",
+    "CLEANUP: delete only files you created yourself. Never `rm -rf` a scratch directory \u2014 list it first; files you do not recognise belong to another agent and may be in active use."
+  ];
+  if (isolated) {
+    return [
+      "## Private Scratch Directory",
+      "Unique to THIS agent instance (session + employee + spawn instance), so a concurrent agent \u2014 including another agent with your own identity \u2014 resolves a different directory:",
+      scratchDir,
+      "Write named intermediate artifacts (pr.md, commit messages, diffs, generated code, files staged for commit) HERE.",
+      ...shared
+    ].join("\n");
+  }
+  return [
+    "## Shared Scratch Directory \u2014 NOT private",
+    "This directory is scoped to your session and employee identity but NOT to your agent instance, because no instance id was available. Other agents running right now under the same identity resolve this SAME path:",
+    scratchDir,
+    "So: prefix every filename you write with a discriminator of your own (`$$` works), and verify a file's first line before consuming it \u2014 a file being present does NOT mean you wrote it. Never `git commit -F <file>` without checking that file's content in the same command.",
+    ...shared
+  ].join("\n");
+}
 async function buildEmployeeBootBriefInner(input, degraded) {
   const agentId = input.agentId.trim();
   const projectName = input.projectName ?? getProjectName(input.cwd);
@@ -330,9 +358,11 @@ async function buildEmployeeBootBriefInner(input, degraded) {
     runSection("memories", () => recentProjectMemories(agentId, projectName, sessionScope ?? null, input.mode), "", degraded),
     runSection("behaviors", () => activeBehaviorBrief(agentId, projectName), "", degraded)
   ]);
+  const instanceId = input.mode === "session-start" ? MAIN_LOOP_INSTANCE : input.agentInstanceId ?? "";
+  const scratchIsolated = scratchInstanceSegment(instanceId).length > 0;
   let scratchDir = "";
   try {
-    scratchDir = ensureSessionScratchDir(void 0, void 0, agentId);
+    scratchDir = ensureSessionScratchDir(void 0, void 0, agentId, instanceId);
   } catch {
     scratchDir = "";
   }
@@ -346,12 +376,7 @@ ${capBlock(summary, SUMMARY_CAP)}`);
   if (workingMemory) sections.push(`## Working Memory (auto-loaded)
 ${capBlock(workingMemory.trim(), WORKING_MEMORY_CAP)}`);
   if (scratchDir) {
-    sections.push([
-      "## Isolated Scratch Directory",
-      `Per-session scratch dir (unique to THIS session, safe from concurrent agents):`,
-      scratchDir,
-      "Write named intermediate artifacts (pr.md, diffs, generated code, files staged for commit) HERE, not in a shared temp path. A file you place here cannot be read or overwritten by another agent's session."
-    ].join("\n"));
+    sections.push(renderScratchSection(scratchDir, scratchIsolated));
   }
   if (memories) sections.push(`## Memory Brief
 Recent memories from this project:

package/dist/{chunk-LY4AXCYJ.js → chunk-RZN2LEAK.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-AY2U4NZ5.js";
+} from "./chunk-GL47M7NY.js";
 
 // src/lib/pipeline-router.ts
 import crypto from "crypto";
@@ -116,12 +116,12 @@ async function sinkCRM(msg, agentResponse, agentName) {
 }
 async function sinkWiki(msg, agentResponse) {
   try {
-    const { createWikiClient } = await import("./wiki-client-W65IOSWF.js");
+    const { createWikiClient } = await import("./wiki-client-DD2NVWK2.js");
     const client = await createWikiClient();
     if (!client) return false;
     const content = msg.text ?? "";
     if (content.length < 50) return false;
-    const { chatInWorkspace } = await import("./wiki-client-W65IOSWF.js");
+    const { chatInWorkspace } = await import("./wiki-client-DD2NVWK2.js");
     const ingestText = [
       `[${msg.platform}] Message from ${msg.senderName ?? msg.senderId} (${msg.timestamp}):`,
       content,
@@ -140,8 +140,8 @@ Agent response: ${agentResponse}` : ""
 }
 async function sinkEntityExtraction(msg, agentResponse, agentName) {
   try {
-    const { extractFromConversation } = await import("./conversation-entity-extractor-4UG7BKWL.js");
-    const { storeExtraction } = await import("./graph-rag-TZLH3CTQ.js");
+    const { extractFromConversation } = await import("./conversation-entity-extractor-7FRKLLBD.js");
+    const { storeExtraction } = await import("./graph-rag-BKAD2XQA.js");
     if ((msg.text?.length ?? 0) < 20) return false;
     if (msg.isHistorical) return false;
     const extraction = await extractFromConversation(msg, agentResponse, agentName);
@@ -149,7 +149,7 @@ async function sinkEntityExtraction(msg, agentResponse, agentName) {
     const client = getClient();
     const memoryId = `conv:${msg.messageId}`;
     await storeExtraction(client, extraction, memoryId, msg.timestamp);
-    import("./conversation-wiki-populator-OS4C6W54.js").then(
+    import("./conversation-wiki-populator-YAOVCUGO.js").then(
       ({ populateWikiFromExtraction }) => populateWikiFromExtraction(extraction, msg, agentResponse, agentName)
     ).catch((err) => {
       process.stderr.write(

package/dist/{chunk-2YIB75UQ.js → chunk-S26CV7BE.js}

@@ -1,15 +1,16 @@
 import {
+  isTransientDaemonTransportError,
   retryOnDaemonTransportError
-} from "./chunk-QV5CQLQH.js";
+} from "./chunk-EIOGV75A.js";
 import {
   vectorToSqlLiteral
-} from "./chunk-CO5ZVE3D.js";
+} from "./chunk-UOPCVFVR.js";
 import {
   blobToVector
 } from "./chunk-OTVEIJUQ.js";
 import {
   getClient
-} from "./chunk-AY2U4NZ5.js";
+} from "./chunk-GL47M7NY.js";
 
 // src/lib/behaviors.ts
 import crypto from "crypto";
@@ -121,15 +122,45 @@ async function storeBehavior(opts) {
     } catch {
     }
   }
-  await retryOnDaemonTransportError(async () => {
-    await getClient().execute({
-      sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at, vector, created_by_agent, created_by_device, source_session_id, device_id)
-            VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?)`,
-      args: [id, trimmedAgent, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", trimmedContent, now, now, vector ? vectorToSqlLiteral(vector) : null, createdByAgent, createdByDevice, sourceSessionId, deviceId]
+  try {
+    await retryOnDaemonTransportError(async () => {
+      await getClient().execute({
+        sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at, vector, created_by_agent, created_by_device, source_session_id, device_id)
+              VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [id, trimmedAgent, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", trimmedContent, now, now, vector ? vectorToSqlLiteral(vector) : null, createdByAgent, createdByDevice, sourceSessionId, deviceId]
+      });
     });
-  });
+  } catch (err) {
+    if (!isTransientDaemonTransportError(err) && !isSelfInsertConflict(err)) throw err;
+    const landed = await behaviorRowExists(id);
+    if (landed === true) return id;
+    if (landed === null) {
+      const cause = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `[behaviors] Behavior store outcome is UNKNOWN for id ${id}. The daemon transport failed after the write was dispatched (${cause}), and the read-back that would settle whether it committed also failed. The row may or may not exist. Retrying this exact store is SAFE: the duplicate guard returns the existing row instead of inserting a second copy. Do NOT report that the behavior was not stored \u2014 that is not known.`
+      );
+    }
+    throw err;
+  }
   return id;
 }
+function isSelfInsertConflict(err) {
+  const msg = err instanceof Error ? err.message : String(err ?? "");
+  return /UNIQUE constraint failed:\s*behaviors\.id/i.test(msg) || /PRIMARY KEY (?:constraint )?(?:must be unique|failed)/i.test(msg);
+}
+async function behaviorRowExists(id) {
+  try {
+    const check = await retryOnDaemonTransportError(async () => {
+      return await getClient().execute({
+        sql: "SELECT id FROM behaviors WHERE id = ? LIMIT 1",
+        args: [id]
+      });
+    });
+    return check.rows.length > 0;
+  } catch {
+    return null;
+  }
+}
 async function countActiveBehaviors(agentId, projectName) {
   const client = getClient();
   let currentDeviceId = null;
@@ -157,7 +188,7 @@ async function countActiveBehaviors(agentId, projectName) {
     p0: Number(row?.p0 ?? 0)
   };
 }
-async function listBehaviors(agentId, projectName, limit = 30) {
+async function listBehaviors(agentId, projectName, limit = 30, opts = {}) {
   const client = getClient();
   let currentDeviceId = null;
   try {
@@ -165,6 +196,14 @@ async function listBehaviors(agentId, projectName, limit = 30) {
     currentDeviceId = loadDeviceId() ?? null;
   } catch {
   }
+  const CANONICAL_UTC_GLOB = "'[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]T[0-9][0-9]:[0-9][0-9]:[0-9][0-9].[0-9][0-9][0-9]Z'";
+  const MODIFIED_AT = "coalesce(nullif(trim(coalesce(updated_at, '')), ''), created_at)";
+  const cutoff = opts.unchangedAtOrBefore && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(opts.unchangedAtOrBefore) ? opts.unchangedAtOrBefore : void 0;
+  const stabilityClause = cutoff ? `AND (${MODIFIED_AT} <= ?
+                 OR ${MODIFIED_AT} NOT GLOB ${CANONICAL_UTC_GLOB})` : "";
+  const stabilityArgs = cutoff ? [cutoff] : [];
+  const idClause = opts.id ? "AND id = ?" : "";
+  const idArgs = opts.id ? [opts.id] : [];
   const { offloadReadIfMain } = await import("./lib/database.js");
   const result = await offloadReadIfMain(
     client,
@@ -174,6 +213,8 @@ async function listBehaviors(agentId, projectName, limit = 30) {
             AND id IS NOT NULL AND trim(coalesce(content, '')) != ''
             AND (project_name IS NULL OR project_name = ?)
             AND (device_id IS NULL OR device_id = ?)
+            ${stabilityClause}
+            ${idClause}
           ORDER BY
             CASE WHEN priority = 'p0' THEN 0
                  WHEN priority = 'p1' THEN 1
@@ -187,7 +228,7 @@ async function listBehaviors(agentId, projectName, limit = 30) {
             END,
             updated_at DESC
           LIMIT ?`,
-    [agentId, projectName ?? "", currentDeviceId ?? "", limit],
+    [agentId, projectName ?? "", currentDeviceId ?? "", ...stabilityArgs, ...idArgs, limit],
     true
   );
   return result.rows.map((r) => ({
@@ -273,7 +314,7 @@ async function listBehaviorsSince(agentId, sinceIso, projectName, limit = 15) {
     device_id: r.device_id ? String(r.device_id) : null
   }));
 }
-async function listSharedSkills(currentAgentId, projectName, limit = 30) {
+async function listSharedSkills(currentAgentId, projectName, limit = 30, priority) {
   const client = getClient();
   let currentDeviceId = null;
   try {
@@ -281,6 +322,8 @@ async function listSharedSkills(currentAgentId, projectName, limit = 30) {
     currentDeviceId = loadDeviceId() ?? null;
   } catch {
   }
+  const priorityClause = priority ? "AND coalesce(priority, 'p1') = ?" : "";
+  const priorityArgs = priority ? [priority] : [];
   const result = await client.execute({
     sql: `SELECT id, agent_id, project_name, domain, priority, content, active, created_at, updated_at, vector, created_by_agent, created_by_device, source_session_id, device_id
           FROM behaviors
@@ -288,11 +331,12 @@ async function listSharedSkills(currentAgentId, projectName, limit = 30) {
             AND id IS NOT NULL AND trim(coalesce(content, '')) != ''
             AND (project_name IS NULL OR project_name = ?)
             AND (device_id IS NULL OR device_id = ?)
+            ${priorityClause}
           ORDER BY
             CASE WHEN agent_id = ? THEN 0 ELSE 1 END,
             updated_at DESC
           LIMIT ?`,
-    args: [projectName ?? "", currentDeviceId ?? "", currentAgentId, limit]
+    args: [projectName ?? "", currentDeviceId ?? "", ...priorityArgs, currentAgentId, limit]
   });
   return result.rows.map((r) => ({
     id: String(r.id),