@nyte-ai/core 0.0.18 → 0.0.21

package/dist/chunks/{compose-aa73dbe8.js → compose-mcz93154.js}

@@ -1,24 +1,24 @@
 import {
   PARTICIPANT_AUTHORITY2
-} from "./compose-mryw0674.js";
+} from "./compose-5z835ej2.js";
 import {
   check2
 } from "./compose-bj54tkph.js";
 import {
   definePart2,
   tool2
-} from "./compose-bjx8s01m.js";
+} from "./compose-fqsqjbrf.js";
 import {
   decodeRunRecord2,
   decodePartRecord2
-} from "./compose-1jz2j92f.js";
-import {
-  runRef2,
-  partRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-gxjc6vz9.js";
 import {
   dev2
 } from "./compose-n116fnmp.js";
+import {
+  runRef2,
+  partRef2
+} from "./compose-cqpjcx2t.js";
 import {
   STALE2,
   load2,
@@ -29,24 +29,36 @@ import {
   attempt2,
   readCall2,
   readCalls2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
+import {
+  readAttributedPaths2,
+  ownedChanges2,
+  anotherChatLive2
+} from "./compose-yfcb6w2h.js";
 import {
   settling2
-} from "./compose-drdej9yt.js";
+} from "./compose-d95fwwvw.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-bbhk8vnr.js";
 import {
   signalsPark2,
   parkStep2,
   runStep2
-} from "./compose-rehp8epe.js";
+} from "./compose-byse0eqj.js";
+import {
+  startJob2
+} from "./compose-nkxwrphm.js";
 import {
   publishPatch2
-} from "./compose-vmhv4e00.js";
+} from "./compose-qxfq6dn9.js";
+import {
+  hiddenOwners2,
+  missingCapabilities2
+} from "./compose-bd8c5n7k.js";
 import {
   toolSource2
-} from "./compose-064y3n82.js";
+} from "./compose-ae5t6v5b.js";
 
 // src/agent/tool-runner.ts
 import { Type } from "typebox";
@@ -90,9 +102,10 @@ function runningCalls(kernel) {
 async function executeCall2(kernel, input) {
   const { session, call } = input;
   const controller = new AbortController;
+  const running = { stop: controller, move: new AbortController };
   const live = runningCalls(kernel);
   const controllers = live.get(call) ?? new Set;
-  controllers.add(controller);
+  controllers.add(running);
   live.set(call, controllers);
   const steps = await Promise.all([
     readCall2(kernel.store, session, call),
@@ -103,10 +116,11 @@ async function executeCall2(kernel, input) {
   try {
     return await perform(kernel, {
       ...input,
-      signal: AbortSignal.any([input.signal, controller.signal])
+      signal: AbortSignal.any([input.signal, controller.signal]),
+      released: running.move.signal
     });
   } finally {
-    controllers.delete(controller);
+    controllers.delete(running);
     if (controllers.size === 0 && live.get(call) === controllers)
       live.delete(call);
   }
@@ -150,13 +164,20 @@ function stoppableTool2(kernel) {
     async stop(_input, context) {
       const running = runningCalls(kernel).get(context.part.id);
       if (running !== undefined && running.size > 0) {
-        for (const controller of running)
-          controller.abort();
+        for (const live of running)
+          live.stop.abort();
         return;
       }
       for (const call of [context.part.id, `${HOOK}${context.part.id}`])
         await kernel.waits.callStopped(context.session, asId(call));
       return;
+    },
+    background(_input, context) {
+      if (!kernel.jobs.release(context.session, asId(context.part.id)))
+        return;
+      for (const live of runningCalls(kernel).get(context.part.id) ?? [])
+        live.move.abort();
+      return;
     }
   };
   return definePart2({
@@ -175,6 +196,7 @@ async function perform(kernel, where) {
   if (planned.kind === "parked")
     return PARKED;
   let concluded;
+  let before = null;
   const snapshotted = planned.kind === "execute" && where.covered !== true && planned.definition.effects !== "none";
   const step = await runStep2(kernel, {
     session,
@@ -187,13 +209,17 @@ async function perform(kernel, where) {
     opening: { updates: () => partOpening(kernel.store, where, planned), fenced: STOPPED },
     part: asId(call),
     signal,
-    body: planned.kind === "execute" ? (durable) => execute(kernel, where, planned, durable, snapshotted) : async () => planned.outcome,
+    body: planned.kind === "execute" ? async (durable) => {
+      const executed = await execute(kernel, where, planned, durable, snapshotted);
+      before = executed.before;
+      return executed.outcome;
+    } : async () => planned.outcome,
     async settle(ended) {
-      concluded ??= conclude(kernel, where, ended, snapshotted);
+      concluded ??= conclude(kernel, where, ended, before, planned.class);
       const settled = await concluded;
       return {
         result: settled.outcome,
-        updates: await settlement(kernel.store, where, planned, settled)
+        updates: await settlement(kernel.store, where, planned, settled, before)
       };
     },
     decode: (value) => outcomes.Check(value) ? outcomes.Decode(value) : null
@@ -206,14 +232,18 @@ async function perform(kernel, where) {
 async function plan(kernel, where, intent) {
   const { session, head, run, call, name } = where;
   const custom = { kind: "custom", label: name };
-  const definition = toolSource2(where.runtime).get(name)?.definition;
-  if (definition === undefined)
+  const found = toolSource2(where.runtime).get(name);
+  const hidden = await hiddenOwners2(kernel, session, run);
+  const definition = found === undefined || hidden.has(found.owner) ? undefined : found.definition;
+  if (definition === undefined) {
+    const missing = found === undefined ? await missingCapabilities2(kernel, session, run) : [];
     return {
       kind: "settle",
-      outcome: failed(`No tool is named ${name}.`),
+      outcome: failed(missing.length === 0 ? `No tool is named ${name}.` : `${name} isn't available here: this chat uses ${missing.join(", ")}, which only Nyte.app has. Open Nyte.app to continue.`),
       args: where.args,
       class: custom
     };
+  }
   if (where.argumentsError !== undefined)
     return {
       kind: "settle",
@@ -314,20 +344,24 @@ async function partOpening(store, where, planned) {
 }
 async function execute(kernel, where, planned, durable, snapshotted) {
   const { session, run, signal } = where;
+  let before = null;
   try {
     if (snapshotted)
-      await baseline(kernel, session, run);
-    const [env, found] = await Promise.all([
+      before = await durable.memo("nyte:snapshot", () => baseline(kernel, session, run));
+    const [env, found, hidden] = await Promise.all([
       kernel.environments.attach(session),
-      requireSession2(kernel.store, session)
+      requireSession2(kernel.store, session),
+      hiddenOwners2(kernel, session, run)
     ]);
     const invocation = createInvocation2(kernel, {
+      hidden,
       session,
       head: where.head,
       run,
       call: where.call,
       context: where.context,
       signal,
+      released: where.released,
       workspace: found.record.workspace,
       env,
       durable,
@@ -335,11 +369,17 @@ async function execute(kernel, where, planned, durable, snapshotted) {
       covered: where.covered === true || snapshotted
     });
     const result = await planned.definition.execute(planned.input, invocation);
-    return signal.aborted ? STOPPED : await validateToolResult(planned.definition, result);
+    return {
+      outcome: signal.aborted ? STOPPED : await validateToolResult(planned.definition, result),
+      before
+    };
   } catch (error) {
     if (signalsPark2(error))
       throw error;
-    return signal.aborted ? STOPPED : failed(error instanceof Error ? error.message : String(error));
+    return {
+      outcome: signal.aborted ? STOPPED : failed(error instanceof Error ? error.message : String(error)),
+      before
+    };
   }
 }
 async function validateToolResult(definition, result) {
@@ -361,15 +401,32 @@ async function validateToolResult(definition, result) {
     parts
   };
 }
-async function conclude(kernel, where, ended, snapshotted) {
+async function conclude(kernel, where, ended, before, toolClass) {
   const { session, head, run } = where;
   const outcome = await where.runtime.hooks.transform("after_tool", ended.kind === "done" ? ended.value : INTERRUPTED, { session, head, run, principal: where.context.principal });
-  const snapshots = snapshotted && ended.kind === "done" ? await kernel.environments.snapshots(session) : null;
-  if (snapshots === null)
-    return { outcome, changes: null, files: [], snapshot: null };
-  const from = await diffBase(kernel.store, session, run) ?? await snapshots.before(run);
+  const snapshots = before !== null && ended.kind === "done" ? await kernel.environments.snapshots(session) : null;
+  if (snapshots === null || before === null)
+    return { outcome, files: null, thread: null, snapshot: null, path: null, unattributed: false };
   const to = await snapshots.after(run);
-  const files = (await snapshots.diff(from, to)).files.map((file) => {
+  const [changed, path] = await Promise.all([
+    snapshots.diff(before.snapshot, to).then(fileChanges),
+    editedPath(kernel, session, toolClass)
+  ]);
+  const unattributed = path === null && changed.length > 0 && (before.contended || await anotherChatLive2(kernel, session));
+  const files = unattributed ? [] : changed.filter((file) => path === null || file.path === path || file.from === path);
+  const thread = files.length === 0 && !unattributed ? null : fileChanges(await ownedChanges2(kernel.store, snapshots, session, to, files.map((file) => file.path)));
+  return { outcome, files, thread, snapshot: to, path, unattributed };
+}
+async function editedPath(kernel, session, toolClass) {
+  if (toolClass.kind !== "edit")
+    return null;
+  if (!/^(?:[\\/]|[A-Za-z]:)/.test(toolClass.path))
+    return toolClass.path.replace(/^\.\//, "");
+  const root = (await kernel.environments.attach(session)).cwd.replace(/[\\/]+$/, "");
+  return toolClass.path.startsWith(`${root}/`) || toolClass.path.startsWith(`${root}\\`) ? toolClass.path.slice(root.length + 1).replaceAll("\\", "/") : null;
+}
+function fileChanges(set) {
+  return set.files.map((file) => {
     const change = {
       path: file.path,
       status: file.status,
@@ -378,18 +435,8 @@ async function conclude(kernel, where, ended, snapshotted) {
     };
     return file.from === undefined ? change : { ...change, from: file.from };
   });
-  return {
-    outcome,
-    changes: {
-      added: files.reduce((sum, file) => sum + file.added, 0),
-      removed: files.reduce((sum, file) => sum + file.removed, 0),
-      paths: files.map((file) => file.path)
-    },
-    files,
-    snapshot: to
-  };
 }
-async function settlement(store, where, planned, settled) {
+async function settlement(store, where, planned, settled, before) {
   const { session, head, run, call } = where;
   const part = asId(call);
   const name = partRef2(session, part);
@@ -399,6 +446,14 @@ async function settlement(store, where, planned, settled) {
   ]);
   if (found === null)
     return [];
+  const counted = before === null || settled.path !== null ? new Set : await readAttributedPaths2(store, session, before.seq, (event) => event.head === head && event.call !== call);
+  const files = settled.files?.filter((file) => !counted.has(file.path));
+  const changes = files === undefined ? null : {
+    added: files.reduce((sum, file) => sum + file.added, 0),
+    removed: files.reduce((sum, file) => sum + file.removed, 0),
+    paths: files.map((file) => file.path),
+    ...settled.unattributed && { unattributed: true }
+  };
   const at = Date.now();
   const state = {
     call,
@@ -407,7 +462,7 @@ async function settlement(store, where, planned, settled) {
     class: planned.class,
     phase: "settled",
     outcome: settled.outcome,
-    changes: settled.changes
+    changes
   };
   const based = settled.snapshot === null ? [] : await nextBase(store, session, run, settled.snapshot);
   const record = { ...found.record, state, version: found.record.version + 1 };
@@ -419,9 +474,9 @@ async function settlement(store, where, planned, settled) {
       part,
       change: "settled",
       outcome: settled.outcome,
-      changes: settled.changes
+      changes
     },
-    ...settled.files.length === 0 ? [] : [{ head: null, kind: "changes", files: settled.files }]
+    ...settled.thread === null ? [] : [{ head: null, kind: "changes", files: settled.thread }]
   ];
   if (found.record.status.kind === "failed" || found.record.status.kind === "settled")
     return [
@@ -448,12 +503,14 @@ async function settlement(store, where, planned, settled) {
   return [...landed.updates, ...based];
 }
 async function baseline(kernel, session, run) {
-  if (await diffBase(kernel.store, session, run) !== null)
-    return;
   const snapshots = await kernel.environments.snapshots(session);
   if (snapshots === null)
-    return;
-  const before = await snapshots.before(run);
+    return null;
+  const seq = await kernel.store.refs.tail(session);
+  const [before, contended] = await Promise.all([
+    snapshots.after(run),
+    anotherChatLive2(kernel, session)
+  ]);
   await attempt2(`Recording run ${run}'s snapshot`, async () => {
     const found = await load2(kernel.store, await kernel.store.refs.get(runRef2(session, run)), decodeRunRecord2);
     if (found === null || found.record.snapshot !== null)
@@ -467,10 +524,7 @@ async function baseline(kernel, session, run) {
     ]);
     return outcome.kind === "set" ? undefined : STALE2;
   });
-}
-async function diffBase(store, session, run) {
-  const found = await load2(store, await store.refs.get(runRef2(session, run)), decodeRunRecord2);
-  return found?.record.lastSnapshot ?? found?.record.snapshot ?? null;
+  return { snapshot: before, seq, contended };
 }
 async function nextBase(store, session, run, to) {
   const found = await load2(store, await store.refs.get(runRef2(session, run)), decodeRunRecord2);
@@ -536,6 +590,11 @@ function createInvocation2(kernel, input) {
         progress: update
       });
     },
+    foreground: {
+      start: (job) => startJob2(kernel, context.origin, input.workspace, { ...job, session }, true),
+      release: () => kernel.jobs.release(session, call),
+      released: input.released ?? new AbortController().signal
+    },
     tools: {
       async execute(name, args, options) {
         const key = options?.key ?? `${calls}`;
@@ -554,7 +613,7 @@ function createInvocation2(kernel, input) {
         });
         return outcome.kind === "parked" ? parkStep2(durable) : outcome;
       },
-      list: () => source.list()
+      list: () => source.list().filter((info) => input.hidden?.has(info.owner) !== true)
     },
     wait: (target) => durable.wait(target),
     memo: (name, compute) => durable.memo(name, compute),

package/dist/chunks/{compose-r7dx7rpz.js → compose-mdwr0er9.js}

@@ -3,24 +3,29 @@ import {
 } from "./compose-q6c7wswc.js";
 import {
   put2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   convertJsonSchema2,
   check2
 } from "./compose-bj54tkph.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-bbhk8vnr.js";
 import {
   MODEL_PREFERENCE2,
+  modelListingRef2,
+  readModelListings2,
+  thinkingPreferenceRef2,
+  readThinkingPreference2,
+  readThinkingPreferences2,
   readModelSelection2
-} from "./compose-dbx6ftbm.js";
+} from "./compose-csh5vv2t.js";
 import {
   closable2
 } from "./compose-zfjxkavf.js";
 import {
   bumpGeneration2
-} from "./compose-064y3n82.js";
+} from "./compose-ae5t6v5b.js";
 
 // src/extend/models.ts
 import { SdkError } from "@nyte-ai/schema";
@@ -81,6 +86,14 @@ function createModelsApi2(kernel, models) {
       bumpGeneration2(kernel);
       return { kind: "set" };
     },
+    async setListing(refs, listing) {
+      if (refs.some((ref) => models.getModel(ref.provider, ref.id) === undefined))
+        return { kind: "unknown-model" };
+      const target = listing === "shown" ? null : await put2(kernel.store, "kv", listing);
+      await commit2(kernel, refs.map((ref) => ({ name: modelListingRef2(ref), target })));
+      bumpGeneration2(kernel);
+      return { kind: "set" };
+    },
     async verify(provider) {
       let verification;
       try {
@@ -109,8 +122,10 @@ function createModelsApi2(kernel, models) {
 async function modelCatalog(kernel, models) {
   const generation = kernel.host.current().catalog;
   const policies = staticPolicies(kernel);
-  const [preferred, credentials] = await Promise.all([
+  const [preferred, remembered, listed, credentials] = await Promise.all([
     readModelSelection2(kernel.store),
+    readThinkingPreferences2(kernel.store),
+    readModelListings2(kernel.store),
     kernel.modelState.read(models)
   ]);
   const providers = models.getProviders().map((provider) => {
@@ -119,13 +134,19 @@ async function modelCatalog(kernel, models) {
     for (const model of catalog)
       if (model.variant?.mode === "fast" && !fast.has(model.variant.base))
         fast.set(model.variant.base, { provider: model.provider, id: model.id });
+    const base = catalog.filter((model) => model.variant === undefined);
+    const listings = Object.fromEntries(base.flatMap((model) => {
+      const listing = listed.get(formatModelKey(model));
+      return listing === undefined ? [] : [[model.id, listing]];
+    }));
     return {
       id: provider.id,
       name: provider.name,
       credential: credentials.get(provider.id) ?? "unknown",
       methods: listLoginMethods(provider),
       limits: readProviderLimits(models, provider.id),
-      models: catalog.filter((model) => model.variant === undefined).map((model) => projectModel(model, fast.get(model.id) ?? null, policies.get(formatModelKey(model)), provider.capabilities))
+      listings,
+      models: base.map((model) => projectModel(model, fast.get(model.id) ?? null, policies.get(formatModelKey(model)), provider.capabilities, remembered.get(formatModelKey(model))))
     };
   });
   const fallback = providers.find((provider) => models.getProvider(provider.id)?.explicitOnly !== true && (provider.credential === "configured" || provider.credential === "verified") && provider.models.length > 0)?.models[0]?.ref ?? null;
@@ -138,7 +159,7 @@ function modelInfo2(models, ref, runtime) {
     return null;
   const policy = runtime.registries.modelContext.list().findLast((entry) => formatModelKey(entry.model) === formatModelKey(ref));
   const fast = catalog.find((entry) => entry.variant?.mode === "fast" && entry.variant.base === model.id);
-  return projectModel(model, fast === undefined ? null : { provider: fast.provider, id: fast.id }, policy, models.getProvider(model.provider)?.capabilities);
+  return projectModel(model, fast === undefined ? null : { provider: fast.provider, id: fast.id }, policy, models.getProvider(model.provider)?.capabilities, undefined);
 }
 function createLogin2(kernel, models, input) {
   let pending = null;
@@ -264,13 +285,13 @@ async function defaultModel(kernel, models) {
   return null;
 }
 var NYTE_LOOP = { steer: true };
-function projectModel(model, fast, policy, capabilities) {
+function projectModel(model, fast, policy, capabilities, remembered) {
   return {
     ref: { provider: model.provider, id: model.id },
     name: model.name,
     reasoning: model.reasoning,
     thinking: acceptedThinkingLevels(model),
-    defaultThinking: defaultThinkingLevel(model),
+    defaultThinking: defaultThinkingLevel(model, remembered),
     fast,
     contextWindow: policy?.contextWindow ?? model.contextWindow,
     compactAt: policy?.compactAt ?? Math.floor(model.contextWindow * 0.8),
@@ -416,7 +437,9 @@ async function resolvePatch(kernel, models, input) {
   if (model === undefined)
     return { kind: "unknown-model", model: ref };
   const issues = [];
-  const thinking = selectThinkingLevel(model, patch.thinking, selected?.thinking);
+  const previous = selected === null ? undefined : models.getModel(selected.model.provider, selected.model.id);
+  const kept = previous !== undefined && formatModelKey(baseRef(previous)) === formatModelKey(baseRef(model)) ? selected?.thinking : undefined;
+  const thinking = await selectThinkingLevel(kernel, model, patch.thinking, kept);
   if (thinking === null)
     issues.push(issue(["thinking"], `${ref.id} does not accept that level.`));
   const settings = { ...selected?.settings, ...patch.settings };
@@ -442,19 +465,53 @@ async function resolvePatch(kernel, models, input) {
     settingsVersion: input.version
   };
 }
-function selectThinkingLevel(model, given, kept) {
+async function selectThinkingLevel(kernel, model, given, kept) {
   const accepted = acceptedThinkingLevels(model);
   if (given !== undefined && given !== null)
     return accepted.includes(given) ? given : null;
   if (given === undefined && kept !== undefined)
     return accepted.includes(kept) ? kept : clampThinkingLevel(model, kept);
-  return defaultThinkingLevel(model);
+  return defaultThinkingLevel(model, await readThinkingPreference2(kernel.store, baseRef(model)));
+}
+function baseRef(model) {
+  return { provider: model.provider, id: model.variant?.base ?? model.id };
 }
 function acceptedThinkingLevels(model) {
   return ["off", ...getSupportedThinkingLevels(model).filter((level) => level !== "off")];
 }
-function defaultThinkingLevel(model) {
-  return model.reasoning ? acceptedThinkingLevels(model).find((level) => level !== "off") ?? "off" : "off";
+function defaultThinkingLevel(model, remembered) {
+  const accepted = acceptedThinkingLevels(model);
+  if (remembered !== undefined && accepted.includes(remembered))
+    return remembered;
+  return model.reasoning ? accepted.find((level) => level !== "off") ?? "off" : "off";
+}
+async function rememberChoice2(kernel, models, choice, scope) {
+  const model = models.getModel(choice.model.provider, choice.model.id);
+  if (model === undefined)
+    return;
+  const base = baseRef(model);
+  const preferred = scope === "model" ? await readModelSelection2(kernel.store) : null;
+  const updates = [
+    ...scope === "model" && (preferred === null || formatModelKey(preferred) !== formatModelKey(choice.model)) ? [
+      {
+        name: MODEL_PREFERENCE2,
+        target: await put2(kernel.store, "kv", {
+          provider: choice.model.provider,
+          id: choice.model.id
+        })
+      }
+    ] : [],
+    ...await readThinkingPreference2(kernel.store, base) === choice.thinking ? [] : [
+      {
+        name: thinkingPreferenceRef2(base),
+        target: await put2(kernel.store, "kv", choice.thinking)
+      }
+    ]
+  ];
+  if (updates.length === 0)
+    return;
+  await commit2(kernel, updates);
+  bumpGeneration2(kernel);
 }
 function sessionScoped(settings) {
   return settings.filter((definition) => definition.scope === "session");
@@ -466,4 +523,4 @@ function issue(path, message) {
   return { severity: "error", path, message };
 }
 
-export { createModelsApi2, modelInfo2, createLogin2, withLimits2, createConfigurationResolver2, settingsVersion2 };
+export { createModelsApi2, modelInfo2, createLogin2, withLimits2, createConfigurationResolver2, settingsVersion2, rememberChoice2 };

package/dist/chunks/{compose-j12n448k.js → compose-nj4nj5n9.js}

@@ -2,7 +2,7 @@ import {
   envelope2,
   decodeRunRecord2,
   decodeCallRecord2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   objectId2
 } from "./compose-q6c7wswc.js";
@@ -15,7 +15,7 @@ import {
   callRef2,
   trustRef2,
   trustTarget2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   waitIndex2,
   wokenIndex2
@@ -410,6 +410,36 @@ var workspaceTrustMoved = {
     });
   }
 };
+var sessionSnapshotDropped = {
+  kind: "schema",
+  name: "2026-10-18-session-snapshot-dropped",
+  sql: { sqlite: [], postgres: [] }
+};
+var changesAsWholeList = {
+  kind: "rewrite",
+  name: "2026-10-20-changes-as-whole-list",
+  rewriteLog(events) {
+    let listed = new Map;
+    return events.map((event) => {
+      if (!isJsonObject(event) || event.kind !== "changes")
+        return null;
+      const logged = event.files;
+      if (!Array.isArray(logged))
+        return null;
+      listed = new Map(listed);
+      for (const file of logged)
+        if (isJsonObject(file) && typeof file.path === "string")
+          listed.set(file.path, file);
+      const files = [...listed.values()];
+      return files.length === logged.length && files.every((file, index) => file === logged[index]) ? null : { ...event, files };
+    });
+  }
+};
+var foldCheckpointsCleared = {
+  kind: "schema",
+  name: "2026-10-20-fold-checkpoints-cleared",
+  sql: { sqlite: ["DELETE FROM fold_checkpoints"], postgres: [] }
+};
 var STORE_STEPS = [
   baseline,
   recordFields,
@@ -429,7 +459,10 @@ var STORE_STEPS = [
   workspaceIsolation,
   foldCheckpoints,
   folderTrust,
-  workspaceTrustMoved
+  workspaceTrustMoved,
+  sessionSnapshotDropped,
+  changesAsWholeList,
+  foldCheckpointsCleared
 ];
 var STORE_VERSION2 = STORE_STEPS.length;
 function assertStoreVersion2(version) {