agentlas 0.7.0 → 0.9.1

package/engine/agentlas-experience-exchange.cjs

@@ -30,6 +30,64 @@ const EXPERIENCE_RETRIEVAL_MAX_ITEMS = 8;
 const EXPERIENCE_RETRIEVAL_MAX_TOKENS = 800;
 const EXCHANGE_LOCK_STALE_MS = 30_000;
 const EXCHANGE_LOCK_WAIT_MS = 2_000;
+const EXPERIENCE_TAXONOMY_PATH = path.join(__dirname, "experience-taxonomy-v1.json");
+const EXPERIENCE_TAXONOMY_CHECKSUM = "sha256:413833472e423352518f9591cd0e051c5bc0a7971e53ab3dc7b5aaf7d50c37ab";
+
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const child of Object.values(value)) deepFreeze(child);
+  return value;
+}
+
+function validateExperienceTaxonomyContract(value) {
+  const issues = [];
+  if (!value || typeof value !== "object" || Array.isArray(value)) issues.push("taxonomy must be an object");
+  else {
+    if (value.schema !== "agentlas.experience-taxonomy.v1") issues.push("taxonomy schema drifted");
+    if (value.kind !== "agentlas-experience-taxonomy") issues.push("taxonomy kind drifted");
+    if (value.taskSignaturePrefix !== "agentlas.task.v1/") issues.push("taxonomy task prefix drifted");
+    if (!Array.isArray(value.taskSlugs) || value.taskSlugs.length !== 23 || value.taskSlugs.includes("general")) issues.push("taxonomy task catalog drifted");
+    const environment = value.environment;
+    if (
+      !environment || environment.osPrefix !== "agentlas.env.v1/os/" ||
+      environment.archPrefix !== "agentlas.env.v1/arch/" || environment.runtimePrefix !== "agentlas.env.v1/runtime/" ||
+      JSON.stringify(environment.osValues) !== JSON.stringify(["macos", "windows", "linux", "ios", "android", "unknown"]) ||
+      JSON.stringify(environment.archValues) !== JSON.stringify(["arm64", "x64", "unknown"]) ||
+      environment.runtimePattern !== "^[a-z0-9][a-z0-9._-]{1,63}$" ||
+      environment.matching !== "all-canonical-constraints-must-match" ||
+      environment.unknownConstraint !== "item-ineligible-base-unaffected"
+    ) issues.push("taxonomy environment contract drifted");
+    const normalization = value.normalization;
+    if (
+      !normalization || normalization.unicode !== "NFKC" || normalization.trim !== true || normalization.case !== "lower" ||
+      normalization.portableSource !== "canonical-id-only" || normalization.runtimeProfile !== "canonical-id-or-exact-bare-slug" ||
+      normalization.fuzzySimilarity !== false || normalization.generalAutoMatch !== false
+    ) issues.push("taxonomy normalization contract drifted");
+    const checksum = `sha256:${crypto.createHash("sha256").update(canonicalJson(value), "utf8").digest("hex")}`;
+    if (checksum !== EXPERIENCE_TAXONOMY_CHECKSUM) issues.push("taxonomy checksum drifted");
+  }
+  if (issues.length) {
+    const error = new Error(issues.join("; "));
+    error.code = "experience_taxonomy_drift";
+    error.issues = issues;
+    throw error;
+  }
+  return deepFreeze(JSON.parse(canonicalJson(value)));
+}
+
+function loadExperienceTaxonomyContract() {
+  const stat = fs.lstatSync(EXPERIENCE_TAXONOMY_PATH);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 64 * 1024) throw new Error("Experience taxonomy artifact is unsafe");
+  return validateExperienceTaxonomyContract(JSON.parse(fs.readFileSync(EXPERIENCE_TAXONOMY_PATH, "utf8")));
+}
+
+const OFFICIAL_EXPERIENCE_CLOUD_HOSTS = new Set([
+  "agentlas.cloud",
+  "www.agentlas.cloud",
+  "api.agentlas.cloud",
+  "staging.agentlas.cloud",
+]);
 
 const ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:/@-]{2,255}$/;
 const HASH_RE = /^sha256:[0-9a-f]{64}$/;
@@ -54,9 +112,7 @@ const PII_PATTERNS = [
   /\b(?:account|customer|client|tenant|workspace|user)[ _-]?(?:id|key|number|no)\s*[:=#]?\s*[A-Za-z0-9_-]{4,}\b|(?:계정|고객|사용자)[ _-]?(?:id|아이디|번호)\s*[:=#]?\s*[A-Za-z0-9_-]{4,}/i,
 ];
 const LOCAL_PATH_PATTERNS = [
-  /(?:file:\/\/|\/(?:Users|home|private|Volumes|var\/folders)\/)/i,
-  /\b[A-Za-z]:\\(?:Users|Documents|Desktop|Downloads)\\/i,
-  /(?:^|[\s'"`])~\/(?:Desktop|Documents|Downloads|Library|\.ssh|\.config)\//i,
+  /(?:file:\/\/|(?:^|[\s"'`()\[\]{}=:,;])(?:\.\.[/\\]|~[/\\]|\/(?!\/|\s)(?:[^/\s"'`<>]+\/)*[^/\s"'`<>]+|[A-Za-z]:[/\\]\S+|\\\\[^\\/\s]+[\\/][^\\/\s]+))/i,
 ];
 const RAW_INTERACTION_PATTERNS = [
   /(?:^|\n)\s*(?:system|assistant|user|tool|customer|agent)\s*:\s+/i,
@@ -77,6 +133,8 @@ const BASE_PACKAGE_PATTERNS = [
   /\bBEGIN AGENTLAS (?:AGENT|PACKAGE)\b/i,
 ];
 const OPAQUE_BLOB_RE = /(?:[A-Fa-f0-9]{128,}|[A-Za-z0-9+/]{124,}={0,2})/;
+const PUBLIC_URL_RE = /\bhttps?:\/\/[^\s<>"']+/i;
+const CUSTOMER_DATA_RE = /\b(?:customer|client|tenant|account|workspace|order|invoice)[ _-]?(?:name|email|address|phone|id|number|ref(?:erence)?)\s*[:=#]\s*\S+|(?:고객|클라이언트|계정|주문|송장)[ _-]?(?:이름|이메일|주소|전화|아이디|번호|참조)\s*[:=#]\s*\S+/i;
 const FORBIDDEN_KEYS = new Set([
   "basepackage", "basepackagefiles", "baseprompt", "cloudpackage", "contentbase64",
   "files", "fulltranscript", "rawsource", "systemprompt", "transcript", "messages",
@@ -118,7 +176,8 @@ function normalizeJson(value, seen = new Set()) {
     seen.delete(value);
     return result;
   }
-  if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
+  const prototype = value && typeof value === "object" ? Object.getPrototypeOf(value) : undefined;
+  if (!value || typeof value !== "object" || (prototype !== Object.prototype && prototype !== null)) {
     throw new ExperienceBundleValidationError([`canonical JSON forbids ${typeof value}`]);
   }
   if (seen.has(value)) throw new ExperienceBundleValidationError(["canonical JSON forbids cyclic values"]);
@@ -153,6 +212,18 @@ function canonicalHash(value) {
   return `sha256:${crypto.createHash("sha256").update(canonicalJson(value), "utf8").digest("hex")}`;
 }
 
+// Load the frozen activation taxonomy only after the canonical JSON machinery
+// and its error type have initialized. Any artifact drift stops startup.
+const EXPERIENCE_TAXONOMY_V1 = loadExperienceTaxonomyContract();
+const CANONICAL_TASK_PREFIX = EXPERIENCE_TAXONOMY_V1.taskSignaturePrefix;
+const CANONICAL_ENV_PREFIX = "agentlas.env.v1/";
+const CANONICAL_TASK_SLUGS = Object.freeze([...EXPERIENCE_TAXONOMY_V1.taskSlugs]);
+const CANONICAL_TASK_IDS = Object.freeze(CANONICAL_TASK_SLUGS.map((slug) => `${CANONICAL_TASK_PREFIX}${slug}`));
+const CANONICAL_TASK_ID_SET = new Set(CANONICAL_TASK_IDS);
+const CANONICAL_OS_VALUES = new Set(EXPERIENCE_TAXONOMY_V1.environment.osValues);
+const CANONICAL_ARCH_VALUES = new Set(EXPERIENCE_TAXONOMY_V1.environment.archValues);
+const CANONICAL_RUNTIME_RE = new RegExp(EXPERIENCE_TAXONOMY_V1.environment.runtimePattern);
+
 function sortedUnique(values) {
   const byCanonical = new Map();
   for (const value of values || []) byCanonical.set(canonicalJson(value), value);
@@ -321,8 +392,12 @@ function validateCredentialMetadata(value, label, issues) {
     const scopes = checkStringList(data.scopes, `${label}.scopes`, 1, 64, issues);
     scopes.forEach((scope, index) => { if (!/^[A-Za-z0-9][A-Za-z0-9._:/@-]{0,127}$/.test(scope)) issues.push(`${label}.scopes[${index}] is invalid`); });
   }
-  if (data.setupUrl != null && !/^https:\/\/[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*(?:\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]*)?$/.test(data.setupUrl)) {
-    issues.push(`${label}.setupUrl must be a value-free HTTPS provider page`);
+  if (data.setupUrl != null && (
+    typeof data.setupUrl !== "string" ||
+    data.setupUrl.length > 2048 ||
+    !/^https:\/\/[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*(?:\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]*)?$/.test(data.setupUrl)
+  )) {
+    issues.push(`${label}.setupUrl must be a value-free HTTPS provider page of at most 2048 characters`);
   }
   if (data.brokerMode != null && !["host-bound-broker", "runtime-env-injection", "provider-managed-oauth", "manual-provider-page"].includes(data.brokerMode)) {
     issues.push(`${label}.brokerMode is invalid`);
@@ -337,9 +412,9 @@ function validateMcpRequirement(value, label, issues) {
   checkId(data.requirementId, `${label}.requirementId`, issues);
   checkId(data.catalogId, `${label}.catalogId`, issues);
   checkString(data.reason, `${label}.reason`, 1, 300, issues);
-  checkStringList(data.capabilities, `${label}.capabilities`, 1, null, issues, { ids: true });
-  checkStringList(data.permissions, `${label}.permissions`, 0, null, issues, { ids: true });
-  const alternatives = checkStringList(data.alternatives, `${label}.alternatives`, 0, null, issues, { ids: true });
+  checkStringList(data.capabilities, `${label}.capabilities`, 1, 32, issues, { ids: true });
+  checkStringList(data.permissions, `${label}.permissions`, 0, 64, issues, { ids: true });
+  const alternatives = checkStringList(data.alternatives, `${label}.alternatives`, 0, 32, issues, { ids: true });
   if (alternatives.includes(data.catalogId)) issues.push(`${label}.alternatives must not contain catalogId`);
   if (typeof data.required !== "boolean" || typeof data.requiresKey !== "boolean") issues.push(`${label}.required/requiresKey must be boolean`);
   if (!Number.isInteger(data.priority) || data.priority < 1 || data.priority > 1000) issues.push(`${label}.priority must be 1..1000`);
@@ -386,8 +461,11 @@ function validateItem(item, index, issues) {
   checkString(data.summary, `${label}.summary`, 1, 320, issues);
   if (!Array.isArray(data.instructions) || data.instructions.length < 1 || data.instructions.length > MAX_INSTRUCTIONS_PER_ITEM) issues.push(`${label}.instructions must contain 1..${MAX_INSTRUCTIONS_PER_ITEM} values`);
   else data.instructions.forEach((step, stepIndex) => checkString(step, `${label}.instructions[${stepIndex}]`, 1, 600, issues));
-  checkStringList(data.taskSignatures, `${label}.taskSignatures`, 1, MAX_TASK_SIGNATURES_PER_ITEM, issues);
-  checkStringList(data.environmentConstraints, `${label}.environmentConstraints`, 0, 32, issues);
+  checkStringList(data.taskSignatures, `${label}.taskSignatures`, 1, MAX_TASK_SIGNATURES_PER_ITEM, issues, { ids: true });
+  const environmentConstraints = checkStringList(data.environmentConstraints, `${label}.environmentConstraints`, 0, 32, issues);
+  environmentConstraints.forEach((constraint, constraintIndex) => {
+    if (constraint.length > 240) issues.push(`${label}.environmentConstraints[${constraintIndex}] must be at most 240 characters`);
+  });
   checkStringList(data.evidenceReceiptIds, `${label}.evidenceReceiptIds`, 1, MAX_EVIDENCE_REFS_PER_ITEM, issues, { ids: true });
   checkStringList(data.supersedesItemIds, `${label}.supersedesItemIds`, 0, MAX_STORED_ITEMS, issues, { ids: true });
   if (typeof data.confidence !== "number" || !Number.isFinite(data.confidence) || data.confidence < 0 || data.confidence > 1) issues.push(`${label}.confidence must be 0..1`);
@@ -431,6 +509,38 @@ function validateBundleSecurity(value, issues) {
   if (nonMetadata.some((text) => OPAQUE_BLOB_RE.test(text))) issues.push("ExperienceBundle contains a long opaque encoded blob");
 }
 
+/**
+ * Value-free privacy classification used before a successful run can become a
+ * local Operational Experience candidate. It deliberately returns only codes;
+ * unsafe source text is never copied into an intake receipt or bundle.
+ */
+function portableExperienceSafetyIssues(text) {
+  const variants = [String(text || "")];
+  let current = variants[0];
+  for (let index = 0; index < 3; index += 1) {
+    try {
+      const decoded = decodeURIComponent(current);
+      if (decoded === current) break;
+      variants.push(decoded);
+      current = decoded;
+    } catch { break; }
+  }
+  const codes = [];
+  const hit = (patterns, code) => {
+    if (patterns.some((pattern) => variants.some((value) => pattern.test(value)))) codes.push(code);
+  };
+  hit(SECRET_PATTERNS, "secret-or-credential");
+  hit(PII_PATTERNS, "personal-or-customer-identifier");
+  hit(LOCAL_PATH_PATTERNS, "local-path");
+  hit(RAW_INTERACTION_PATTERNS, "raw-prompt-or-transcript");
+  hit(PROMPT_INJECTION_PATTERNS, "prompt-injection-material");
+  hit(BASE_PACKAGE_PATTERNS, "base-package-material");
+  if (variants.some((value) => PUBLIC_URL_RE.test(value))) codes.push("url");
+  if (variants.some((value) => CUSTOMER_DATA_RE.test(value))) codes.push("customer-data");
+  if (variants.some((value) => OPAQUE_BLOB_RE.test(value))) codes.push("opaque-blob");
+  return [...new Set(codes)].sort(compareCodePoints);
+}
+
 function validateExperienceBundle(payload) {
   const value = normalizeExperienceBundle(payload);
   const issues = [];
@@ -574,6 +684,42 @@ function writePrivateTextAtomic(filePath, text) {
   }
 }
 
+function readPrivateFileSnapshot(filePath) {
+  recoverPrivateAtomicTarget(filePath);
+  if (!fs.existsSync(filePath)) return { exists: false, bytes: null };
+  const stat = fs.lstatSync(filePath);
+  if (!stat.isFile() || stat.isSymbolicLink()) throw new Error("private transaction target is unsafe");
+  return { exists: true, bytes: fs.readFileSync(filePath) };
+}
+
+function writePrivateBufferAtomic(filePath, bytes) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(dir, 0o700); } catch { /* best effort */ }
+  const temp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.rollback.tmp`);
+  try {
+    fs.writeFileSync(temp, bytes, { mode: 0o600, flag: "wx" });
+    replacePrivateFileAtomic(temp, filePath);
+    try { fs.chmodSync(filePath, 0o600); } catch { /* best effort */ }
+  } finally {
+    try { fs.rmSync(temp, { force: true }); } catch { /* noop */ }
+  }
+}
+
+function restorePrivateFileSnapshot(filePath, snapshot) {
+  recoverPrivateAtomicTarget(filePath);
+  if (snapshot.exists) {
+    writePrivateBufferAtomic(filePath, snapshot.bytes);
+    return;
+  }
+  if (fs.existsSync(filePath)) {
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink()) throw new Error("private rollback target is unsafe");
+    fs.rmSync(filePath, { force: true });
+  }
+  try { fs.rmSync(`${filePath}.previous`, { force: true }); } catch { /* noop */ }
+}
+
 function exchangeStatePath(userDataDir) {
   return path.join(userDataDir, "terminal", "experience-exchange-v1.json");
 }
@@ -696,11 +842,13 @@ function projectScopeHash(cwd) {
   return canonicalHash({ kind: "terminal-project-scope", path: resolved.normalize("NFC") });
 }
 
-function saveLocalBundle(userDataDir, validation, options = {}) {
+function commitLocalBundleRecord(userDataDir, validation, options = {}) {
   const bundle = validation.bundle;
   return withExchangeStateLock(userDataDir, () => {
     const storedPath = bundleStorePath(userDataDir, bundle.bundleId);
-    writePrivateTextAtomic(storedPath, validation.canonicalJson);
+    const statePath = exchangeStatePath(userDataDir);
+    const storedSnapshot = readPrivateFileSnapshot(storedPath);
+    const stateSnapshot = readPrivateFileSnapshot(statePath);
     const state = loadExchangeState(userDataDir);
     const now = new Date().toISOString();
     const previous = state.bundles.find((row) => row.bundleId === bundle.bundleId);
@@ -713,16 +861,31 @@ function saveLocalBundle(userDataDir, validation, options = {}) {
       compatibleBaseReleaseIds: [...bundle.pack.baseCompatibility.compatibleBaseReleaseIds],
       projectScopeHash: projectScopeHash(options.cwd),
       storedAt: now,
-      remote: previous?.remote || null,
+      remote: Object.prototype.hasOwnProperty.call(options, "remote") ? options.remote : previous?.remote || null,
     };
     const index = state.bundles.findIndex((item) => item.bundleId === row.bundleId);
     if (index >= 0) state.bundles[index] = row;
     else state.bundles.push(row);
-    saveExchangeState(userDataDir, state);
-    return row;
+    try {
+      writePrivateTextAtomic(storedPath, validation.canonicalJson);
+      saveExchangeState(userDataDir, state);
+      return row;
+    } catch (error) {
+      const rollbackErrors = [];
+      for (const [filePath, snapshot] of [[storedPath, storedSnapshot], [statePath, stateSnapshot]]) {
+        try { restorePrivateFileSnapshot(filePath, snapshot); }
+        catch (rollbackError) { rollbackErrors.push(rollbackError); }
+      }
+      if (rollbackErrors.length) error.rollbackErrors = rollbackErrors;
+      throw error;
+    }
   });
 }
 
+function saveLocalBundle(userDataDir, validation, options = {}) {
+  return commitLocalBundleRecord(userDataDir, validation, options);
+}
+
 function readStoredBundle(userDataDir, bundleId) {
   const file = bundleStorePath(userDataDir, bundleId);
   recoverPrivateAtomicTarget(file);
@@ -777,9 +940,8 @@ function trustedExperienceOrigin(rawValue, options = {}) {
       throw new Error("Loopback Experience Web origin requires explicit AGENTLAS_EXPERIENCE_ALLOW_LOOPBACK=1 opt-in");
     }
   } else {
-    const agentlasHost = hostname === "agentlas.cloud" || hostname.endsWith(".agentlas.cloud");
-    if (parsed.protocol !== "https:" || !agentlasHost || (parsed.port && parsed.port !== "443")) {
-      throw new Error("Authenticated Experience exchange is restricted to an HTTPS Agentlas origin");
+    if (parsed.protocol !== "https:" || !OFFICIAL_EXPERIENCE_CLOUD_HOSTS.has(hostname) || (parsed.port && parsed.port !== "443")) {
+      throw new Error("Authenticated Experience exchange is restricted to an explicitly approved HTTPS Agentlas origin");
     }
   }
   return parsed.origin;
@@ -792,9 +954,16 @@ function parseResponseJson(response, label) {
 function responseError(response, label) {
   let data = null;
   try { data = JSON.parse(response.text || "null"); } catch { /* generic below */ }
-  const error = new Error(`${label} failed (${response.status})${data?.error ? `: ${String(data.error).slice(0, 300)}` : ""}`);
+  const serverCode = [data?.errorCode, data?.code, data?.error]
+    .find((value) => typeof value === "string" && /^[a-z0-9][a-z0-9._-]{0,95}$/.test(value));
+  const detail = typeof data?.message === "string"
+    ? data.message
+    : typeof data?.error === "string"
+      ? data.error
+      : "";
+  const error = new Error(`${label} failed (${response.status})${detail ? `: ${detail.slice(0, 300)}` : ""}`);
   error.status = response.status;
-  error.code = data?.code || (response.status === 401 || response.status === 403 ? "authentication_refused" : "experience_exchange_failed");
+  error.code = serverCode || (response.status === 401 || response.status === 403 ? "authentication_refused" : "experience_exchange_failed");
   error.details = data;
   return error;
 }
@@ -916,21 +1085,47 @@ function validateUploadReceipt(receipt, bundle) {
   };
 }
 
+function remoteProjection(receipt, baseResolution = null, previousRemote = null) {
+  return {
+    uploadId: receipt.uploadId,
+    status: receipt.status,
+    requestedVisibility: receipt.requestedVisibility,
+    revision: receipt.revision,
+    serverCheckedAt: new Date().toISOString(),
+    receipt,
+    ...(baseResolution ? { baseResolution } : previousRemote?.baseResolution ? { baseResolution: previousRemote.baseResolution } : {}),
+  };
+}
+
+function commitServerAcceptedBundle(userDataDir, validation, receipt, baseResolution, options = {}) {
+  const bundle = validation.bundle;
+  try {
+    const state = loadExchangeState(userDataDir);
+    const previous = state.bundles.find((row) => row.bundleId === bundle.bundleId);
+    return commitLocalBundleRecord(userDataDir, validation, {
+      cwd: options.cwd,
+      remote: remoteProjection(receipt, baseResolution, previous?.remote || null),
+    });
+  } catch (error) {
+    const stateError = new Error(
+      `Experience was accepted by the server as ${receipt.uploadId}, but Terminal could not atomically commit the canonical bundle and authoritative receipt. ` +
+      "The prior local bundle/state were restored; rerun the same command and Idempotency-Key to reconcile the same receipt.",
+    );
+    stateError.code = "AGENTLAS_EXPERIENCE_LOCAL_STATE_COMMIT_FAILED";
+    stateError.receipt = receipt;
+    stateError.bundleId = bundle.bundleId;
+    stateError.cause = error;
+    throw stateError;
+  }
+}
+
 function persistRemoteReceipt(userDataDir, bundle, receipt, baseResolution = null) {
   try {
     return withExchangeStateLock(userDataDir, () => {
       const state = loadExchangeState(userDataDir);
       const row = state.bundles.find((item) => item.bundleId === bundle.bundleId);
       if (!row) throw new Error("local bundle record disappeared before receipt persistence");
-      row.remote = {
-        uploadId: receipt.uploadId,
-        status: receipt.status,
-        requestedVisibility: receipt.requestedVisibility,
-        revision: receipt.revision,
-        serverCheckedAt: new Date().toISOString(),
-        receipt,
-        ...(baseResolution ? { baseResolution } : row.remote?.baseResolution ? { baseResolution: row.remote.baseResolution } : {}),
-      };
+      row.remote = remoteProjection(receipt, baseResolution, row.remote);
       saveExchangeState(userDataDir, state);
       return row;
     });
@@ -990,8 +1185,10 @@ async function publishBundle(validation, options = {}) {
   const existingState = loadExchangeState(options.userDataDir);
   const existingRow = findStateRecord(existingState, bundle.bundleId);
   const exactBaseDescriptor = normalizeBaseDescriptor(options, existingRow?.remote?.baseResolution);
-  const savedRow = saveLocalBundle(options.userDataDir, normalizedValidation, { cwd: options.cwd });
-  const baseRelease = await resolveBaseRelease(bundle, { ...options, baseDescriptor: exactBaseDescriptor }, auth, savedRow.remote?.baseResolution);
+  // Preflight and server acceptance happen before the canonical local envelope
+  // is changed. A failed promotion must leave the prior private file/state
+  // byte-identical instead of pairing a public envelope with an old receipt.
+  const baseRelease = await resolveBaseRelease(bundle, { ...options, baseDescriptor: exactBaseDescriptor }, auth, existingRow?.remote?.baseResolution);
   let response;
   try {
     response = await options.fetchHub(`${auth.base}/uploads`, {
@@ -1001,7 +1198,7 @@ async function publishBundle(validation, options = {}) {
     });
   } catch (error) {
     const recovered = await recoverLostUpload(bundle, key, options, auth, error);
-    persistRemoteReceipt(options.userDataDir, bundle, recovered.receipt, baseRelease);
+    commitServerAcceptedBundle(options.userDataDir, normalizedValidation, recovered.receipt, baseRelease, { cwd: options.cwd });
     return { ...recovered, dryRun: false, networkUsed: true, baseRelease, publicActivation: false, evaluatorAuthority: false };
   }
   if (!response.ok) throw responseError(response, "Experience draft upload");
@@ -1014,7 +1211,7 @@ async function publishBundle(validation, options = {}) {
   if (receipt.status !== expectedStatus) throw new Error(`Experience ${operation} receipt must be ${expectedStatus}, never ${receipt.status}`);
   const etag = response.headers && typeof response.headers.get === "function" ? response.headers.get("etag") : null;
   if (etag !== `"${receipt.revision}"`) throw new Error("Experience upload ETag does not match the exact receipt revision");
-  persistRemoteReceipt(options.userDataDir, bundle, receipt, baseRelease);
+  commitServerAcceptedBundle(options.userDataDir, normalizedValidation, receipt, baseRelease, { cwd: options.cwd });
   return { receipt, replayed: body.replayed, recovered: false, dryRun: false, networkUsed: true, baseRelease, publicActivation: false, evaluatorAuthority: false };
 }
 
@@ -1023,24 +1220,142 @@ function findStateRecord(state, ref) {
   return matches.sort((a, b) => String(b.storedAt).localeCompare(String(a.storedAt)))[0] || null;
 }
 
+function verifyStoredBundleRow(userDataDir, row) {
+  const validation = readStoredBundle(userDataDir, row.bundleId);
+  const bundle = validation.bundle;
+  const sameIdentity =
+    bundle.bundleId === row.bundleId &&
+    bundle.bundleHash === row.bundleHash &&
+    bundle.pack.experiencePackId === row.experiencePackId &&
+    bundle.pack.releaseId === row.experiencePackReleaseId &&
+    bundle.pack.baseCompatibility.agentDefinitionId === row.agentDefinitionId &&
+    canonicalJson(bundle.pack.baseCompatibility.compatibleBaseReleaseIds) === canonicalJson(row.compatibleBaseReleaseIds);
+  if (!sameIdentity) throw new Error("stored Experience bundle identity does not match its private index");
+  if (row.remote) {
+    const receipt = validateUploadReceipt(row.remote.receipt, bundle);
+    if (
+      receipt.uploadId !== row.remote.uploadId ||
+      receipt.status !== row.remote.status ||
+      receipt.requestedVisibility !== row.remote.requestedVisibility ||
+      receipt.revision !== row.remote.revision
+    ) throw new Error("stored Experience server receipt projection drifted from its private index");
+    if (row.remote.baseResolution) {
+      const base = row.remote.baseResolution;
+      if (
+        base.agentDefinitionId !== row.agentDefinitionId ||
+        !row.compatibleBaseReleaseIds.includes(base.agentReleaseId)
+      ) throw new Error("stored Experience exact base resolution drifted from its private index");
+    }
+  }
+  return validation;
+}
+
+function scopedStateRows(userDataDir, cwd) {
+  const scope = projectScopeHash(cwd);
+  return loadExchangeState(userDataDir).bundles
+    .filter((row) => row.projectScopeHash === scope)
+    .sort((a, b) => compareCodePoints(a.experiencePackReleaseId, b.experiencePackReleaseId) || compareCodePoints(a.bundleId, b.bundleId));
+}
+
+function resolveScopedStoredRecord(userDataDir, ref, cwd) {
+  if (!ref) throw new Error("an exact Experience bundle, pack release, or upload reference is required");
+  const matches = scopedStateRows(userDataDir, cwd)
+    .filter((row) => [row.bundleId, row.bundleHash, row.experiencePackId, row.experiencePackReleaseId, row.remote?.uploadId].includes(ref));
+  if (!matches.length) throw new Error(`no exact local Experience record exists for this project: ${ref}`);
+  if (matches.length > 1) throw new Error(`Experience reference is ambiguous; use an exact release, bundle, or upload id: ${ref}`);
+  return { row: matches[0], validation: verifyStoredBundleRow(userDataDir, matches[0]) };
+}
+
+function publicStoredBundleView(row, validation) {
+  const bundle = validation.bundle;
+  const itemStatusCounts = bundle.items.reduce((counts, item) => {
+    counts[item.status] = (counts[item.status] || 0) + 1;
+    return counts;
+  }, { candidate: 0, promoted: 0, deprecated: 0, rejected: 0 });
+  const remote = row.remote
+    ? {
+        uploadId: row.remote.uploadId,
+        status: row.remote.status,
+        requestedVisibility: row.remote.requestedVisibility,
+        revision: row.remote.revision,
+        serverCheckedAt: row.remote.serverCheckedAt,
+        receiptPresent: true,
+        receiptVerified: true,
+        ...(row.remote.baseResolution ? { exactBaseAgentReleaseId: row.remote.baseResolution.agentReleaseId } : {}),
+      }
+    : null;
+  return {
+    schemaVersion: "agentlas.terminal-experience-local-view.v1",
+    bundleId: row.bundleId,
+    bundleHash: row.bundleHash,
+    experiencePackId: row.experiencePackId,
+    experiencePackReleaseId: row.experiencePackReleaseId,
+    agentDefinitionId: row.agentDefinitionId,
+    compatibleBaseReleaseIds: [...row.compatibleBaseReleaseIds],
+    requestedVisibility: bundle.requestedVisibility,
+    itemCount: bundle.items.length,
+    itemStatusCounts,
+    reviewState: itemStatusCounts.candidate > 0 && itemStatusCounts.promoted === 0 ? "candidate-review" : "curated",
+    storedAt: row.storedAt,
+    currentProjectOnly: true,
+    localBundleVerified: true,
+    remote,
+    publicActivationClaimed: false,
+    evaluatorAuthority: false,
+  };
+}
+
+function listStoredExperienceBundles(userDataDir, cwd) {
+  return scopedStateRows(userDataDir, cwd)
+    .map((row) => publicStoredBundleView(row, verifyStoredBundleRow(userDataDir, row)));
+}
+
+function inspectStoredExperienceBundle(userDataDir, ref, cwd) {
+  const { row, validation } = resolveScopedStoredRecord(userDataDir, ref, cwd);
+  return publicStoredBundleView(row, validation);
+}
+
+function previewWithdrawUpload(ref, options = {}) {
+  const { row, validation } = resolveScopedStoredRecord(options.userDataDir, ref, options.cwd);
+  if (!row.remote?.uploadId || !row.remote?.revision || !row.remote?.receipt) {
+    throw new Error("unpublish requires an exact locally observed server receipt; publish or run experience status first");
+  }
+  const receipt = validateUploadReceipt(row.remote.receipt, validation.bundle);
+  if (receipt.status === "withdrawn") throw new Error("Experience upload is already withdrawn");
+  return {
+    schemaVersion: "agentlas.terminal-experience-unpublish-preview.v1",
+    dryRun: true,
+    action: "unpublish",
+    bundleId: row.bundleId,
+    experiencePackReleaseId: row.experiencePackReleaseId,
+    uploadId: receipt.uploadId,
+    currentStatus: receipt.status,
+    ifMatchRevision: receipt.revision,
+    networkUsed: false,
+    localWriteUsed: false,
+    serverReceiptPresent: true,
+    authority: "local-observed-server-receipt",
+    publicActivationClaimed: false,
+  };
+}
+
 async function fetchUploadStatus(ref, options = {}) {
+  const { row, validation } = resolveScopedStoredRecord(options.userDataDir, ref, options.cwd);
+  const uploadId = row.remote?.uploadId;
+  if (!uploadId) throw new Error("no exact server upload receipt is known for this local project bundle");
   const auth = await authenticatedContext(options, false);
-  const state = loadExchangeState(options.userDataDir);
-  const row = findStateRecord(state, ref);
-  const uploadId = UPLOAD_ID_RE.test(String(ref || "")) ? ref : row?.remote?.uploadId;
-  if (!uploadId) throw new Error("no server upload id is known for this local bundle");
   const response = await options.fetchHub(`${auth.base}/uploads/${encodeURIComponent(uploadId)}`, {
     method: "GET",
     headers: { accept: "application/json", cookie: auth.cookie, origin: auth.origin },
   });
   if (!response.ok) throw responseError(response, "Experience upload status");
   const body = parseResponseJson(response, "Experience upload status");
-  const bundle = row ? readStoredBundle(options.userDataDir, row.bundleId).bundle : null;
+  const bundle = validation.bundle;
   const receipt = validateUploadReceipt(body.receipt, bundle);
   if (receipt.uploadId !== uploadId) throw new Error("status receipt id mismatch");
   const etag = response.headers && typeof response.headers.get === "function" ? response.headers.get("etag") : null;
   if (etag !== `"${receipt.revision}"`) throw new Error("status ETag does not match the exact receipt revision");
-  if (row) persistRemoteReceipt(options.userDataDir, bundle, receipt);
+  persistRemoteReceipt(options.userDataDir, bundle, receipt);
   return { receipt, authoritative: "server", publicActivation: false, evaluatorAuthority: false };
 }
 
@@ -1075,10 +1390,9 @@ function writePrivateExportAtomic(filePath, text, overwrite) {
 }
 
 async function fetchUploadExport(ref, options = {}) {
-  const state = loadExchangeState(options.userDataDir);
-  const row = findStateRecord(state, ref);
-  const uploadId = UPLOAD_ID_RE.test(String(ref || "")) ? ref : row?.remote?.uploadId;
-  if (!uploadId) throw new Error("export requires a server upload id");
+  const { row } = resolveScopedStoredRecord(options.userDataDir, ref, options.cwd);
+  const uploadId = row.remote?.uploadId;
+  if (!uploadId) throw new Error("export requires an exact locally observed server upload receipt");
   const requestedOutput = options.outputPath
     ? path.resolve(options.cwd || process.cwd(), options.outputPath)
     : row
@@ -1118,12 +1432,12 @@ async function fetchUploadExport(ref, options = {}) {
 }
 
 async function withdrawUpload(ref, options = {}) {
-  const auth = await authenticatedContext(options, false);
-  const state = loadExchangeState(options.userDataDir);
-  const row = findStateRecord(state, ref);
-  const uploadId = UPLOAD_ID_RE.test(String(ref || "")) ? ref : row?.remote?.uploadId;
-  if (!uploadId) throw new Error("withdraw requires a server upload id");
+  const { row, validation } = resolveScopedStoredRecord(options.userDataDir, ref, options.cwd);
+  const uploadId = row.remote?.uploadId;
+  if (!uploadId) throw new Error("unpublish requires an exact locally observed server upload receipt");
   if (!row?.remote?.revision) throw new Error("withdraw requires the exact locally observed server revision; run experience status first");
+  if (row.remote.status === "withdrawn") throw new Error("Experience upload is already withdrawn");
+  const auth = await authenticatedContext(options, false);
   const response = await options.fetchHub(`${auth.base}/uploads/${encodeURIComponent(uploadId)}`, {
     method: "DELETE",
     headers: { accept: "application/json", cookie: auth.cookie, origin: auth.origin, "If-Match": `"${row.remote.revision}"` },
@@ -1133,7 +1447,7 @@ async function withdrawUpload(ref, options = {}) {
       const body = parseResponseJson(response, "Experience withdrawal conflict");
       const current = body.current?.receipt || body.current || body.receipt;
       if (current) {
-        const bundle = readStoredBundle(options.userDataDir, row.bundleId).bundle;
+        const bundle = validation.bundle;
         const receipt = validateUploadReceipt(current, bundle);
         persistRemoteReceipt(options.userDataDir, bundle, receipt);
         const error = new Error("Experience withdrawal revision is stale; current server receipt was reconciled locally. Review status and retry.");
@@ -1146,7 +1460,7 @@ async function withdrawUpload(ref, options = {}) {
     throw responseError(response, "Experience withdrawal (server support may be unavailable)");
   }
   const body = parseResponseJson(response, "Experience withdrawal");
-  const bundle = readStoredBundle(options.userDataDir, row.bundleId).bundle;
+  const bundle = validation.bundle;
   const receipt = validateUploadReceipt(body.receipt || body, bundle);
   if (receipt.uploadId !== uploadId || receipt.status !== "withdrawn") throw new Error("withdrawal did not return the exact withdrawn server receipt");
   const etag = response.headers && typeof response.headers.get === "function" ? response.headers.get("etag") : null;
@@ -1157,15 +1471,348 @@ async function withdrawUpload(ref, options = {}) {
   return { receipt, authoritative: "server", publicActivation: false };
 }
 
+const TASK_CLASS_KEYWORDS = Object.freeze({
+  research: ["research", "investigate", "literature review", "market research", "리서치", "연구", "자료 조사"],
+  writing: ["writing", "write article", "write copy", "copywriting", "blog post", "essay", "글쓰기", "글 작성", "카피 작성", "원고 작성"],
+  coding: ["coding", "code implementation", "implement code", "write code", "source code", "코딩", "코드 구현", "코드 작성", "프로그래밍"],
+  debugging: ["debug", "debugging", "bug fix", "fix bug", "troubleshoot", "error", "exception", "failure", "failed", "디버깅", "버그 수정", "오류", "오류 수정", "실패"],
+  design: ["design", "ui design", "ux design", "wireframe", "디자인", "와이어프레임", "화면 설계"],
+  "image-generation": ["image generation", "generate image", "create image", "text to image", "이미지 생성", "그림 생성"],
+  "video-production": ["video production", "create video", "video editing", "영상 제작", "비디오 제작", "영상 편집"],
+  presentation: ["presentation", "slide deck", "powerpoint", "ppt", "프레젠테이션", "발표 자료", "슬라이드", "피피티"],
+  document: ["document", "docx", "pdf document", "document editing", "문서", "문서 작성", "문서 편집"],
+  "data-analysis": ["data analysis", "analyze data", "analytics", "데이터 분석", "통계 분석"],
+  "browser-automation": ["browser automation", "automate browser", "playwright", "브라우저 자동화", "웹 자동화"],
+  "social-publishing": ["social publishing", "publish social", "post to instagram", "post to tiktok", "sns 게시", "소셜 게시", "인스타 업로드", "틱톡 업로드"],
+  marketing: ["marketing", "campaign", "seo", "마케팅", "캠페인"],
+  sales: ["sales", "lead generation", "sales outreach", "영업", "리드 발굴"],
+  "customer-support": ["customer support", "customer service", "support ticket", "고객 지원", "고객 문의", "cs 응대"],
+  ecommerce: ["ecommerce", "e commerce", "online store", "shopify", "이커머스", "온라인 쇼핑몰", "스마트스토어"],
+  "legal-review": ["legal review", "contract review", "legal analysis", "법률 검토", "계약 검토", "법무 검토"],
+  finance: ["finance", "financial analysis", "investment analysis", "재무", "금융", "투자 분석"],
+  "project-planning": ["project planning", "project plan", "roadmap", "프로젝트 계획", "로드맵", "일정 계획"],
+  "agent-building": ["agent building", "build agent", "create agent", "에이전트 빌드", "에이전트 만들", "에이전트 생성"],
+  "workflow-automation": ["workflow automation", "automate workflow", "automation workflow", "워크플로 자동화", "업무 자동화"],
+  "file-operations": ["file operations", "move files", "rename files", "organize files", "파일 작업", "파일 이동", "파일 이름 변경", "파일 정리"],
+  translation: ["translation", "translate", "localization", "번역", "현지화"],
+});
+
+function normalizeClassificationText(value) {
+  return String(value || "")
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[^a-z0-9가-힣]+/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizedTaxonomyAtom(value) {
+  return typeof value === "string" ? value.normalize("NFKC").trim().toLowerCase() : "";
+}
+
+function canonicalSourceTaskId(value) {
+  const normalized = normalizedTaxonomyAtom(value);
+  return normalized.startsWith(CANONICAL_TASK_PREFIX) && CANONICAL_TASK_ID_SET.has(normalized) ? normalized : null;
+}
+
+function canonicalTaskId(value) {
+  const normalized = normalizedTaxonomyAtom(value);
+  const source = canonicalSourceTaskId(normalized);
+  if (source) return source;
+  const id = `${CANONICAL_TASK_PREFIX}${normalized}`;
+  return CANONICAL_TASK_ID_SET.has(id) ? id : null;
+}
+
+function isCanonicalTaskId(value) {
+  return typeof value === "string" && CANONICAL_TASK_ID_SET.has(value);
+}
+
+function keywordOccurs(normalizedPrompt, rawKeyword) {
+  const keyword = normalizeClassificationText(rawKeyword);
+  if (!keyword) return false;
+  if (/[가-힣]/.test(keyword)) return normalizedPrompt.includes(keyword);
+  return ` ${normalizedPrompt} `.includes(` ${keyword} `);
+}
+
+function deriveCanonicalTaskClasses(prompt, options = {}) {
+  const declaredRaw = options.declaredTaskClasses ?? options.declaredTaskClass;
+  if (declaredRaw != null && (Array.isArray(declaredRaw) ? declaredRaw.length : String(declaredRaw).trim())) {
+    const declared = (Array.isArray(declaredRaw) ? declaredRaw : [declaredRaw]).map(String);
+    const taskIds = [...new Set(declared.map(canonicalTaskId).filter(Boolean))];
+    const invalidDeclared = declared.filter((value) => !canonicalTaskId(value));
+    return {
+      taskIds: CANONICAL_TASK_IDS.filter((id) => taskIds.includes(id)),
+      source: "declared-task-class",
+      matchedTaskClasses: CANONICAL_TASK_IDS.filter((id) => taskIds.includes(id)),
+      invalidDeclaredCount: invalidDeclared.length,
+    };
+  }
+  const normalizedPrompt = normalizeClassificationText(prompt);
+  const matches = [];
+  for (const slug of CANONICAL_TASK_SLUGS) {
+    if ((TASK_CLASS_KEYWORDS[slug] || []).some((keyword) => keywordOccurs(normalizedPrompt, keyword))) {
+      matches.push(`${CANONICAL_TASK_PREFIX}${slug}`);
+    }
+  }
+  return { taskIds: matches, source: "deterministic-keyword-map", matchedTaskClasses: matches, invalidDeclaredCount: 0 };
+}
+
+function parseEnvironmentConstraint(value) {
+  const normalized = normalizedTaxonomyAtom(value);
+  const contract = EXPERIENCE_TAXONOMY_V1.environment;
+  if (normalized.startsWith(contract.osPrefix)) {
+    const selected = normalized.slice(contract.osPrefix.length);
+    return CANONICAL_OS_VALUES.has(selected) ? { dimension: "os", value: selected } : null;
+  }
+  if (normalized.startsWith(contract.archPrefix)) {
+    const selected = normalized.slice(contract.archPrefix.length);
+    return CANONICAL_ARCH_VALUES.has(selected) ? { dimension: "arch", value: selected } : null;
+  }
+  if (normalized.startsWith(contract.runtimePrefix)) {
+    const selected = normalized.slice(contract.runtimePrefix.length);
+    return CANONICAL_RUNTIME_RE.test(selected) ? { dimension: "runtime", value: selected } : null;
+  }
+  return null;
+}
+
+function isCanonicalEnvironmentTag(value) {
+  return Boolean(parseEnvironmentConstraint(value));
+}
+
 function defaultEnvironmentTags(options = {}) {
   const platform = options.platform || process.platform;
   const arch = options.arch || process.arch;
-  const platformName = platform === "darwin" ? "macos" : platform === "win32" ? "windows" : platform;
-  const tags = new Set([`${platformName}-${arch}`]);
-  const locale = options.locale || (() => { try { return Intl.DateTimeFormat().resolvedOptions().locale; } catch { return null; } })();
-  if (locale) tags.add(String(locale));
-  for (const tag of options.extra || []) if (tag) tags.add(String(tag));
-  return [...tags];
+  const platformCandidate = normalizedTaxonomyAtom(platform === "darwin" ? "macos" : platform === "win32" ? "windows" : platform);
+  const archCandidate = normalizedTaxonomyAtom(arch === "x86_64" ? "x64" : arch === "aarch64" ? "arm64" : arch);
+  const runtimeCandidate = normalizedTaxonomyAtom(typeof options.runtime === "string" ? options.runtime : typeof options.runtimeTag === "string" ? options.runtimeTag : "terminal");
+  const platformName = CANONICAL_OS_VALUES.has(platformCandidate) ? platformCandidate : "unknown";
+  const archName = CANONICAL_ARCH_VALUES.has(archCandidate) ? archCandidate : "unknown";
+  const runtimeName = CANONICAL_RUNTIME_RE.test(runtimeCandidate) ? runtimeCandidate : "unknown";
+  return [
+    `${EXPERIENCE_TAXONOMY_V1.environment.osPrefix}${platformName}`,
+    `${EXPERIENCE_TAXONOMY_V1.environment.archPrefix}${archName}`,
+    `${EXPERIENCE_TAXONOMY_V1.environment.runtimePrefix}${runtimeName}`,
+  ];
+}
+
+function environmentConstraintsMatch(constraints, environment) {
+  const actual = {
+    os: normalizedTaxonomyAtom(environment?.os),
+    arch: normalizedTaxonomyAtom(environment?.arch),
+    runtime: normalizedTaxonomyAtom(environment?.runtime),
+  };
+  if (!CANONICAL_OS_VALUES.has(actual.os) || !CANONICAL_ARCH_VALUES.has(actual.arch) || !CANONICAL_RUNTIME_RE.test(actual.runtime)) return false;
+  if (actual.os === "unknown" || actual.arch === "unknown" || actual.runtime === "unknown") return false;
+  return (constraints || []).every((raw) => {
+    const parsed = parseEnvironmentConstraint(raw);
+    return Boolean(parsed && actual[parsed.dimension] === parsed.value);
+  });
+}
+
+function selectApplicablePortableItems(input = {}) {
+  const profile = new Set([input.taskClass, ...(input.capabilityTags || [])].map(canonicalTaskId).filter(Boolean));
+  if (!profile.size) return [];
+  const eligible = (input.items || []).filter((item) => {
+    if (!item || ["deprecated", "rejected"].includes(item.status)) return false;
+    if (!(item.taskSignatures || []).map(canonicalSourceTaskId).filter(Boolean).some((task) => profile.has(task))) return false;
+    return environmentConstraintsMatch(item.environmentConstraints || [], input.environment || {});
+  });
+  const superseded = new Set(eligible.flatMap((item) => item.supersedesItemIds || []));
+  return eligible
+    .filter((item) => typeof item.experienceItemId === "string" && !superseded.has(item.experienceItemId))
+    .map((item) => item.experienceItemId);
+}
+
+function readExactLocalBaseMarker(agentRoot, expectedSlug = null) {
+  if (!agentRoot) return { marker: null, reason: "exact-local-base-marker-unavailable" };
+  const file = path.join(path.resolve(agentRoot), ".agentlas-cloud-package.json");
+  try {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 256 * 1024) {
+      return { marker: null, reason: "exact-local-base-marker-unsafe" };
+    }
+    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    const slug = String(raw.slug || expectedSlug || "").trim();
+    const packageHashRaw = String(raw.packageHash || "").replace(/^sha256:/i, "").toLowerCase();
+    const packageHashVersion = String(raw.packageHashVersion || "");
+    const cloudId = raw.cloudId == null ? null : String(raw.cloudId);
+    if (
+      !/^[a-z0-9][a-z0-9._-]{0,95}$/.test(slug) ||
+      (expectedSlug && slug !== expectedSlug) ||
+      !/^[a-f0-9]{64}$/.test(packageHashRaw) ||
+      !["path-sha256-v1", "path-sha256-executable-v2"].includes(packageHashVersion) ||
+      (cloudId && !ID_RE.test(cloudId))
+    ) return { marker: null, reason: "exact-local-base-marker-invalid" };
+    return {
+      marker: {
+        slug,
+        cloudId,
+        packageHash: `sha256:${packageHashRaw}`,
+        packageHashVersion,
+      },
+      reason: null,
+    };
+  } catch (error) {
+    return {
+      marker: null,
+      reason: error?.code === "ENOENT" ? "exact-local-base-marker-unavailable" : "exact-local-base-marker-invalid",
+    };
+  }
+}
+
+function exactTaskSignatureInPrompt(signature, prompt, options = {}) {
+  if (!isCanonicalTaskId(signature)) return false;
+  return deriveCanonicalTaskClasses(prompt, options).taskIds.includes(signature);
+}
+
+/**
+ * Resolve normal Terminal runs without fuzzy identity or semantic guessing.
+ * Automatic retrieval additionally needs one exact Experience release selected
+ * by an authoritative loadout. Merely saving/uploading a compatible bundle is
+ * never attachment consent.
+ */
+function resolveRuntimeExperienceForAgent(options = {}) {
+  const requested = options.requested || {};
+  if (requested.disabled === true) {
+    return { disabled: true, observableReason: "disabled-by-user", resolution: "skipped" };
+  }
+  const environmentTags = defaultEnvironmentTags(options);
+  if (environmentTags.some((tag) => tag.endsWith("/unknown"))) {
+    return { disabled: true, observableReason: "runtime-environment-unknown", resolution: "skipped" };
+  }
+  if (Array.isArray(requested.environmentTags) && requested.environmentTags.length) {
+    const declaredEnvironment = [...new Set(requested.environmentTags.map(String).filter(Boolean))];
+    const exactDefault = declaredEnvironment.length === environmentTags.length && declaredEnvironment.every((tag) => environmentTags.includes(tag));
+    if (!declaredEnvironment.every(isCanonicalEnvironmentTag)) {
+      return { disabled: true, observableReason: "legacy-environment-constraint-not-runtime-activatable", resolution: "skipped" };
+    }
+    if (!exactDefault) {
+      return { disabled: true, observableReason: "declared-environment-does-not-match-runtime", resolution: "skipped" };
+    }
+  }
+  const explicitBase = String(requested.baseAgentReleaseId || "");
+  const explicitSignatures = [...new Set((requested.taskSignatures || []).map(String).filter(Boolean))];
+  const explicitPackReleases = [...new Set((requested.experiencePackReleaseIds || []).map(String).filter(Boolean))];
+  if (explicitBase || explicitSignatures.length || requested.agentDefinitionId || explicitPackReleases.length) {
+    if (!ID_RE.test(explicitBase) || !explicitSignatures.length || explicitPackReleases.length !== 1 || !ID_RE.test(explicitPackReleases[0])) {
+      return { disabled: true, observableReason: "incomplete-explicit-experience-binding", resolution: "skipped" };
+    }
+    if (explicitSignatures.some((item) => !isCanonicalTaskId(item))) {
+      return { disabled: true, observableReason: "legacy-task-signature-not-runtime-activatable", resolution: "skipped" };
+    }
+    return {
+      disabled: false,
+      baseAgentReleaseId: explicitBase,
+      ...(requested.agentDefinitionId && ID_RE.test(String(requested.agentDefinitionId)) ? { agentDefinitionId: String(requested.agentDefinitionId) } : {}),
+      experiencePackReleaseIds: explicitPackReleases,
+      taskSignatures: explicitSignatures,
+      environmentTags,
+      resolution: "explicit-exact",
+    };
+  }
+  const agent = options.agent;
+  if (!agent || agent.builtin || !agent.slug) {
+    return { disabled: true, observableReason: agent?.builtin ? "builtin-agent-has-no-owned-experience-base" : "no-exact-agent-base", resolution: "skipped" };
+  }
+  const local = readExactLocalBaseMarker(options.agentRoot, agent.slug);
+  if (!local.marker) return { disabled: true, observableReason: local.reason, resolution: "skipped" };
+  const attachedPackReleases = [...new Set(
+    (requested.attachedExperiencePackReleaseIds || []).map(String).filter(Boolean),
+  )];
+  if (attachedPackReleases.length !== 1 || !ID_RE.test(attachedPackReleases[0])) {
+    return { disabled: true, observableReason: "explicit-experience-attachment-required", resolution: "skipped" };
+  }
+  let state;
+  try { state = loadExchangeState(options.userDataDir); }
+  catch { return { disabled: true, observableReason: "local-experience-state-invalid", resolution: "skipped" }; }
+  const scopeHash = projectScopeHash(options.cwd);
+  const matchingRows = state.bundles.filter((row) => {
+    const base = row.remote?.baseResolution;
+    return attachedPackReleases.includes(row.experiencePackReleaseId) &&
+      row.projectScopeHash === scopeHash && base &&
+      base.slug === local.marker.slug &&
+      (!local.marker.cloudId || base.cloudId === local.marker.cloudId) &&
+      base.packageHash === local.marker.packageHash &&
+      base.packageHashVersion === local.marker.packageHashVersion &&
+      base.agentDefinitionId === row.agentDefinitionId &&
+      row.compatibleBaseReleaseIds.includes(base.agentReleaseId);
+  });
+  if (!matchingRows.length) {
+    return { disabled: true, observableReason: "exact-local-base-release-unavailable", resolution: "skipped" };
+  }
+  const baseKeys = new Set(matchingRows.map((row) => {
+    const base = row.remote.baseResolution;
+    return `${base.agentDefinitionId}\0${base.agentReleaseId}\0${base.packageHash}`;
+  }));
+  if (baseKeys.size !== 1) {
+    return { disabled: true, observableReason: "ambiguous-exact-base-release", resolution: "skipped" };
+  }
+  const base = matchingRows[0].remote.baseResolution;
+  const taskClassResolution = deriveCanonicalTaskClasses(options.prompt, {
+    declaredTaskClasses: requested.declaredTaskClasses ?? options.declaredTaskClasses ?? options.declaredTaskClass,
+  });
+  if (taskClassResolution.invalidDeclaredCount) {
+    return { disabled: true, observableReason: "invalid-declared-task-class", resolution: "skipped" };
+  }
+  if (!taskClassResolution.taskIds.length) {
+    return { disabled: true, observableReason: "canonical-task-class-unresolved", resolution: "skipped" };
+  }
+  const environment = new Set(environmentTags);
+  const classifiedTasks = new Set(taskClassResolution.taskIds);
+  const taskSignatures = new Set();
+  let sawPromotedItem = false;
+  let sawCanonicalSignature = false;
+  let sawMatchingCanonicalTask = false;
+  let sawLegacyEnvironmentForMatch = false;
+  let sawCanonicalEnvironmentMismatch = false;
+  for (const row of matchingRows) {
+    let bundle;
+    try { bundle = readStoredBundle(options.userDataDir, row.bundleId).bundle; }
+    catch { continue; }
+    for (const item of bundle.items) {
+      if (item.status !== "promoted") continue;
+      sawPromotedItem = true;
+      const canonicalSignatures = item.taskSignatures.filter(isCanonicalTaskId);
+      if (canonicalSignatures.length) sawCanonicalSignature = true;
+      const matchedSignatures = canonicalSignatures.filter((signature) => classifiedTasks.has(signature));
+      if (!matchedSignatures.length) continue;
+      sawMatchingCanonicalTask = true;
+      if (!item.environmentConstraints.every(isCanonicalEnvironmentTag)) {
+        sawLegacyEnvironmentForMatch = true;
+        continue;
+      }
+      if (!item.environmentConstraints.every((constraint) => environment.has(constraint))) {
+        sawCanonicalEnvironmentMismatch = true;
+        continue;
+      }
+      for (const signature of matchedSignatures) taskSignatures.add(signature);
+    }
+  }
+  if (!taskSignatures.size) {
+    const observableReason = sawPromotedItem && !sawCanonicalSignature
+      ? "legacy-task-signature-not-auto-activatable"
+      : sawMatchingCanonicalTask && sawLegacyEnvironmentForMatch
+        ? "legacy-environment-constraint-not-auto-activatable"
+        : sawMatchingCanonicalTask && sawCanonicalEnvironmentMismatch
+          ? "canonical-environment-constraint-mismatch"
+          : "canonical-task-signature-unavailable";
+    return {
+      disabled: true,
+      observableReason,
+      resolution: "skipped",
+      taskClassResolution,
+    };
+  }
+  return {
+    disabled: false,
+    baseAgentReleaseId: base.agentReleaseId,
+    agentDefinitionId: base.agentDefinitionId,
+    experiencePackReleaseIds: attachedPackReleases,
+    taskSignatures: [...taskSignatures].sort(compareCodePoints),
+    environmentTags,
+    resolution: "automatic-exact",
+    taskClassResolution,
+  };
 }
 
 function estimateTokens(text) {
@@ -1175,33 +1822,49 @@ function estimateTokens(text) {
 function buildLocalExperienceAdvisory(options = {}) {
   const empty = { text: "", itemIds: [], estimatedTokens: 0, authority: "local-advisory", serverRentalResolutionReceiptPresent: false };
   if (!options.userDataDir || !options.cwd || !ID_RE.test(String(options.baseAgentReleaseId || ""))) return empty;
-  const taskSignatures = new Set((options.taskSignatures || []).map(String).filter(Boolean));
+  const experiencePackReleaseIds = new Set(
+    (options.experiencePackReleaseIds || []).map(String).filter((value) => ID_RE.test(value)),
+  );
+  if (experiencePackReleaseIds.size !== 1) return empty;
+  const taskSignatures = new Set((options.taskSignatures || []).map(String).filter(isCanonicalTaskId));
   if (!taskSignatures.size) return empty;
-  const environmentTags = new Set((options.environmentTags || defaultEnvironmentTags(options)).map(String));
+  const resolvedEnvironmentTags = (options.environmentTags || defaultEnvironmentTags(options)).map(String).filter(isCanonicalEnvironmentTag);
+  if (resolvedEnvironmentTags.some((tag) => tag.endsWith("/unknown"))) return empty;
+  const environmentTags = new Set(resolvedEnvironmentTags);
   const state = loadExchangeState(options.userDataDir);
   const projectHash = projectScopeHash(options.cwd);
   const candidates = [];
   for (const row of state.bundles) {
-    if (row.projectScopeHash !== projectHash || !row.compatibleBaseReleaseIds.includes(options.baseAgentReleaseId)) continue;
+    if (
+      !experiencePackReleaseIds.has(row.experiencePackReleaseId) ||
+      row.projectScopeHash !== projectHash ||
+      !row.compatibleBaseReleaseIds.includes(options.baseAgentReleaseId)
+    ) continue;
     if (options.agentDefinitionId && row.agentDefinitionId !== options.agentDefinitionId) continue;
     let validation;
     try { validation = readStoredBundle(options.userDataDir, row.bundleId); } catch { continue; }
     for (const item of validation.bundle.items) {
       if (item.status !== "promoted") continue;
       if (!item.taskSignatures.some((signature) => taskSignatures.has(signature))) continue;
+      if (!item.environmentConstraints.every(isCanonicalEnvironmentTag)) continue;
       if (!item.environmentConstraints.every((constraint) => environmentTags.has(constraint))) continue;
       candidates.push(item);
     }
   }
   candidates.sort((a, b) => Number(b.confidence) - Number(a.confidence) || compareCodePoints(a.experienceItemId, b.experienceItemId));
   const header = "[AGENTLAS_LOCAL_EXPERIENCE_ADVISORY v1] NO SERVER RENTAL-RESOLUTION RECEIPT. Local user-attested procedures only; not evaluator-verified and not reputation evidence.";
+  const reservedTokens = Number.isInteger(options.reservedTokens)
+    ? Math.max(0, Math.min(EXPERIENCE_RETRIEVAL_MAX_TOKENS, options.reservedTokens))
+    : 0;
+  const dynamicTokenBudget = Math.max(0, EXPERIENCE_RETRIEVAL_MAX_TOKENS - reservedTokens);
+  if (estimateTokens(header) > dynamicTokenBudget) return empty;
   let text = header;
   const itemIds = [];
   for (const item of candidates) {
     if (itemIds.length >= EXPERIENCE_RETRIEVAL_MAX_ITEMS || itemIds.includes(item.experienceItemId)) continue;
     const line = `\n- [${item.experienceItemId}] ${item.summary}\n  Steps: ${item.instructions.join(" | ")}`;
     const next = `${text}${line}`;
-    if (estimateTokens(next) > EXPERIENCE_RETRIEVAL_MAX_TOKENS) continue;
+    if (estimateTokens(next) > dynamicTokenBudget) continue;
     text = next;
     itemIds.push(item.experienceItemId);
   }
@@ -1237,6 +1900,39 @@ function renderPublish(result) {
   ].join("\n");
 }
 
+function publicUploadReceipt(receipt) {
+  return {
+    schema: receipt.schema,
+    uploadId: receipt.uploadId,
+    bundleId: receipt.bundleId,
+    bundleHash: receipt.bundleHash,
+    experiencePackId: receipt.experiencePackId,
+    experienceReleaseId: receipt.experienceReleaseId,
+    status: receipt.status,
+    requestedVisibility: receipt.requestedVisibility,
+    revision: receipt.revision,
+    createdAt: receipt.createdAt,
+    updatedAt: receipt.updatedAt,
+    ...(receipt.errorCode ? { errorCode: receipt.errorCode } : {}),
+  };
+}
+
+function publicCommandExchangeResult(result) {
+  return {
+    ...(result.receipt ? { receipt: publicUploadReceipt(result.receipt) } : {}),
+    ...(BUNDLE_ID_RE.test(String(result.bundleId || "")) ? { bundleId: result.bundleId } : {}),
+    ...(HASH_RE.test(String(result.bundleHash || "")) ? { bundleHash: result.bundleHash } : {}),
+    ...(["private", "unlisted", "public"].includes(result.requestedVisibility) ? { requestedVisibility: result.requestedVisibility } : {}),
+    ...(typeof result.replayed === "boolean" ? { replayed: result.replayed } : {}),
+    ...(typeof result.recovered === "boolean" ? { recovered: result.recovered } : {}),
+    ...(typeof result.dryRun === "boolean" ? { dryRun: result.dryRun } : {}),
+    ...(typeof result.networkUsed === "boolean" ? { networkUsed: result.networkUsed } : {}),
+    ...(typeof result.authoritative === "string" ? { authoritative: result.authoritative } : {}),
+    publicActivation: false,
+    evaluatorAuthority: false,
+  };
+}
+
 function baseDescriptorFromFlags(flags) {
   return {
     ...(flags["base-slug"] ? { slug: flags["base-slug"] } : {}),
@@ -1255,25 +1951,62 @@ async function cmdExperienceExchange(options = {}) {
 
   if (sub === "help" || sub === "--help" || sub === "-h") {
     const help = [
+      "agentlas experience list",
+      "agentlas experience inspect <exact-release-id|bundle-id|upload-id>",
       "agentlas experience validate <bundle.agentlas-experience.json>",
       "agentlas experience save <bundle> --base-cloud-id <id>|--base-slug <slug> --base-package-hash sha256:<hash>",
       "agentlas experience publish <bundle> --visibility unlisted|public --base-cloud-id <id>|--base-slug <slug> --base-package-hash sha256:<hash>",
       "agentlas experience status <bundle-id|upload-id>",
+      "agentlas experience unpublish <exact-release-id|bundle-id|upload-id> [--dry-run]",
       "agentlas experience withdraw <bundle-id|upload-id>",
       "agentlas experience export <bundle-id|upload-id> [--out file] [--overwrite]",
       "Options: --dry-run (zero network/write), --idempotency-key <safe-key>, save --local-only",
-      "Legacy local intents: list|inspect|unpublish|legacy-publish",
+      "Legacy pack-only local intents: legacy-list|legacy-inspect|legacy-publish|legacy-unpublish",
       "publish requests verification only; Terminal never claims evaluator verification or public activation.",
     ].join("\n");
     emit(help);
     return { help: true };
   }
 
-  if (["list", "ls", "inspect", "show", "unpublish", "legacy-publish", "legacy-unpublish"].includes(sub)) {
+  if (["legacy-list", "legacy-inspect", "legacy-publish", "legacy-unpublish"].includes(sub)) {
     if (typeof options.legacyCommand !== "function") throw new Error("legacy local-intent Experience handler is unavailable");
-    const mapped = sub === "legacy-publish" ? "publish" : sub === "legacy-unpublish" ? "unpublish" : sub;
+    const mapped = sub.slice("legacy-".length);
     return options.legacyCommand({ ...options, args: [mapped, ...args.slice(1)] });
   }
+  if (sub === "list" || sub === "ls") {
+    if (flags._.length) throw new Error("usage: agentlas experience list [--json]");
+    const bundles = listStoredExperienceBundles(options.userDataDir, options.cwd);
+    const result = {
+      schemaVersion: "agentlas.terminal-experience-local-list.v1",
+      currentProjectOnly: true,
+      networkUsed: false,
+      bundles,
+    };
+    const lines = bundles.length
+      ? ["LOCAL PORTABLE EXPERIENCE BUNDLES · current project only · no network", ...bundles.map((bundle) =>
+          `- ${bundle.experiencePackId}@${bundle.experiencePackReleaseId} · ${bundle.itemCount} item(s) · ${bundle.reviewState} · Hub: ${bundle.remote ? `${bundle.remote.status} (${bundle.remote.uploadId})` : "not submitted"}`)]
+      : ["No Portable Experience Bundles are stored for this project.", "Hub was not contacted."];
+    emit(flags.json ? JSON.stringify(result, null, 2) : lines.join("\n"));
+    return result;
+  }
+  if (sub === "inspect" || sub === "show") {
+    const ref = flags._[0];
+    if (!ref || flags._.length !== 1) throw new Error("usage: agentlas experience inspect <exact-release-id|bundle-id|upload-id>");
+    const bundle = inspectStoredExperienceBundle(options.userDataDir, ref, options.cwd);
+    const result = { ...bundle, networkUsed: false };
+    emit(flags.json ? JSON.stringify(result, null, 2) : [
+      `${bundle.experiencePackId}@${bundle.experiencePackReleaseId}`,
+      `bundle: ${bundle.bundleId} · ${bundle.itemCount} item(s) · local integrity: verified`,
+      `review state: ${bundle.reviewState} · candidates ${bundle.itemStatusCounts.candidate} · promoted ${bundle.itemStatusCounts.promoted}`,
+      `compatible base releases: ${bundle.compatibleBaseReleaseIds.join(", ")}`,
+      bundle.remote
+        ? `Hub receipt: ${bundle.remote.status} · ${bundle.remote.uploadId} · exact revision ${bundle.remote.revision}`
+        : "Hub receipt: none · not submitted",
+      "Owner/account, local path, raw content, prompt, transcript, and credentials are intentionally omitted.",
+      "Public activation/evaluator authority: not claimed.",
+    ].join("\n"));
+    return result;
+  }
   if (sub === "validate") {
     const validation = readBundleFile(flags._[0], options.cwd);
     const result = { valid: true, bundleId: validation.bundle.bundleId, bundleHash: validation.bundle.bundleHash, packContentHash: validation.bundle.pack.contentHash, items: validation.bundle.items.length, canonicalBytes: validation.canonicalBytes, networkUsed: false, authority: "local-validation" };
@@ -1300,24 +2033,11 @@ async function cmdExperienceExchange(options = {}) {
       idempotencyKey: flags["idempotency-key"] || null,
       baseDescriptor: baseDescriptorFromFlags(flags),
     });
-    emit(flags.json ? JSON.stringify(result, null, 2) : renderPublish(result));
+    emit(flags.json ? JSON.stringify(publicCommandExchangeResult(result), null, 2) : renderPublish(result));
     return result;
   }
   if (sub === "publish") {
-    // Compatibility: the old pack-only command remains a local-intent alias.
     const source = flags._[0];
-    if (source && !BUNDLE_ID_RE.test(source)) {
-      const absolute = path.resolve(options.cwd || process.cwd(), source);
-      try {
-        const parsed = JSON.parse(fs.readFileSync(absolute, "utf8"));
-        if (parsed?.schemaVersion === "agentlas.experience-pack.v1") {
-          if (typeof options.legacyCommand !== "function") throw new Error("legacy handler unavailable");
-          return options.legacyCommand({ ...options, args: ["publish", ...args.slice(1)] });
-        }
-      } catch (error) {
-        if (error?.code !== "ENOENT" && !String(error?.message || "").includes("JSON")) throw error;
-      }
-    }
     const validation = resolveBundleInput(options.userDataDir, source, options.cwd);
     const result = await publishBundle(validation, {
       ...options,
@@ -1327,12 +2047,12 @@ async function cmdExperienceExchange(options = {}) {
       idempotencyKey: flags["idempotency-key"] || null,
       baseDescriptor: baseDescriptorFromFlags(flags),
     });
-    emit(flags.json ? JSON.stringify(result, null, 2) : renderPublish(result));
+    emit(flags.json ? JSON.stringify(publicCommandExchangeResult(result), null, 2) : renderPublish(result));
     return result;
   }
   if (sub === "status") {
     const result = await fetchUploadStatus(flags._[0], options);
-    emit(flags.json ? JSON.stringify(result, null, 2) : `Server-authoritative status: ${result.receipt.status} · ${result.receipt.uploadId}\nrequested visibility: ${result.receipt.requestedVisibility} · Terminal did not assert public activation/evaluator reputation`);
+    emit(flags.json ? JSON.stringify(publicCommandExchangeResult(result), null, 2) : `Server-authoritative status: ${result.receipt.status} · ${result.receipt.uploadId}\nrequested visibility: ${result.receipt.requestedVisibility} · Terminal did not assert public activation/evaluator reputation`);
     return result;
   }
   if (sub === "export") {
@@ -1345,17 +2065,18 @@ async function cmdExperienceExchange(options = {}) {
     emit(flags.json ? JSON.stringify(result, null, 2) : `Experience exported: ${result.outputPath}\nbundle hash: ${result.bundleHash}`);
     return result;
   }
-  if (sub === "withdraw") {
+  if (sub === "withdraw" || sub === "unpublish") {
+    if (!flags._[0] || flags._.length !== 1) throw new Error("usage: agentlas experience unpublish <exact-release-id|bundle-id|upload-id> [--dry-run]");
     if (flags["dry-run"] === true) {
-      const result = { dryRun: true, withdrawn: false, networkUsed: false, ref: flags._[0] || null };
-      emit(flags.json ? JSON.stringify(result, null, 2) : "DRY RUN · no withdrawal request sent · server state unchanged");
+      const result = previewWithdrawUpload(flags._[0], options);
+      emit(flags.json ? JSON.stringify(result, null, 2) : `DRY RUN · exact upload ${result.uploadId} at ${result.ifMatchRevision}\nnetwork/write used: no · server state unchanged · no new receipt`);
       return result;
     }
     const result = await withdrawUpload(flags._[0], options);
-    emit(flags.json ? JSON.stringify(result, null, 2) : `Server-authoritative withdrawal: ${result.receipt.uploadId} · withdrawn\nExisting receipts/history remain; no public activation claim.`);
+    emit(flags.json ? JSON.stringify(publicCommandExchangeResult(result), null, 2) : `Server-authoritative unpublication: ${result.receipt.uploadId} · withdrawn\nExisting receipts/history remain; no public activation claim.`);
     return result;
   }
-  throw new Error("unknown experience subcommand (validate|save|publish|status|export|withdraw; legacy: list|inspect|unpublish|legacy-publish)");
+  throw new Error("unknown experience subcommand (list|inspect|validate|save|publish|status|export|unpublish|withdraw; legacy: legacy-list|legacy-inspect|legacy-publish|legacy-unpublish)");
 }
 
 module.exports = {
@@ -1365,6 +2086,12 @@ module.exports = {
   MAX_STORED_ITEMS,
   EXPERIENCE_RETRIEVAL_MAX_ITEMS,
   EXPERIENCE_RETRIEVAL_MAX_TOKENS,
+  EXPERIENCE_TAXONOMY_V1,
+  EXPERIENCE_TAXONOMY_CHECKSUM,
+  CANONICAL_TASK_PREFIX,
+  CANONICAL_ENV_PREFIX,
+  CANONICAL_TASK_SLUGS,
+  CANONICAL_TASK_IDS,
   ExperienceBundleValidationError,
   canonicalJson,
   canonicalHash,
@@ -1384,7 +2111,16 @@ module.exports = {
   loadExchangeState,
   withExchangeStateLock,
   saveLocalBundle,
+  commitServerAcceptedBundle,
   readStoredBundle,
+  verifyStoredBundleRow,
+  scopedStateRows,
+  resolveScopedStoredRecord,
+  listStoredExperienceBundles,
+  inspectStoredExperienceBundle,
+  previewWithdrawUpload,
+  publicUploadReceipt,
+  publicCommandExchangeResult,
   projectScopeHash,
   idempotencyKeyForBundle,
   idempotencyKeyHash,
@@ -1394,8 +2130,22 @@ module.exports = {
   fetchUploadExport,
   withdrawUpload,
   defaultEnvironmentTags,
+  loadExperienceTaxonomyContract,
+  validateExperienceTaxonomyContract,
+  canonicalSourceTaskId,
+  canonicalTaskId,
+  isCanonicalTaskId,
+  parseEnvironmentConstraint,
+  isCanonicalEnvironmentTag,
+  environmentConstraintsMatch,
+  selectApplicablePortableItems,
+  deriveCanonicalTaskClasses,
+  readExactLocalBaseMarker,
+  exactTaskSignatureInPrompt,
+  resolveRuntimeExperienceForAgent,
   estimateTokens,
   buildLocalExperienceAdvisory,
   augmentRuntimeSystemWithLocalExperience,
+  portableExperienceSafetyIssues,
   cmdExperienceExchange,
 };