nolo-cli 0.75.0 → 0.76.0

package/{agentRunCommand-QJGP7JEN.js → agentRunCommand-YJOW3VB3.js}

@@ -8,7 +8,7 @@ import {
   resolveRunSettlementNote,
   resolveWorkflowReference,
   runAgentRunCommand
-} from "./chunk-6ZC5KPXV.js";
+} from "./chunk-KO7QCXLL.js";
 import "./chunk-S7Z2HMCN.js";
 import {
   parseAgentRunArgs

package/{chunk-6ZC5KPXV.js → chunk-KO7QCXLL.js}

@@ -172,7 +172,8 @@ import {
   parsePositiveFiniteNumberOrFallback
 } from "./chunk-Y5GCAMGP.js";
 import {
-  createMemoryKey
+  createMemoryKey,
+  ulid
 } from "./chunk-VMFTFOWF.js";
 import {
   asTrimmedLowercaseString
@@ -185,6 +186,9 @@ import {
 import {
   parsePublicAgentId
 } from "./chunk-BJIRLHJR.js";
+import {
+  isLevelNotFoundError
+} from "./chunk-OW765XBU.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -10411,7 +10415,7 @@ function findCollapsedPasteSpanAt(buffer, pos, opts = {}) {
 }
 
 // packages/cli/client/agentRun.ts
-import { ulid } from "ulid";
+import { ulid as ulid2 } from "ulid";
 async function loadRunLocalAgentTurn() {
   const { runLocalAgentTurn } = await import("./agentRuntimeLocal-T43UNWAY.js");
   return runLocalAgentTurn;
@@ -11078,8 +11082,8 @@ async function runLocalAgentTurnForCli(options, settings) {
     ...options.parentWakeOnTerminal ? { parentWakeOnTerminal: true } : {},
     ...options.parentDialogId ? { parentThreadId: options.parentDialogId } : {}
   } : void 0;
-  const currentDialogId = options.continueDialogId ?? ulid();
-  const turnId = `turn-${ulid()}`;
+  const currentDialogId = options.continueDialogId ?? ulid2();
+  const turnId = `turn-${ulid2()}`;
   const runtimeContextWithOwnership = {
     ...runtimeContext ?? {},
     dialogId: currentDialogId,
@@ -12076,8 +12080,15 @@ var rankMemoryCandidates = (items, query, context) => {
 // packages/ai/memory/vnext/store.ts
 var enc = (value) => encodeURIComponent(value).replace(/-/g, "%2D");
 var rangeOf = (prefix) => ({ gte: prefix, lte: `${prefix}\uFFFF` });
+var entityKey = (ownerId, id) => `mem2-e-${enc(ownerId)}-${enc(id)}`;
 var entityOwnerPrefix = (ownerId) => `mem2-e-${enc(ownerId)}-`;
+var stateKey = (ownerId, id) => `mem2-s-${enc(ownerId)}-${enc(id)}`;
+var stateEntityIndexKey = (ownerId, entityId, stateId) => `mem2-si-${enc(ownerId)}-${enc(entityId)}-${enc(stateId)}`;
 var stateEntityIndexPrefix = (ownerId, entityId) => `mem2-si-${enc(ownerId)}-${enc(entityId)}-`;
+var evidenceKey = (ownerId, id) => `mem2-v-${enc(ownerId)}-${enc(id)}`;
+var relationKey = (ownerId, id) => `mem2-r-${enc(ownerId)}-${enc(id)}`;
+var relationFromIndexKey = (ownerId, from, relationId) => `mem2-rf-${enc(ownerId)}-${enc(from)}-${enc(relationId)}`;
+var relationToIndexKey = (ownerId, to, relationId) => `mem2-rt-${enc(ownerId)}-${enc(to)}-${enc(relationId)}`;
 var readIndexed = async (db, prefix) => {
   const refs = [];
   for await (const [, value] of db.iterator({ ...rangeOf(prefix), reverse: false })) {
@@ -12086,6 +12097,7 @@ var readIndexed = async (db, prefix) => {
   const rows = await Promise.all(refs.map((key) => db.get(key).catch(() => null)));
   return rows.filter((row) => !!row);
 };
+var getMemoryEntityVNext = async (db, ownerId, entityId) => db.get(entityKey(ownerId, entityId)).catch(() => null);
 var listMemoryEntitiesVNext = async (db, ownerId) => {
   const rows = [];
   for await (const [, value] of db.iterator({
@@ -12096,7 +12108,40 @@ var listMemoryEntitiesVNext = async (db, ownerId) => {
   }
   return rows;
 };
+var getMemoryStateVNext = async (db, ownerId, stateId) => db.get(stateKey(ownerId, stateId)).catch(() => null);
 var listMemoryStatesForEntityVNext = (db, ownerId, entityId) => readIndexed(db, stateEntityIndexPrefix(ownerId, entityId));
+var putMemoryEvidenceVNext = async (db, evidence) => {
+  await db.put(evidenceKey(evidence.ownerId, evidence.id), evidence);
+};
+var getMemoryEvidenceVNext = async (db, ownerId, evidenceId) => db.get(evidenceKey(ownerId, evidenceId)).catch(() => null);
+var getMemoryEvidenceVNextStrict = async (db, ownerId, evidenceId) => {
+  try {
+    return await db.get(evidenceKey(ownerId, evidenceId));
+  } catch (error) {
+    if (isLevelNotFoundError(error)) return null;
+    throw error;
+  }
+};
+var _appendEntityBatch = (batch, entity) => {
+  batch.put(entityKey(entity.ownerId, entity.id), entity);
+};
+var _appendEvidenceBatch = (batch, evidence) => {
+  batch.put(evidenceKey(evidence.ownerId, evidence.id), evidence);
+};
+var _appendStateBatch = (batch, state2) => {
+  const key = stateKey(state2.ownerId, state2.id);
+  batch.put(key, state2);
+  batch.put(stateEntityIndexKey(state2.ownerId, state2.entityId, state2.id), { key });
+};
+var _appendRetiredStateBatch = (batch, state2) => {
+  batch.put(stateKey(state2.ownerId, state2.id), state2);
+};
+var _appendRelationBatch = (batch, relation) => {
+  const key = relationKey(relation.ownerId, relation.id);
+  batch.put(key, relation);
+  batch.put(relationFromIndexKey(relation.ownerId, relation.from, relation.id), { key });
+  batch.put(relationToIndexKey(relation.ownerId, relation.to, relation.id), { key });
+};
 
 // packages/ai/memory/vnext/recall.ts
 var MAX_RECALL_REFS = 6;
@@ -12227,11 +12272,41 @@ ${catalogText(entities, states)}`
 };
 
 // packages/ai/memory/vnext/legacyMigration.ts
+import { createHash } from "crypto";
+var LEGACY_MEMORY_SOURCE_REF_PREFIX = "legacy-memory";
+var LEGACY_MEMORY_EVIDENCE_ID_PREFIX = "mem-legacy-";
 var resolveLegacyMemoryPrincipal = (item) => ({
   ownerType: item.ownerType,
   ownerId: item.ownerId,
   principalId: `${item.ownerType}:${encodeURIComponent(item.ownerId)}`
 });
+var buildLegacyMemorySourceRef = (item) => {
+  const { principalId } = resolveLegacyMemoryPrincipal(item);
+  return `${LEGACY_MEMORY_SOURCE_REF_PREFIX}:${principalId}:${encodeURIComponent(item.id)}`;
+};
+var legacyEvidenceSeed = (principalId, itemId) => JSON.stringify([principalId, itemId]);
+var buildLegacyEvidenceId = (item) => {
+  const { principalId } = resolveLegacyMemoryPrincipal(item);
+  const digest = createHash("sha256").update(legacyEvidenceSeed(principalId, item.id)).digest("hex");
+  return `${LEGACY_MEMORY_EVIDENCE_ID_PREFIX}${digest.slice(0, 32)}`;
+};
+var clampLegacyConfidence = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+};
+var buildLegacyMemoryEvidence = (item) => {
+  const { principalId } = resolveLegacyMemoryPrincipal(item);
+  return {
+    id: buildLegacyEvidenceId(item),
+    ownerId: principalId,
+    text: item.content,
+    sourceRef: buildLegacyMemorySourceRef(item),
+    confidence: clampLegacyConfidence(item.confidence),
+    createdAt: item.createdAt
+  };
+};
 
 // packages/ai/memory/vnext/shadowRead.ts
 var SHADOW_TIMEOUT_MS = 2e4;
@@ -12340,6 +12415,736 @@ var runMemoryVNextShadowRead = async (input) => {
 };
 var isMemoryVNextShadowReadEnabled = (env = typeof process !== "undefined" ? process.env : {}) => env.NOLO_MEMORY_VNEXT_SHADOW_READ === "1" || env.NOLO_MEMORY_VNEXT_SHADOW_READ === "true";
 
+// packages/ai/memory/vnext/applyMutation.ts
+async function validateMutation(db, ownerId, mutation) {
+  const pending = {
+    evidenceIds: /* @__PURE__ */ new Set(),
+    entityIds: /* @__PURE__ */ new Set(),
+    stateIds: /* @__PURE__ */ new Set(),
+    relationIds: /* @__PURE__ */ new Set()
+  };
+  for (const ev of mutation.evidence ?? []) {
+    if (!ev.id || typeof ev.id !== "string") {
+      throw new Error("evidence id must be a non-empty string");
+    }
+    if (pending.evidenceIds.has(ev.id)) {
+      throw new Error(`duplicate evidence id in mutation: ${ev.id}`);
+    }
+    pending.evidenceIds.add(ev.id);
+  }
+  for (const ent of mutation.entities ?? []) {
+    if (!ent.id || typeof ent.id !== "string") {
+      throw new Error("entity id must be a non-empty string");
+    }
+    if (pending.entityIds.has(ent.id)) {
+      throw new Error(`duplicate entity id in mutation: ${ent.id}`);
+    }
+    pending.entityIds.add(ent.id);
+  }
+  for (const st of mutation.states ?? []) {
+    if (!st.id || typeof st.id !== "string") {
+      throw new Error("state id must be a non-empty string");
+    }
+    if (pending.stateIds.has(st.id)) {
+      throw new Error(`duplicate state id in mutation: ${st.id}`);
+    }
+    pending.stateIds.add(st.id);
+  }
+  for (const rel of mutation.relations ?? []) {
+    if (!rel.id || typeof rel.id !== "string") {
+      throw new Error("relation id must be a non-empty string");
+    }
+    if (pending.relationIds.has(rel.id)) {
+      throw new Error(`duplicate relation id in mutation: ${rel.id}`);
+    }
+    pending.relationIds.add(rel.id);
+  }
+  const supersededIds = /* @__PURE__ */ new Set();
+  for (const sid of mutation.supersededStateIds ?? []) {
+    if (supersededIds.has(sid)) {
+      throw new Error(`duplicate supersededStateId in mutation: ${sid}`);
+    }
+    supersededIds.add(sid);
+  }
+  for (const ev of mutation.evidence ?? []) {
+    if (ev.ownerId !== ownerId) {
+      throw new Error(
+        `evidence ${ev.id} has ownerId ${ev.ownerId}, expected ${ownerId}`
+      );
+    }
+  }
+  for (const ent of mutation.entities ?? []) {
+    if (ent.ownerId !== ownerId) {
+      throw new Error(
+        `entity ${ent.id} has ownerId ${ent.ownerId}, expected ${ownerId}`
+      );
+    }
+  }
+  for (const st of mutation.states ?? []) {
+    if (st.ownerId !== ownerId) {
+      throw new Error(
+        `state ${st.id} has ownerId ${st.ownerId}, expected ${ownerId}`
+      );
+    }
+  }
+  for (const rel of mutation.relations ?? []) {
+    if (rel.ownerId !== ownerId) {
+      throw new Error(
+        `relation ${rel.id} has ownerId ${rel.ownerId}, expected ${ownerId}`
+      );
+    }
+  }
+  for (const st of mutation.states ?? []) {
+    if (supersededIds.has(st.id)) {
+      throw new Error(
+        `state ${st.id} appears in both states and supersededStateIds; a record cannot be created and retired in the same mutation`
+      );
+    }
+  }
+  const facetSlots = /* @__PURE__ */ new Set();
+  for (const st of mutation.states ?? []) {
+    const slot = `${st.entityId} ${st.facet}`;
+    if (facetSlots.has(slot)) {
+      throw new Error(
+        `mutation writes parallel current states for entity ${st.entityId} facet ${st.facet}`
+      );
+    }
+    facetSlots.add(slot);
+  }
+  for (const ev of mutation.evidence ?? []) {
+    const existing = await getMemoryEvidenceVNext(db, ownerId, ev.id);
+    if (existing) {
+      throw new Error(
+        `evidence ${ev.id} already exists (owner ${ownerId}); use a unique id`
+      );
+    }
+  }
+  for (const ent of mutation.entities ?? []) {
+    const existing = await getMemoryEntityVNext(db, ownerId, ent.id);
+    if (existing) {
+      throw new Error(
+        `entity ${ent.id} already exists (owner ${ownerId}); use a unique id`
+      );
+    }
+  }
+  for (const st of mutation.states ?? []) {
+    if (!pending.entityIds.has(st.entityId)) {
+      const entity = await getMemoryEntityVNext(db, ownerId, st.entityId);
+      if (!entity) {
+        throw new Error(
+          `memory state ${st.id} references missing entity ${st.entityId} (owner ${ownerId})`
+        );
+      }
+    }
+    for (const evidenceId of st.evidenceIds) {
+      if (!pending.evidenceIds.has(evidenceId)) {
+        const ev = await getMemoryEvidenceVNext(db, ownerId, evidenceId);
+        if (!ev) {
+          throw new Error(
+            `memory state ${st.id} references missing evidence ${evidenceId} (owner ${ownerId})`
+          );
+        }
+      }
+    }
+    const existing = await getMemoryStateVNext(db, ownerId, st.id);
+    if (existing) {
+      if (existing.retiredAt) {
+        throw new Error(
+          `cannot update retired memory state ${st.id} (owner ${ownerId})`
+        );
+      }
+      if (existing.entityId !== st.entityId || existing.facet !== st.facet) {
+        throw new Error(
+          `state ${st.id} already exists with different entity/facet (${existing.entityId}/${existing.facet} vs ${st.entityId}/${st.facet}); use supersede instead`
+        );
+      }
+    }
+    if (!existing) {
+      const existingStates = await listMemoryStatesForEntityVNext(db, ownerId, st.entityId);
+      for (const es of existingStates) {
+        if (es.facet === st.facet && !es.retiredAt) {
+          if (!supersededIds.has(es.id)) {
+            throw new Error(
+              `entity ${st.entityId} facet ${st.facet} already has current state ${es.id}; supersede it or use a different facet`
+            );
+          }
+        }
+      }
+    }
+  }
+  for (const sid of mutation.supersededStateIds ?? []) {
+    const existing = await getMemoryStateVNext(db, ownerId, sid);
+    if (!existing) {
+      throw new Error(
+        `cannot supersede missing memory state: ${sid} (owner ${ownerId})`
+      );
+    }
+    if (existing.retiredAt) {
+      throw new Error(
+        `cannot supersede already retired memory state: ${sid} (owner ${ownerId})`
+      );
+    }
+    const replacement = (mutation.states ?? []).find(
+      (st) => st.entityId === existing.entityId && st.facet === existing.facet
+    );
+    if (!replacement) {
+      throw new Error(
+        `superseded state ${sid} (entity ${existing.entityId} facet ${existing.facet}) has no replacement in this mutation`
+      );
+    }
+  }
+  for (const rel of mutation.relations ?? []) {
+    for (const [side, ref] of [
+      ["from", rel.from],
+      ["to", rel.to]
+    ]) {
+      if (pending.entityIds.has(ref) || pending.stateIds.has(ref) || pending.evidenceIds.has(ref)) {
+        continue;
+      }
+      const resolved = await getMemoryEntityVNext(db, ownerId, ref) ?? await getMemoryStateVNext(db, ownerId, ref) ?? await getMemoryEvidenceVNext(db, ownerId, ref);
+      if (!resolved) {
+        throw new Error(
+          `memory relation ${rel.id} references missing ${side} ${ref} (owner ${ownerId})`
+        );
+      }
+    }
+  }
+}
+var applyMemoryInterpreterMutation = async (db, ownerId, mutation) => {
+  await validateMutation(db, ownerId, mutation);
+  const batch = db.batch();
+  for (const ev of mutation.evidence ?? []) {
+    _appendEvidenceBatch(batch, ev);
+  }
+  for (const ent of mutation.entities ?? []) {
+    _appendEntityBatch(batch, ent);
+  }
+  for (const st of mutation.states ?? []) {
+    _appendStateBatch(batch, st);
+  }
+  for (const sid of mutation.supersededStateIds ?? []) {
+    const existing = await getMemoryStateVNext(db, ownerId, sid);
+    if (!existing) {
+      throw new Error(
+        `cannot supersede missing memory state: ${sid} (owner ${ownerId})`
+      );
+    }
+    const replacement = (mutation.states ?? []).find(
+      (st) => st.entityId === existing.entityId && st.facet === existing.facet
+    );
+    const retired = {
+      ...existing,
+      retiredAt: replacement?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    _appendRetiredStateBatch(batch, retired);
+  }
+  for (const rel of mutation.relations ?? []) {
+    _appendRelationBatch(batch, rel);
+  }
+  await batch.write();
+};
+
+// packages/ai/memory/vnext/legacyMigrationApply.ts
+var isSameLegacyMemoryEvidence = (left, right) => left.id === right.id && left.ownerId === right.ownerId && left.text === right.text && left.sourceRef === right.sourceRef && left.confidence === right.confidence && left.createdAt === right.createdAt;
+var applyLegacyMemoryEvidence = async (db, item) => {
+  const incoming = buildLegacyMemoryEvidence(item);
+  const existing = await getMemoryEvidenceVNextStrict(db, incoming.ownerId, incoming.id);
+  if (existing) {
+    return isSameLegacyMemoryEvidence(existing, incoming) ? { status: "already_exists", evidence: existing } : { status: "conflict", existing, incoming };
+  }
+  await putMemoryEvidenceVNext(db, incoming);
+  return { status: "created", evidence: incoming };
+};
+
+// packages/ai/memory/vnext/types.ts
+var MEMORY_ENTITY_TYPES = [
+  "person",
+  "organization",
+  "project",
+  "place",
+  "object",
+  "activity",
+  "concept"
+];
+var MEMORY_RELATION_TYPES = [
+  "related_to",
+  "part_of",
+  "uses",
+  "involves",
+  "supersedes"
+];
+
+// packages/ai/memory/vnext/interpreterWireProtocol.ts
+var isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var isString = (value) => typeof value === "string" && value.trim().length > 0;
+var isStringArray = (value) => Array.isArray(value) && value.every(isString);
+var optionalArray = (value, validate2) => value === void 0 || Array.isArray(value) && value.every(validate2);
+var ACTIONS = /* @__PURE__ */ new Set([
+  "no_op",
+  "create",
+  "update",
+  "specialize",
+  "supersede",
+  "ambiguous"
+]);
+var validateEvidence = (value) => {
+  if (!isObject(value)) return false;
+  return isString(value.key) && isString(value.text) && typeof value.confidence === "number" && Number.isFinite(value.confidence) && value.confidence >= 0 && value.confidence <= 1 && (value.sourceRef === void 0 || isString(value.sourceRef));
+};
+var validateEntity = (value) => {
+  if (!isObject(value)) return false;
+  return isString(value.key) && MEMORY_ENTITY_TYPES.includes(value.type) && isString(value.name) && (value.subtype === void 0 || isString(value.subtype)) && (value.aliases === void 0 || isStringArray(value.aliases));
+};
+var validateState = (value) => {
+  if (!isObject(value)) return false;
+  return (value.stateId === void 0 || isString(value.stateId)) && (value.supersedes === void 0 || isString(value.supersedes)) && isString(value.entityRef) && isString(value.facet) && "value" in value && isString(value.text) && isStringArray(value.evidenceRefs);
+};
+var validateRelation = (value) => {
+  if (!isObject(value)) return false;
+  return isString(value.fromRef) && MEMORY_RELATION_TYPES.includes(value.type) && isString(value.toRef);
+};
+var stripJsonFence = (raw) => {
+  const trimmed = raw.trim();
+  const match = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return match ? match[1].trim() : trimmed;
+};
+var parseMemoryInterpreterWireMutation = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(stripJsonFence(raw));
+  } catch {
+    return { ok: false, error: "interpreter output is not valid JSON" };
+  }
+  if (!isObject(parsed)) return { ok: false, error: "interpreter output must be an object" };
+  if (!isString(parsed.action) || !ACTIONS.has(parsed.action)) {
+    return { ok: false, error: "invalid reconciliation action" };
+  }
+  if (!isString(parsed.reason)) return { ok: false, error: "reason is required" };
+  if (!optionalArray(parsed.evidence, validateEvidence)) return { ok: false, error: "invalid evidence array" };
+  if (!optionalArray(parsed.entities, validateEntity)) return { ok: false, error: "invalid entities array" };
+  if (!optionalArray(parsed.states, validateState)) return { ok: false, error: "invalid states array" };
+  if (!optionalArray(parsed.relations, validateRelation)) return { ok: false, error: "invalid relations array" };
+  return { ok: true, value: parsed };
+};
+var buildMemoryInterpreterWireContract = () => `
+Return ONLY one JSON object:
+{
+  "action": "no_op|create|update|specialize|supersede|ambiguous",
+  "reason": "short explanation",
+  "evidence": [{ "key": "e1", "text": "...", "confidence": 0.9, "sourceRef": "optional" }],
+  "entities": [{ "key": "n1", "type": "person|organization|project|place|object|activity|concept", "name": "...", "subtype": "optional", "aliases": [] }],
+  "states": [{ "stateId": "optional-existing-state-id", "supersedes": "optional-existing-state-id-this-statement-replaces", "entityRef": "existing-entity-id-or-new-entity-key", "facet": "...", "value": {}, "text": "...", "evidenceRefs": ["e1"] }],
+  "relations": [{ "fromRef": "existing-id-or-local-key", "type": "related_to|part_of|uses|involves|supersedes", "toRef": "existing-id-or-local-key" }]
+}
+
+Do not generate persistent ids, owner ids, timestamps or storage keys. Runtime owns identity and time.
+Use short local keys only to connect records created in the SAME response. Every local key must be unique across evidence/entities.
+State evidenceRefs may reference Evidence emitted in this response. Evidence ids marked referenceable in the supplied memory context may be referenced directly. Do not reference any other prior Evidence id.
+When updating an existing State, reuse its exact stateId, exact entityRef and exact facet. Runtime preserves that State's original entity/facet/createdAt and appends new Evidence provenance.
+When creating a new State, omit stateId.
+For supersede: emit the replacing statement as a NEW State (omit stateId) and set supersedes to the exact id of the replaced current State. Runtime retires the replaced State \u2014 it stays recoverable as history but is no longer current, and the new State becomes the only current one for that facet. Never update or supersede an already retired State.
+supersedes and stateId are mutually exclusive on one State.
+Do not emit an existing Entity again merely to update its State; reference its exact id in entityRef.
+Relations may reference only known persisted Entity/State/Evidence ids or local Entity/Evidence keys emitted in the same response.
+Do not invent new Entity or Relation types. Keep expressive detail in subtype/facet/value/text.
+`.trim();
+var assertUniqueLocalKeys = (wire) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of [...wire.evidence ?? [], ...wire.entities ?? []]) {
+    if (seen.has(item.key)) throw new Error(`duplicate local key: ${item.key}`);
+    seen.add(item.key);
+  }
+};
+var materializeMemoryInterpreterMutation = (input) => {
+  assertUniqueLocalKeys(input.wire);
+  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const nextId = input.nextId ?? ulid;
+  const existingStates = new Map((input.existingStates ?? []).map((state2) => [state2.id, state2]));
+  const existingStateIds = new Set(existingStates.keys());
+  const existingEvidenceIds = new Set(
+    [...existingStates.values()].flatMap((state2) => state2.evidenceIds)
+  );
+  const existingEntityIds = new Set(input.existingEntityIds ?? []);
+  const entityRefs = /* @__PURE__ */ new Map();
+  const evidenceRefs = /* @__PURE__ */ new Map();
+  const evidence = (input.wire.evidence ?? []).map((item) => {
+    const id = nextId();
+    evidenceRefs.set(item.key, id);
+    return {
+      id,
+      ownerId: input.ownerId,
+      text: item.text,
+      ...item.sourceRef ? { sourceRef: item.sourceRef } : {},
+      confidence: item.confidence,
+      createdAt: now
+    };
+  });
+  const entities = (input.wire.entities ?? []).map((item) => {
+    const id = nextId();
+    entityRefs.set(item.key, id);
+    return {
+      id,
+      ownerId: input.ownerId,
+      type: item.type,
+      name: item.name,
+      ...item.subtype ? { subtype: item.subtype } : {},
+      ...item.aliases ? { aliases: item.aliases } : {},
+      createdAt: now,
+      updatedAt: now
+    };
+  });
+  const resolveEntityRef = (ref) => {
+    const created = entityRefs.get(ref);
+    if (created) return created;
+    if (existingEntityIds.has(ref)) return ref;
+    throw new Error(`unknown entity ref: ${ref}`);
+  };
+  const supersededStateIds = [];
+  const referenceableEvidenceIds = new Set(input.referenceableEvidenceIds ?? []);
+  const resolveEvidenceRef = (ref) => {
+    const created = evidenceRefs.get(ref);
+    if (created) return created;
+    if (referenceableEvidenceIds.has(ref)) return ref;
+    throw new Error(`unknown evidence ref: ${ref}`);
+  };
+  const states = (input.wire.states ?? []).map((item) => {
+    const prior = item.stateId ? existingStates.get(item.stateId) : void 0;
+    if (item.stateId && !prior) {
+      throw new Error(`unknown existing state: ${item.stateId}`);
+    }
+    if (prior?.retiredAt) {
+      throw new Error(`retired state cannot be updated: ${item.stateId}`);
+    }
+    if (prior && item.entityRef !== prior.entityId) {
+      throw new Error(`existing state entityRef changed: ${item.stateId}`);
+    }
+    if (prior && item.facet !== prior.facet) {
+      throw new Error(`existing state facet changed: ${item.stateId}`);
+    }
+    let supersededStateId;
+    if (item.supersedes !== void 0) {
+      if (input.wire.action !== "supersede") {
+        throw new Error(
+          `supersedes is only valid for the supersede action, got ${input.wire.action}`
+        );
+      }
+      if (item.stateId !== void 0) {
+        throw new Error("supersedes and stateId are mutually exclusive on one state");
+      }
+      const superseded = existingStates.get(item.supersedes);
+      if (!superseded) {
+        throw new Error(`unknown superseded state id: ${item.supersedes}`);
+      }
+      if (superseded.retiredAt) {
+        throw new Error(`retired state cannot be superseded: ${item.supersedes}`);
+      }
+      if (supersededStateIds.includes(item.supersedes)) {
+        throw new Error(`duplicate superseded state id: ${item.supersedes}`);
+      }
+      supersededStateId = item.supersedes;
+    }
+    const newEvidenceIds = item.evidenceRefs.map(resolveEvidenceRef);
+    const id = prior?.id ?? nextId();
+    if (supersededStateId !== void 0) supersededStateIds.push(supersededStateId);
+    return {
+      id,
+      ownerId: input.ownerId,
+      entityId: prior?.entityId ?? resolveEntityRef(item.entityRef),
+      facet: prior?.facet ?? item.facet,
+      value: item.value,
+      text: item.text,
+      evidenceIds: [.../* @__PURE__ */ new Set([...prior?.evidenceIds ?? [], ...newEvidenceIds])],
+      createdAt: prior?.createdAt ?? now,
+      updatedAt: now
+    };
+  });
+  const resolveRelationRef = (ref) => {
+    const createdEntity = entityRefs.get(ref);
+    if (createdEntity) return createdEntity;
+    const createdEvidence = evidenceRefs.get(ref);
+    if (createdEvidence) return createdEvidence;
+    if (existingEntityIds.has(ref) || existingStateIds.has(ref) || existingEvidenceIds.has(ref)) {
+      return ref;
+    }
+    throw new Error(`unknown relation ref: ${ref}`);
+  };
+  const relations = (input.wire.relations ?? []).map((item) => ({
+    id: nextId(),
+    ownerId: input.ownerId,
+    from: resolveRelationRef(item.fromRef),
+    type: item.type,
+    to: resolveRelationRef(item.toRef),
+    createdAt: now
+  }));
+  return {
+    action: input.wire.action,
+    reason: input.wire.reason,
+    ...evidence.length ? { evidence } : {},
+    ...entities.length ? { entities } : {},
+    ...states.length ? { states } : {},
+    ...supersededStateIds.length ? { supersededStateIds } : {},
+    ...relations.length ? { relations } : {}
+  };
+};
+
+// packages/ai/memory/vnext/interpreterPrompt.ts
+var MEMORY_VNEXT_ENTITY_CREATION_CONTRACT = `
+Entity creation is NOT named-entity recognition.
+
+Create a new long-lived Entity only when the subject has future continuity value.
+A mention alone is insufficient.
+
+Prefer leaving information as Evidence until at least one strong continuity signal exists:
+1. The subject recurs across independent dialogs, or the user explicitly describes it as enduring.
+2. The user connects it to their own preferences, relationships, goals, identity, worldview, ongoing work, or repeated activity.
+3. Future conversations are likely to refer back to it under different wording, so a stable anchor materially improves cross-dialog continuity.
+4. Creating the anchor is necessary to update or relate existing long-lived State.
+
+Do NOT create an Entity merely because the text contains a named person, product, place, historical event, book, philosopher, food, device, or concept.
+When uncertain, keep Evidence and defer Entity creation.
+
+Concept-specific rule:
+- concept is for abstract subjects that become part of the user's personal meaning world, such as freedom, absurdism, privacy, modernity, beauty, loneliness, safety, or maintainability.
+- Do not create a Concept Entity for every topic discussed or external fact queried.
+- Promote a concept only when it recurs, carries a durable user stance/interest/tension, connects multiple memories, or is likely to become a future recall/navigation anchor.
+- A one-off question such as "when was Kant born?" should normally create no long-lived Concept or Person Entity. Repeated discussion about Kant, freedom, and the user's own values may justify them.
+`.trim();
+var MEMORY_VNEXT_THIRD_PARTY_RELEVANCE_CONTRACT = `
+Third-party relevance test:
+- A fact about another person is durable only when it concerns the user's own world. Observation-only third-party facts \u2014 someone's appearance, news, habits, or the doings of a person the user merely encounters \u2014 stay Evidence, no matter how often they recur.
+- Closeness of that person, and repeated mentions across independent dialogs, do not by themselves make such an observation durable: never invent a user-world consequence to justify promotion (for example "the user keeps watching this person").
+- Matters that are part of the user's own shared life \u2014 household or family arrangements the user takes part in, a family member's health, or what the user relies on someone for \u2014 do belong to the user's world: state the user-world side (caregiving, changed time, changed plans, a sustained constraint) instead of a chronicle of the other person's doings.
+`.trim();
+var MEMORY_VNEXT_RECONCILIATION_CONTRACT = `
+When durable understanding changes, choose the smallest correct reconciliation:
+- no_op: no durable change.
+- create: genuinely new durable state/entity.
+- update: advance an existing state without changing its scope.
+- specialize: add a scoped exception/qualification; do not replace the broader state.
+- supersede: a newer statement explicitly replaces old current state. Emit the replacement as a NEW State and name the replaced current State in its supersedes field; runtime retires the old one (kept as recoverable history, no longer current).
+- ambiguous: evidence conflicts with current state, but replacement vs exception cannot be determined reliably.
+
+Examples:
+- "\u56DE\u7B54\u7B80\u5355" then "\u5B89\u5168\u548C bug \u6392\u67E5\u8BE6\u7EC6" => specialize, not supersede.
+- "\u6211\u6709 Ollama Pro" then "\u6211\u5DF2\u7ECF\u4E0D\u7528 Ollama Pro \u4E86" => supersede.
+- Repeatedly choosing thin noodles without explicitly rejecting thick noodles => update or ambiguous, not automatic supersession.
+
+Preserve ambiguity. Do not ask the user merely to clean memory. A later task may ask only if the unresolved state materially changes the answer.
+`.trim();
+var buildMemoryVNextInterpreterPrompt = () => [
+  "You maintain long-lived adaptive relationship memory backed by evidence.",
+  "External dialogs/files/web facts remain authoritative outside memory.",
+  "Prefer a small stable set of Entities and updateable States over an ever-growing bag of facts.",
+  MEMORY_VNEXT_ENTITY_CREATION_CONTRACT,
+  MEMORY_VNEXT_THIRD_PARTY_RELEVANCE_CONTRACT,
+  MEMORY_VNEXT_RECONCILIATION_CONTRACT,
+  buildMemoryInterpreterWireContract()
+].join("\n\n");
+
+// packages/ai/memory/vnext/legacyMigrationShadow.ts
+var LEGACY_MIGRATION_SHADOW_INSTRUCTION = `
+This Evidence came from a legacy memory record.
+Legacy kind and subject metadata are advisory hints only.
+Re-evaluate it under the current vNext contract.
+Do not mechanically map:
+- semantic -> State
+- procedural -> procedure State
+- subjectType=agent -> agent Entity
+- visibility -> scope
+Prefer Evidence-only when durable semantic value is unclear.
+`.trim();
+var serializeExisting = (existing) => JSON.stringify({
+  entityIds: existing?.entityIds ?? [],
+  states: (existing?.states ?? []).map((state2) => ({
+    stateId: state2.id,
+    entityId: state2.entityId,
+    facet: state2.facet,
+    text: state2.text
+  }))
+});
+var buildLegacyMigrationInterpreterInput = (input) => [
+  LEGACY_MIGRATION_SHADOW_INSTRUCTION,
+  `The legacy record's Evidence is marked referenceable with id "${input.evidence.id}" and sourceRef "${input.evidence.sourceRef}". Evidence ids marked referenceable in the supplied memory context may be referenced directly. When a State cites it, reference that exact id in evidenceRefs. Do not emit another Evidence for this legacy record.`,
+  `Imported Evidence (text is the authoritative legacy content, referenceable directly):
+${JSON.stringify(
+    {
+      ...input.evidence,
+      referenceable: true
+    },
+    null,
+    2
+  )}`,
+  `Legacy metadata (advisory hints only, NOT vNext semantics):
+${JSON.stringify(
+    {
+      kind: input.item.kind,
+      visibility: input.item.visibility,
+      subjectType: input.item.subjectType,
+      subjectId: input.item.subjectId,
+      facet: input.item.facet,
+      importance: input.item.importance,
+      resident: input.item.resident
+    },
+    null,
+    2
+  )}`,
+  `Existing vNext context for this principal (caller-supplied shadow snapshot):
+${serializeExisting(
+    input.existing
+  )}`
+].join("\n\n");
+var mergeImportedEvidence = (mutation, imported) => {
+  const emitted = mutation.evidence ?? [];
+  const duplicatedIds = new Set(
+    emitted.filter(
+      (item) => item.sourceRef === imported.sourceRef || // A re-emitted copy that drops sourceRef is still the same legacy record:
+      // text equality is the only identity left on the wire to catch it.
+      item.sourceRef === void 0 && item.text === imported.text
+    ).map((item) => item.id)
+  );
+  const rewrite = (id) => duplicatedIds.has(id) ? imported.id : id;
+  return {
+    ...mutation,
+    evidence: [imported, ...emitted.filter((item) => !duplicatedIds.has(item.id))],
+    ...mutation.states ? {
+      states: mutation.states.map((state2) => ({
+        ...state2,
+        evidenceIds: [...new Set(state2.evidenceIds.map(rewrite))]
+      }))
+    } : {},
+    ...mutation.relations ? {
+      relations: mutation.relations.map((relation) => ({
+        ...relation,
+        from: rewrite(relation.from),
+        to: rewrite(relation.to)
+      }))
+    } : {}
+  };
+};
+var runLegacyMemoryMigrationShadow = async (input) => {
+  const principal = resolveLegacyMemoryPrincipal(input.item);
+  const evidence = buildLegacyMemoryEvidence(input.item);
+  const completion = await input.provider.complete(
+    [
+      { role: "system", content: buildMemoryVNextInterpreterPrompt() },
+      {
+        role: "user",
+        content: buildLegacyMigrationInterpreterInput({
+          item: input.item,
+          evidence,
+          ...input.existing ? { existing: input.existing } : {}
+        })
+      }
+    ],
+    input.timeoutMs === void 0 ? void 0 : { timeoutMs: input.timeoutMs }
+  );
+  const parsed = parseMemoryInterpreterWireMutation(completion.content);
+  if (!parsed.ok) {
+    throw new Error(`legacy migration shadow: unparsable interpreter response (${parsed.error})`);
+  }
+  const candidate = materializeMemoryInterpreterMutation({
+    // The principal identity (user:/space:/system:<id>) is the migration owner
+    // space, so a space migration can never land in a user space.
+    ownerId: evidence.ownerId,
+    wire: parsed.value,
+    ...input.existing?.states ? { existingStates: [...input.existing.states] } : {},
+    ...input.existing?.entityIds ? { existingEntityIds: [...input.existing.entityIds] } : {},
+    referenceableEvidenceIds: [evidence.id],
+    ...input.now === void 0 ? {} : { now: input.now },
+    ...input.nextId ? { nextId: input.nextId } : {}
+  });
+  const mutation = mergeImportedEvidence(candidate, evidence);
+  return {
+    principal,
+    evidence,
+    wire: parsed.value,
+    mutation,
+    action: mutation.action,
+    reason: mutation.reason
+  };
+};
+
+// packages/ai/memory/vnext/lazyPromotion.ts
+var ERROR_MESSAGE_MAX2 = 120;
+var inFlight = /* @__PURE__ */ new Set();
+var shortError2 = (error) => {
+  const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  return message.length > ERROR_MESSAGE_MAX2 ? `${message.slice(0, ERROR_MESSAGE_MAX2)}\u2026` : message;
+};
+var loadExistingContext = async (db, ownerId) => {
+  const entities = await listMemoryEntitiesVNext(db, ownerId);
+  const states = (await Promise.all(
+    entities.map((entity) => listMemoryStatesForEntityVNext(db, ownerId, entity.id))
+  )).flat();
+  return {
+    entityIds: entities.map((entity) => entity.id),
+    states
+  };
+};
+var withoutImportedEvidence = (mutation, importedEvidenceId) => ({
+  ...mutation,
+  evidence: (mutation.evidence ?? []).filter((evidence) => evidence.id !== importedEvidenceId)
+});
+var hasWrites = (mutation) => (mutation.evidence?.length ?? 0) > 0 || (mutation.entities?.length ?? 0) > 0 || (mutation.states?.length ?? 0) > 0 || (mutation.supersededStateIds?.length ?? 0) > 0 || (mutation.relations?.length ?? 0) > 0;
+var runMemoryVNextLazyPromotion = async (input) => {
+  const clock = input.clock ?? (() => performance.now());
+  const startedAt = clock();
+  const emit = input.emit ?? ((observation) => console.info("[memory] vnext lazy promotion", {
+    event: "memory_vnext_lazy_promotion",
+    ...observation
+  }));
+  const finish = (partial) => {
+    const observation = {
+      ...partial,
+      latencyMs: Math.round((clock() - startedAt) * 10) / 10
+    };
+    try {
+      emit(observation);
+    } catch {
+    }
+    return observation;
+  };
+  const deterministicEvidence = buildLegacyMemoryEvidence(input.item);
+  const flightKey = `${deterministicEvidence.ownerId}\0${deterministicEvidence.id}`;
+  if (inFlight.has(flightKey)) {
+    return finish({ status: "in_flight" });
+  }
+  inFlight.add(flightKey);
+  try {
+    const evidenceResult = await applyLegacyMemoryEvidence(input.db, input.item);
+    if (evidenceResult.status === "conflict") {
+      return finish({ status: "conflict" });
+    }
+    const evidence = evidenceResult.evidence;
+    const existing = await loadExistingContext(input.db, evidence.ownerId);
+    const alreadyCovered = (existing.states ?? []).some(
+      (state2) => !state2.retiredAt && state2.evidenceIds.includes(evidence.id)
+    );
+    if (alreadyCovered) {
+      return finish({ status: "already_covered" });
+    }
+    const interpreted = await runLegacyMemoryMigrationShadow({
+      item: input.item,
+      provider: input.provider,
+      existing,
+      ...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+      ...input.now === void 0 ? {} : { now: input.now },
+      ...input.nextId ? { nextId: input.nextId } : {}
+    });
+    const semanticMutation = withoutImportedEvidence(interpreted.mutation, evidence.id);
+    if (!hasWrites(semanticMutation)) {
+      return finish({ status: "no_op", action: semanticMutation.action });
+    }
+    await applyMemoryInterpreterMutation(input.db, evidence.ownerId, semanticMutation);
+    return finish({ status: "promoted", action: semanticMutation.action });
+  } catch (error) {
+    return finish({ status: "error", error: shortError2(error) });
+  } finally {
+    inFlight.delete(flightKey);
+  }
+};
+var isMemoryVNextLazyPromotionEnabled = (env = typeof process !== "undefined" ? process.env : {}) => env.NOLO_MEMORY_VNEXT_LAZY_PROMOTION === "1" || env.NOLO_MEMORY_VNEXT_LAZY_PROMOTION === "true";
+
 // packages/ai/memory/runtime.ts
 var COLD_STORAGE_CONFIDENCE = 0.3;
 var MEMORY_OVERLAY_TOKEN_BUDGET = DEFAULT_MEMORY_OVERLAY_TOKEN_BUDGET;
@@ -12506,6 +13311,17 @@ var resolveMemoryRuntime = async (input) => {
       legacyContextChars: promptBlock?.length ?? 0
     });
   }
+  const promotionCandidate = selected[0];
+  const lazyPromotionEnabled = input.vNextShadowProvider != null && isMemoryVNextLazyPromotionEnabled();
+  if (lazyPromotionEnabled && promotionCandidate) {
+    void runMemoryVNextLazyPromotion({
+      db: input.db,
+      item: promotionCandidate,
+      provider: input.vNextShadowProvider,
+      ...input.lazyPromotionEmit ? { emit: input.lazyPromotionEmit } : {}
+    }).catch(() => {
+    });
+  }
   if (selected.length === 0) {
     return { selectedItems: [], promptBlock: null };
   }

package/index.js

@@ -127,7 +127,7 @@ function createDaemonShortcutCommand(path, description, command2) {
 // packages/cli/agentInternalCommandEntries.ts
 function getAgentInternalCommandEntries() {
   const createAgentRunCommand = (path, description) => createContextCommand(path, description, async (args2, ctx) => {
-    const { runAgentRunCommand } = await import("./agentRunCommand-QJGP7JEN.js");
+    const { runAgentRunCommand } = await import("./agentRunCommand-YJOW3VB3.js");
     return runAgentRunCommand(args2, {
       env: ctx.env,
       scriptDir: ctx.scriptDir,
@@ -883,7 +883,7 @@ async function runScript(script, forwardedArgs, env) {
   return proc.exited;
 }
 async function launchTuiWorkspace(args2) {
-  const { startTuiWorkspace } = await import("./readlineWorkspace-NXKHYZEU.js");
+  const { startTuiWorkspace } = await import("./readlineWorkspace-2RP77YDN.js");
   const { createTuiSummaryLlmCaller } = await import("./tuiSummaryLlmCaller-T2OA5ZVB.js");
   return startTuiWorkspace({
     ...args2,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {

package/{readlineWorkspace-NXKHYZEU.js → readlineWorkspace-2RP77YDN.js}

@@ -72,7 +72,7 @@ import {
   wrapTextToLines,
   wrapTranscriptLine,
   wrapTranscriptLineWithLayout
-} from "./chunk-6ZC5KPXV.js";
+} from "./chunk-KO7QCXLL.js";
 import "./chunk-S7Z2HMCN.js";
 import "./chunk-JYYZCK2Z.js";
 import {