@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/{chunk-KYFFVTGO.js → chunk-55BEFF4V.js}

@@ -1,7 +1,7 @@
 import {
   hasLiveSubagentSpawn,
   projectScopedDefShadows
-} from "./chunk-2ADYTOHQ.js";
+} from "./chunk-K4ESASPL.js";
 import {
   getSessionKey
 } from "./chunk-CVYC6DUW.js";
@@ -14,10 +14,10 @@ import {
   getEmployee,
   isCoordinatorRole,
   loadEmployeesSync
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/active-agent.ts
 import { readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from "fs";

package/dist/{chunk-SEP5ITFQ.js → chunk-636LKCKE.js}

@@ -1,9 +1,9 @@
 import {
   getClient
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 import {
   loadConfig
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/reminders.ts
 import crypto from "crypto";

package/dist/{chunk-QTI4QAWA.js → chunk-6EZQUNE6.js}

@@ -1,6 +1,235 @@
 // src/lib/registry-proxy.ts
 import { createServer } from "http";
+import { readFileSync } from "fs";
 import { Readable } from "stream";
+
+// src/lib/stack-release-publish.ts
+import { createHash, timingSafeEqual } from "crypto";
+var MAX_MANIFEST_BYTES = 4 * 1024 * 1024;
+var PUBLISHABLE_STATUSES = ["released", "canary"];
+var StackReleasePublishError = class extends Error {
+  rejection;
+  constructor(rejection) {
+    super(`${rejection.code}: ${rejection.detail}`);
+    this.name = "StackReleasePublishError";
+    this.rejection = rejection;
+  }
+};
+function reject(httpStatus, code, detail) {
+  return new StackReleasePublishError({ httpStatus, code, detail });
+}
+function manifestSha256(rawManifest) {
+  return createHash("sha256").update(rawManifest, "utf8").digest("hex");
+}
+function constantTimeTokenMatch(candidate, accepted) {
+  if (!candidate) return false;
+  const candidateDigest = createHash("sha256").update(candidate, "utf8").digest();
+  let matched = false;
+  for (const token of accepted) {
+    if (!token) continue;
+    const tokenDigest = createHash("sha256").update(token, "utf8").digest();
+    if (timingSafeEqual(candidateDigest, tokenDigest)) matched = true;
+  }
+  return matched;
+}
+function parsePublisherTokens(raw) {
+  return (raw ?? "").split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
+}
+var VERSION_RE = /^[0-9]+(?:\.[0-9]+){1,3}$/;
+function validatePublishBody(body) {
+  const { version, manifest, status, createdBy } = body;
+  if (typeof manifest !== "string" || manifest.trim() === "") {
+    throw reject(
+      400,
+      "manifest_required",
+      "`manifest` must be the RAW manifest file bytes as a string. A pre-parsed object is refused: manifest_sha256 must be the hash of the exact bytes that were signed."
+    );
+  }
+  if (Buffer.byteLength(manifest, "utf8") > MAX_MANIFEST_BYTES) {
+    throw reject(413, "manifest_too_large", `manifest exceeds ${MAX_MANIFEST_BYTES} bytes`);
+  }
+  if (typeof version !== "string" || !VERSION_RE.test(version)) {
+    throw reject(400, "version_invalid", '`version` must be a dotted numeric stack version, e.g. "0.9.36"');
+  }
+  const resolvedStatus = status === void 0 ? "released" : status;
+  if (typeof resolvedStatus !== "string" || !PUBLISHABLE_STATUSES.includes(resolvedStatus)) {
+    throw reject(
+      400,
+      "status_invalid",
+      `\`status\` must be one of ${PUBLISHABLE_STATUSES.join(", ")}. "draft" is not publishable \u2014 a draft is not a release.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(manifest);
+  } catch (err) {
+    throw reject(400, "manifest_unparseable", `manifest is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw reject(400, "manifest_unparseable", "manifest must be a JSON object");
+  }
+  const manifestObj = parsed;
+  if (manifestObj.schemaVersion !== 1) {
+    throw reject(422, "schema_version_unsupported", `manifest.schemaVersion must be 1 (got ${String(manifestObj.schemaVersion)})`);
+  }
+  const stacks = manifestObj.stacks;
+  if (!stacks || typeof stacks !== "object" || Array.isArray(stacks)) {
+    throw reject(422, "manifest_no_stacks", "manifest.stacks must be an object");
+  }
+  const entry = stacks[version];
+  if (!entry || typeof entry !== "object") {
+    throw reject(
+      422,
+      "version_not_in_manifest",
+      `manifest.stacks has no entry for version "${version}". Publishing a version the manifest does not describe would ship an empty release.`
+    );
+  }
+  const entryVersion = entry.version;
+  if (entryVersion !== version) {
+    throw reject(
+      422,
+      "version_mismatch",
+      `manifest.stacks["${version}"].version is "${String(entryVersion)}" \u2014 the entry disagrees with its own key.`
+    );
+  }
+  if (resolvedStatus === "released" && manifestObj.latest !== version) {
+    throw reject(
+      422,
+      "latest_mismatch",
+      `status "released" requires manifest.latest === "${version}" (got "${String(manifestObj.latest)}"). Publish a canary with status "canary", which is exempt because a canary does not bump latest.`
+    );
+  }
+  return {
+    version,
+    rawManifest: manifest,
+    manifestSha256: manifestSha256(manifest),
+    manifest: manifestObj,
+    status: resolvedStatus,
+    createdBy: typeof createdBy === "string" && createdBy.trim() ? createdBy.trim().slice(0, 200) : "publish-endpoint"
+  };
+}
+function assertDeclaredSha(validated, declared) {
+  if (declared === void 0 || declared === null) return;
+  if (typeof declared !== "string" || !/^[a-f0-9]{64}$/i.test(declared)) {
+    throw reject(400, "manifest_sha256_invalid", "`manifestSha256`, when given, must be 64 hex characters");
+  }
+  if (declared.toLowerCase() !== validated.manifestSha256) {
+    throw reject(
+      400,
+      "manifest_sha256_mismatch",
+      `declared manifestSha256 ${declared.toLowerCase()} != sha256 of received bytes ${validated.manifestSha256}. The manifest was altered in transit.`
+    );
+  }
+}
+async function assertManifestSignature(manifest, publicKeyPem) {
+  if (!publicKeyPem || !publicKeyPem.trim()) {
+    throw reject(
+      503,
+      "signature_verification_unavailable",
+      "No stack manifest public key configured (EXE_STACK_PUBLIC_KEY / EXE_STACK_PUBLIC_KEY_FILE). Refusing to publish: an unverifiable publish cannot guarantee that published implies signed."
+    );
+  }
+  if (!manifest.signature) {
+    throw reject(
+      422,
+      "manifest_unsigned",
+      "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-J6JXSTAZ.js");
+  try {
+    verifyStackManifestSignature(manifest, publicKeyPem);
+  } catch (err) {
+    throw reject(
+      422,
+      "manifest_signature_invalid",
+      `manifest signature does not verify against the configured public key: ${err instanceof Error ? err.message : String(err)}. This is a STALE signature (the manifest was edited after signing) or a wrong key. Refusing to publish.`
+    );
+  }
+}
+async function assertVersionUniqueIndex(db) {
+  let rows;
+  try {
+    ({ rows } = await db.query(
+      `SELECT 1
+         FROM pg_index i
+         JOIN pg_class c ON c.oid = i.indrelid
+         JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = 'billing'
+          AND c.relname = 'stack_releases'
+          AND i.indisunique
+          AND i.indnkeyatts = 1
+          AND (SELECT a.attname FROM pg_attribute a WHERE a.attrelid = c.oid AND a.attnum = i.indkey[0]) = 'version'
+        LIMIT 1`
+    ));
+  } catch (err) {
+    throw reject(
+      503,
+      "idempotency_constraint_unverifiable",
+      `could not verify the UNIQUE index on billing.stack_releases(version): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (rows.length === 0) {
+    throw reject(
+      503,
+      "idempotency_constraint_missing",
+      "billing.stack_releases has no UNIQUE index on (version). Publishing without it cannot be idempotent \u2014 two release runs would create two rows. Apply deploy/migrations/004_billing_stack_releases_publish_idempotency.sql."
+    );
+  }
+}
+async function insertStackRelease(db, validated) {
+  await assertVersionUniqueIndex(db);
+  const inserted = await db.query(
+    `INSERT INTO billing.stack_releases (version, manifest, manifest_sha256, status, released_at, created_by)
+     VALUES ($1, $2::jsonb, $3, $4, now(), $5)
+     ON CONFLICT (version) DO NOTHING
+     RETURNING version`,
+    [validated.version, validated.rawManifest, validated.manifestSha256, validated.status, validated.createdBy]
+  );
+  if (inserted.rows.length === 1) {
+    return {
+      outcome: "published",
+      version: validated.version,
+      manifestSha256: validated.manifestSha256,
+      status: validated.status
+    };
+  }
+  const existing = await db.query(
+    "SELECT manifest_sha256, status FROM billing.stack_releases WHERE version = $1",
+    [validated.version]
+  );
+  const row = existing.rows[0];
+  if (!row) {
+    throw reject(
+      409,
+      "publish_race",
+      `version ${validated.version} conflicted on insert but no row exists. Concurrent mutation of billing.stack_releases \u2014 re-run the release.`
+    );
+  }
+  const existingSha = String(row.manifest_sha256 ?? "");
+  const existingStatus = String(row.status ?? "");
+  if (existingSha === validated.manifestSha256 && existingStatus === validated.status) {
+    return {
+      outcome: "already-published",
+      version: validated.version,
+      manifestSha256: validated.manifestSha256,
+      status: validated.status
+    };
+  }
+  throw reject(
+    409,
+    "version_already_published_with_different_content",
+    `stack version ${validated.version} is already published (sha256 ${existingSha || "<none>"}, status ${existingStatus || "<none>"}) and does not match this publish (sha256 ${validated.manifestSha256}, status ${validated.status}). Published releases are immutable. Cut a new stack version instead of rewriting a shipped one.`
+  );
+}
+async function publishStackRelease(db, body, options) {
+  const validated = validatePublishBody(body);
+  assertDeclaredSha(validated, body.manifestSha256);
+  await assertManifestSignature(validated.manifest, options.publicKeyPem);
+  return insertStackRelease(db, validated);
+}
+
+// src/lib/registry-proxy.ts
 function parsePullTokens(raw) {
   return (raw ?? "").split(/[\n,]/).map((s) => s.trim()).filter(Boolean);
 }
@@ -16,9 +245,25 @@ function registryProxyOptionsFromEnv(env = process.env) {
     pullTokens,
     allowedNamespace: env.EXE_REGISTRY_PROXY_ALLOWED_NAMESPACE || "askexe",
     licenseValidatorUrl: env.EXE_REGISTRY_PROXY_LICENSE_VALIDATOR_URL || "https://api.askexe.com/v1/license/validate",
-    databaseUrl: env.EXE_REGISTRY_PROXY_DATABASE_URL || env.DATABASE_URL || void 0
+    databaseUrl: env.EXE_REGISTRY_PROXY_DATABASE_URL || env.DATABASE_URL || void 0,
+    publisherTokens: parsePublisherTokens(env.EXE_REGISTRY_PROXY_PUBLISHER_TOKENS),
+    stackPublicKeyPem: readStackPublicKey(env)
   };
 }
+function readStackPublicKey(env) {
+  if (env.EXE_STACK_PUBLIC_KEY) return env.EXE_STACK_PUBLIC_KEY;
+  if (env.EXE_STACK_PUBLIC_KEY_FILE) {
+    try {
+      return readFileSync(env.EXE_STACK_PUBLIC_KEY_FILE, "utf8");
+    } catch (err) {
+      console.error(
+        `[registry-proxy] EXE_STACK_PUBLIC_KEY_FILE unreadable (${err instanceof Error ? err.message : String(err)}) \u2014 publish endpoint will refuse every request until this is fixed.`
+      );
+      return void 0;
+    }
+  }
+  return void 0;
+}
 function assertRegistryProxyConfig(options) {
   if (!options.upstreamToken) throw new Error("EXE_REGISTRY_PROXY_UPSTREAM_TOKEN or GHCR_TOKEN is required");
   if (options.pullTokens.length === 0 && !options.licenseValidatorUrl) {
@@ -73,6 +318,7 @@ function unauthorized(res) {
   res.end(JSON.stringify({ error: "registry proxy authentication required" }));
 }
 var READ_ONLY_METHODS = ["GET", "HEAD"];
+var STACK_RELEASE_PUBLISH_PATH = "/v1/stack-releases";
 function isReadOnlyRegistryMethod(method) {
   return readOnlyRegistryMethod(method) !== null;
 }
@@ -80,9 +326,9 @@ function readOnlyRegistryMethod(method) {
   const normalized = (method ?? "").toUpperCase();
   return normalized === "GET" || normalized === "HEAD" ? normalized : null;
 }
-function methodNotAllowed(res, method) {
+function methodNotAllowed(res, method, allow = READ_ONLY_METHODS) {
   res.writeHead(405, {
-    allow: READ_ONLY_METHODS.join(", "),
+    allow: allow.join(", "),
     "content-type": "application/json"
   });
   res.end(
@@ -156,6 +402,9 @@ function classifyRegistryProxyRequest(req, namespace) {
   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_PUBLISH_PATH) {
+    return (req.method ?? "").toUpperCase() === "POST" ? { kind: "stack-release-publish", url } : { kind: "method-not-allowed", method: req.method, url, allow: ["POST"] };
+  }
   const pathKind = classifyRegistryPath(url.pathname, namespace);
   if (pathKind === "read") {
     return method ? { kind: "registry-read", method, url } : { kind: "method-not-allowed", method: req.method, url };
@@ -283,13 +532,92 @@ function createRegistryProxyServer(options) {
       res.end(JSON.stringify({ error: "stack manifest query failed" }));
     }
   }
+  async function readJsonBody(req, maxBytes) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+      const buf = chunk;
+      total += buf.length;
+      if (total > maxBytes) {
+        req.destroy();
+        throw new StackReleasePublishError({
+          httpStatus: 413,
+          code: "body_too_large",
+          detail: `request body exceeds ${maxBytes} bytes`
+        });
+      }
+      chunks.push(buf);
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    try {
+      return JSON.parse(raw);
+    } catch (err) {
+      throw new StackReleasePublishError({
+        httpStatus: 400,
+        code: "body_unparseable",
+        detail: `request body is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async function handleStackReleasePublish(req, res) {
+    const publisherTokens = options.publisherTokens ?? [];
+    const token = parseBearerToken(req.headers.authorization);
+    if (publisherTokens.length === 0) {
+      console.error(
+        "[registry-proxy] publish 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 publish: 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, MAX_MANIFEST_BYTES + 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 publishStackRelease(pool, body, { publicKeyPem: options.stackPublicKeyPem });
+      console.log(
+        `[registry-proxy] stack release ${result.version} ${result.outcome} (status=${result.status}, manifest_sha256=${result.manifestSha256}).`
+      );
+      res.writeHead(result.outcome === "published" ? 201 : 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 publish 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 publish FAILED: ${detail}`);
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "stack release publish failed", code: "publish_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.`
       );
-      methodNotAllowed(res, req.method);
+      methodNotAllowed(res, req.method, route.allow);
       return;
     }
     if (route.kind === "not-found") {
@@ -305,6 +633,10 @@ function createRegistryProxyServer(options) {
       await handleStackManifest(req, res);
       return;
     }
+    if (route.kind === "stack-release-publish") {
+      await handleStackReleasePublish(req, res);
+      return;
+    }
     const auth = parseBasicAuth(req.headers.authorization);
     if (!auth) {
       unauthorized(res);
@@ -351,7 +683,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-JVG5KNIY.js");
+  const { licenseSyncConfigFromEnv, startLicenseSyncScheduler } = await import("./license-sync-5VYS2F2W.js");
   const syncConfig = licenseSyncConfigFromEnv();
   if (syncConfig) {
     startLicenseSyncScheduler(syncConfig);
@@ -365,6 +697,7 @@ export {
   parsePullTokens,
   registryProxyOptionsFromEnv,
   assertRegistryProxyConfig,
+  STACK_RELEASE_PUBLISH_PATH,
   isReadOnlyRegistryMethod,
   createRegistryProxyServer,
   runRegistryProxy

package/dist/{chunk-WAEKYKTK.js → chunk-6RKKVPYF.js}

@@ -1,6 +1,6 @@
 import {
   loadEmployees
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 
 // src/lib/agent-symlinks.ts
 import os from "os";

package/dist/{chunk-VX2F4ZUY.js → chunk-6SCGLHJ7.js}

@@ -4,13 +4,13 @@ import {
 } from "./chunk-A6PDF4BO.js";
 import {
   registerDaemonScopedQueryChokepoint
-} from "./chunk-YFCNWQAM.js";
+} from "./chunk-DJOIMFKV.js";
 import {
   orgPartnerModeActive,
   resolveOrgPartnerBindings,
   resolvePartnerIdentities,
   rosterKeyLookupFor
-} from "./chunk-PVEM537A.js";
+} from "./chunk-4YLBKEL5.js";
 import {
   createMailboxOpener,
   createMemorySeqStore,
@@ -19,7 +19,7 @@ import {
   isConsentMacPrimed,
   primeTaskOriginMarkerKey,
   scopedQueryChokepointStatus
-} from "./chunk-RUVO3NJC.js";
+} from "./chunk-IN6CAM4F.js";
 import {
   flushMailboxOutbox
 } from "./chunk-4LWBC7CM.js";

package/dist/{chunk-MEGRQ53A.js → chunk-6VHOQ3IM.js}

@@ -3,23 +3,26 @@ import {
 } from "./chunk-HSFBNCNC.js";
 import {
   behaviorTruncationNotice
-} from "./chunk-ELXFSIIM.js";
+} from "./chunk-32YV32VA.js";
 import {
   countActiveBehaviors,
   listBehaviors
-} from "./chunk-MBNIJXKI.js";
+} from "./chunk-WMEYJT4R.js";
 import {
   lightweightSearch
-} from "./chunk-ZXB56YR2.js";
+} from "./chunk-TFKCERAK.js";
 import {
   getCurrentSessionScope
-} from "./chunk-XHYHX6F7.js";
+} from "./chunk-AKLQSC6W.js";
+import {
+  getSessionKey
+} from "./chunk-CVYC6DUW.js";
 import {
   getProjectName
-} from "./chunk-W2IRQJ6R.js";
+} from "./chunk-JTVIANUB.js";
 import {
   getClient
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 
 // src/lib/session-summary.ts
 var MAX_CHARS = 800;
@@ -145,6 +148,34 @@ function compressCheckpoint(rawText) {
   return result;
 }
 
+// src/lib/session-scratch.ts
+import { mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+function sanitizeSegment(s) {
+  return s.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 64);
+}
+function sanitizeSessionKey(sessionKey) {
+  return sanitizeSegment(sessionKey) || `unknown-${process.pid}`;
+}
+function sessionScratchDir(sessionKey, homeDir = os.homedir(), agentId) {
+  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;
+}
+function resolveSessionScratchDir(homeDir = os.homedir(), agentId) {
+  return sessionScratchDir(getSessionKey(), homeDir, agentId);
+}
+function ensureSessionScratchDir(sessionKey, homeDir = os.homedir(), agentId) {
+  const dir = sessionKey === void 0 ? resolveSessionScratchDir(homeDir, agentId) : sessionScratchDir(sessionKey, homeDir, agentId);
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+  return dir;
+}
+
 // src/lib/employee-boot-brief.ts
 var SECTION_TIMEOUT_MS = 4e3;
 var BRIEF_TIMEOUT_MS = 6e3;
@@ -296,6 +327,12 @@ async function buildEmployeeBootBriefInner(input, degraded) {
     runSection("memories", () => recentProjectMemories(agentId, projectName, sessionScope ?? null, input.mode), "", degraded),
     runSection("behaviors", () => activeBehaviorBrief(agentId, projectName), "", degraded)
   ]);
+  let scratchDir = "";
+  try {
+    scratchDir = ensureSessionScratchDir(void 0, void 0, agentId);
+  } catch {
+    scratchDir = "";
+  }
   const sections = [];
   if (input.mode === "subagent") {
     sections.push(`## Employee Memory Brief
@@ -305,6 +342,14 @@ Bound roster employee: **${agentId}**. Project: ${projectName}.`);
 ${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"));
+  }
   if (memories) sections.push(`## Memory Brief
 Recent memories from this project:
 ${memories}`);

package/dist/{chunk-HIIXCAEE.js → chunk-6YVUR3OU.js}

@@ -3,18 +3,18 @@ import {
   getClient,
   isInitialized,
   loadEmployees
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 import {
   checkLicense,
   isFeatureAllowed,
   isPersonalFreeGrandfathered
-} from "./chunk-DKBPCOU4.js";
+} from "./chunk-L6RXG36J.js";
 import {
   PLAN_LIMITS
 } from "./chunk-A7XLR3K7.js";
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/plan-limits.ts
 import { readFileSync, existsSync } from "fs";

package/dist/{chunk-L6ZNURWN.js → chunk-7GE2EQ23.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 
 // src/lib/skill-refinement.ts
 import crypto from "crypto";

package/dist/{chunk-2CWS374F.js → chunk-7RI2CNXJ.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/branding.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";

package/dist/{chunk-OL3QP3AU.js → chunk-7TSBV3SD.js}

@@ -6,7 +6,7 @@ import {
 import {
   CANONICAL_SSO_COOKIE,
   evaluateSsoCookieContract
-} from "./chunk-TCTED52S.js";
+} from "./chunk-FTZET5YX.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";