@nyte-ai/core 0.0.18 → 0.0.19

package/dist/chunks/{compose-kb22bkpt.js → compose-cqpjcx2t.js}

@@ -33,6 +33,9 @@ function endedRunRef2(id, run) {
 function liveRef2(id, run) {
   return `sessions/${id}/live/${run}`;
 }
+function runCallsPrefix2(id, run) {
+  return `sessions/${id}/calls/${run}:`;
+}
 function partRef2(id, part) {
   return `sessions/${id}/parts/${part}`;
 }
@@ -57,6 +60,14 @@ function kvRef2(scope, owner, key) {
 function leaseRef2(id, head) {
   return `sessions/${id}/leases/${head}`;
 }
+var PROCESSES2 = "processes/";
+function processRef2(instance) {
+  return `${PROCESSES2}${instance}`;
+}
+var JOBS2 = "jobs/";
+function jobRef2(id) {
+  return `${JOBS2}${id}`;
+}
 function hostIdentityRef2() {
   return "host/identity";
 }
@@ -64,4 +75,4 @@ function hostPrincipalsRef2() {
   return "host/principals";
 }
 
-export { sessionRef2, parseSessionRef2, parseHeadRef2, headRef2, inboxRef2, seenRef2, runRef2, endedRunRef2, liveRef2, partRef2, receiptRef2, callRef2, workspaceRef2, trustRef2, trustTarget2, kvRef2, leaseRef2, hostIdentityRef2, hostPrincipalsRef2 };
+export { sessionRef2, parseSessionRef2, parseHeadRef2, headRef2, inboxRef2, seenRef2, runRef2, endedRunRef2, liveRef2, runCallsPrefix2, partRef2, receiptRef2, callRef2, workspaceRef2, trustRef2, trustTarget2, kvRef2, leaseRef2, PROCESSES2, processRef2, JOBS2, jobRef2, hostIdentityRef2, hostPrincipalsRef2 };

package/dist/chunks/{compose-dbx6ftbm.js → compose-csh5vv2t.js}

@@ -1,15 +1,53 @@
 import {
   decodeKvValue2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   kvRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 
 // src/store/model-state.ts
-import { ModelRefType } from "@nyte-ai/schema";
+import { ModelRefType, ThinkingType } from "@nyte-ai/schema";
+import { Type } from "typebox";
 import { Value } from "typebox/value";
 var CHECK_INTERVAL_MS = 60000;
 var MODEL_PREFERENCE2 = kvRef2("host", "models", "default");
+var THINKING_PREFERENCES = kvRef2("host", "models", "thinking/");
+var MODEL_LISTINGS = kvRef2("host", "models", "listing/");
+var SavedListingType = Type.Enum(["hidden", "favorite"]);
+function modelListingRef2(model) {
+  return `${MODEL_LISTINGS}${model.provider}/${model.id}`;
+}
+async function readModelListings2(store) {
+  const refs = await store.refs.list(MODEL_LISTINGS);
+  const entries = await Promise.all(refs.map(async (ref) => {
+    if (ref.target === null)
+      return [];
+    const value = decodeKvValue2(await store.objects.get(ref.target));
+    return Value.Check(SavedListingType, value) ? [[ref.name.slice(MODEL_LISTINGS.length), value]] : [];
+  }));
+  return new Map(entries.flat());
+}
+function thinkingPreferenceRef2(model) {
+  return `${THINKING_PREFERENCES}${model.provider}/${model.id}`;
+}
+async function readThinkingPreference2(store, model) {
+  const ref = await store.refs.get(thinkingPreferenceRef2(model));
+  return ref === null || ref.target === null ? undefined : decodeThinking(await store.objects.get(ref.target));
+}
+async function readThinkingPreferences2(store) {
+  const refs = await store.refs.list(THINKING_PREFERENCES);
+  const entries = await Promise.all(refs.map(async (ref) => {
+    if (ref.target === null)
+      return [];
+    const level = decodeThinking(await store.objects.get(ref.target));
+    return level === undefined ? [] : [[ref.name.slice(THINKING_PREFERENCES.length), level]];
+  }));
+  return new Map(entries.flat());
+}
+function decodeThinking(object) {
+  const value = decodeKvValue2(object);
+  return Value.Check(ThinkingType, value) ? value : undefined;
+}
 async function readModelSelection2(store) {
   const ref = await store.refs.get(MODEL_PREFERENCE2);
   const value = ref === null || ref.target === null ? undefined : decodeKvValue2(await store.objects.get(ref.target));
@@ -147,4 +185,4 @@ function createModelState2(changed) {
   };
 }
 
-export { MODEL_PREFERENCE2, readModelSelection2, createModelState2 };
+export { MODEL_PREFERENCE2, modelListingRef2, readModelListings2, thinkingPreferenceRef2, readThinkingPreference2, readThinkingPreferences2, readModelSelection2, createModelState2 };

package/dist/chunks/{compose-jc22rsz4.js → compose-dbsn3bsy.js}

@@ -4,14 +4,14 @@ import {
 import {
   walkCommitPath2,
   readPositionCommit2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   committed2,
   setTurn2,
   stale2,
   reuse2,
   toPartMessageId2
-} from "./compose-cq1zx4gp.js";
+} from "./compose-h14pmqv3.js";
 
 // src/fold/paths.ts
 function finish2(state, draft) {

package/dist/chunks/{compose-rehp8epe.js → compose-eemt6sea.js}

@@ -1,9 +1,9 @@
 import {
   decodePartRecord2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   partRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   dev2
 } from "./compose-n116fnmp.js";
@@ -11,17 +11,17 @@ import {
   load2,
   put2,
   readCall2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   storedAnswer2
-} from "./compose-drdej9yt.js";
+} from "./compose-c2rnebv0.js";
 import {
   waitIndex2,
   wokenIndex2
 } from "./compose-0wq555bd.js";
 import {
   changeCall2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-pnsvwd3m.js";
 import {
   holdLease2
 } from "./compose-vzvm76dn.js";
@@ -30,7 +30,7 @@ import {
   readParkedWait2,
   waitingOn2,
   lapsed2
-} from "./compose-ef936rsa.js";
+} from "./compose-ks2rdteq.js";
 
 // src/engine/durable.ts
 import { isJson, isJsonObject, SdkError } from "@nyte-ai/schema";
@@ -88,7 +88,7 @@ async function runStep2(kernel, input) {
     dev2("durable", "replayed", { session, call });
     return { kind: "done", value: read(record.result) };
   }
-  if (!opened.wrote && input.replay === "never") {
+  if (!opened.wrote && record.replay === "never") {
     return { kind: "interrupted", value: await settle({ kind: "interrupted" }) };
   }
   const writes = [];

package/dist/chunks/{compose-r7dx7rpz.js → compose-exfx5b4d.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-pnsvwd3m.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-r1pxdxbw.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-p3q14yt1.js → compose-g2a1f1yx.js}

@@ -1,7 +1,7 @@
 import {
   headRef2,
   partRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   EMPTY_REVISION2,
   STALE2,
@@ -13,16 +13,16 @@ import {
   walkCommitPath2,
   toCommitObjectId2,
   guard2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-pnsvwd3m.js";
 import {
   withFold2
-} from "./compose-6vf6dkk2.js";
+} from "./compose-xhtgytrh.js";
 import {
   fence2
-} from "./compose-9m19b27b.js";
+} from "./compose-gvrqkyn4.js";
 
 // src/engine/branch-summary.ts
 import { asId } from "@nyte-ai/schema";

package/dist/chunks/compose-gvm49f4b.js

@@ -0,0 +1,155 @@
+import {
+  envelope2
+} from "./compose-gxjc6vz9.js";
+import {
+  PROCESSES2,
+  processRef2
+} from "./compose-cqpjcx2t.js";
+import {
+  dev2
+} from "./compose-n116fnmp.js";
+
+// src/engine/presence.ts
+import { SdkError } from "@nyte-ai/schema";
+var BEAT_MS2 = 5000;
+var LAPSE_MS2 = 20000;
+var FORGET_MS = 10 * 60000;
+var GAP_MS = 2 * BEAT_MS2;
+var REVOKED2 = "Another Nyte took over this one's work while it was paused, so this host stopped; it reopens on its own.";
+async function openPresence2(raw, input) {
+  const name = processRef2(input.instance);
+  const body = envelope2("process", {
+    instance: input.instance,
+    holder: input.holder,
+    label: input.member.label,
+    pid: input.member.pid,
+    capabilities: [...input.member.capabilities],
+    startedAt: Date.now()
+  }, Date.now());
+  const target = await raw.objects.put(body);
+  const registered = await raw.refs.set([{ name, target, expect: "absent" }]);
+  if (registered.kind !== "set")
+    throw new SdkError("internal", `${name} already exists; process instances must be unique.`);
+  let revision = registered.revisions[0];
+  const revocation = new AbortController;
+  const seen = new Map;
+  let wroteAt = performance.now();
+  let beating = false;
+  let closed = false;
+  const revoke = () => {
+    if (revocation.signal.aborted)
+      return;
+    dev2("presence", "revoked", { instance: input.instance });
+    clearInterval(timer);
+    revocation.abort();
+  };
+  const wrote = () => {
+    const now = performance.now();
+    if (now - wroteAt > GAP_MS)
+      for (const entry of seen.values())
+        entry.since = now;
+    wroteAt = now;
+  };
+  const writable = (now) => now - wroteAt <= GAP_MS;
+  const observe = (instance, current, now) => {
+    const known = seen.get(instance);
+    if (known !== undefined && known.revision === current)
+      return known;
+    const fresh = { revision: current, since: now };
+    seen.set(instance, fresh);
+    return fresh;
+  };
+  const beat = async () => {
+    if (beating || closed || revocation.signal.aborted)
+      return;
+    beating = true;
+    try {
+      const outcome = await raw.refs.set([{ name, target, expect: revision }]);
+      if (outcome.kind !== "set")
+        return revoke();
+      revision = outcome.revisions[0];
+      wrote();
+    } catch (error) {
+      dev2("presence", "beat failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      beating = false;
+    }
+  };
+  const timer = setInterval(() => void beat(), BEAT_MS2);
+  const store = {
+    ...raw,
+    refs: {
+      ...raw.refs,
+      async set(updates) {
+        if (revocation.signal.aborted)
+          throw new SdkError("unavailable", REVOKED2);
+        const outcome = await raw.refs.set(updates.map((update) => ({ ...update, fences: [...update.fences ?? [], name] })));
+        if (outcome.kind === "fenced" && outcome.name === name) {
+          revoke();
+          throw new SdkError("unavailable", REVOKED2);
+        }
+        return outcome;
+      }
+    }
+  };
+  return {
+    instance: input.instance,
+    member: input.member,
+    store,
+    revoked: revocation.signal,
+    async holder(instance) {
+      if (instance === input.instance)
+        return { kind: "me" };
+      const ref = await raw.refs.get(processRef2(instance));
+      const now = performance.now();
+      if (ref === null) {
+        seen.delete(instance);
+        return { kind: "absent" };
+      }
+      const lapsed = now - observe(instance, ref.revision, now).since;
+      return writable(now) && lapsed >= LAPSE_MS2 ? { kind: "dead", name: ref.name, expect: ref.revision } : { kind: "alive", until: Date.now() + Math.max(LAPSE_MS2 - lapsed, BEAT_MS2) };
+    },
+    async sweep() {
+      const listed = await raw.refs.list(PROCESSES2);
+      const now = performance.now();
+      const present = new Set;
+      for (const ref of listed) {
+        const instance = ref.name.slice(PROCESSES2.length);
+        present.add(instance);
+        if (instance === input.instance)
+          continue;
+        const known = observe(instance, ref.revision, now);
+        if (!writable(now) || now - known.since < FORGET_MS)
+          continue;
+        await raw.refs.set([{ name: ref.name, target: null, expect: ref.revision }]);
+        seen.delete(instance);
+      }
+      for (const instance of seen.keys())
+        if (!present.has(instance))
+          seen.delete(instance);
+      if (!present.has(input.instance) && !closed)
+        revoke();
+    },
+    async close(leases = []) {
+      if (closed)
+        return;
+      closed = true;
+      clearInterval(timer);
+      if (revocation.signal.aborted)
+        return;
+      const leaving = [
+        { name, target: null, expect: revision },
+        ...leases.map((lease) => ({ name: lease.name, target: null, expect: lease.expect }))
+      ];
+      const left = await raw.refs.set(leaving).catch(() => null);
+      if (left?.kind !== "set")
+        await raw.refs.set([{ name, target: null, expect: revision }]).catch(() => {
+          return;
+        });
+    }
+  };
+}
+
+export { BEAT_MS2, LAPSE_MS2, REVOKED2, openPresence2 };

package/dist/chunks/{compose-9m19b27b.js → compose-gvrqkyn4.js}

@@ -1,11 +1,11 @@
 import {
   decodeRunRecord2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   inboxRef2,
   runRef2,
   liveRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   STALE2,
   load2,
@@ -17,20 +17,20 @@ import {
   put2,
   attempt2,
   readCall2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   stoppedParts2
-} from "./compose-drdej9yt.js";
+} from "./compose-c2rnebv0.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-pnsvwd3m.js";
 import {
   liveParts2,
   readRunEnd2
-} from "./compose-6vf6dkk2.js";
+} from "./compose-xhtgytrh.js";
 import {
   readParkedWait2
-} from "./compose-ef936rsa.js";
+} from "./compose-ks2rdteq.js";
 
 // src/engine/fence.ts
 var FENCED2 = { class: "aborted", message: "Stopped." };

package/dist/chunks/{compose-1jz2j92f.js → compose-gxjc6vz9.js}

@@ -8,6 +8,7 @@ import {
   cyclicWithJson,
   HeadInfoType,
   idSchema,
+  JobEndType,
   isJsonObject,
   JsonObjectType,
   JsonType,
@@ -71,7 +72,9 @@ var RunRecordType = record({
   usage: nullable(typed()(UsageType)),
   requests: Type.Number(),
   response: Type.Optional(typed()(UsageType)),
-  parked: list(idSchema())
+  parked: list(idSchema()),
+  interrupted: Type.Optional(record({ count: Type.Number(), mark: Type.String() })),
+  requires: Type.Optional(list(Type.String()))
 });
 var PartRecordType = record({
   id: idSchema(),
@@ -174,6 +177,27 @@ var LeaseType = record({
   instance: Type.String(),
   expiresAt: Type.Number()
 });
+var ProcessRecordType = record({
+  instance: Type.String(),
+  holder: idSchema(),
+  label: Type.String(),
+  pid: nullable(Type.Number()),
+  capabilities: list(Type.String()),
+  startedAt: Type.Number()
+});
+var JobRecordType = record({
+  id: idSchema(),
+  instance: Type.String(),
+  workspace: idSchema(),
+  session: idSchema(),
+  head: idSchema(),
+  startedBy: nullable(idSchema()),
+  title: Type.String(),
+  command: Type.String(),
+  startedAt: Type.Number(),
+  end: nullable(typed()(JobEndType)),
+  endedAt: nullable(Type.Number())
+});
 var HostIdentityType = record({ id: idSchema(), createdAt: Type.Number() });
 var STORED_RECORD_TYPES2 = {
   session: SessionRecordType,
@@ -186,6 +210,8 @@ var STORED_RECORD_TYPES2 = {
   workspace: WorkspaceRecordType,
   trust: TrustRecordType,
   lease: LeaseType,
+  process: ProcessRecordType,
+  job: JobRecordType,
   call: CallRecordType,
   principals: PrincipalRecordType,
   identity: HostIdentityType
@@ -205,6 +231,8 @@ var decodeTrustRecord2 = decoder("trust", TrustRecordType);
 var decodeCallRecord2 = decoder("call", CallRecordType);
 var decodePrincipalRecord2 = decoder("principals", PrincipalRecordType);
 var decodeLease2 = decoder("lease", LeaseType);
+var decodeProcessRecord2 = decoder("process", ProcessRecordType);
+var decodeJobRecord2 = decoder("job", JobRecordType);
 var decodeHostIdentity2 = decoder("identity", HostIdentityType);
 function decodeKvValue2(object) {
   return isJsonObject(object) && object.kind === "kv" ? object.body : undefined;
@@ -226,4 +254,4 @@ function nullable(schema) {
   return Type.Union([schema, Type.Null()]);
 }
 
-export { STORED_RECORD_TYPES2, envelope2, decodeSessionRecord2, decodeCommitRecord2, decodeRunRecord2, decodeSeenRecord2, decodeInboxRecord2, decodePartRecord2, decodeReceiptRecord2, decodeWorkspaceRecord2, decodeTrustRecord2, decodeCallRecord2, decodePrincipalRecord2, decodeLease2, decodeHostIdentity2, decodeKvValue2 };
+export { STORED_RECORD_TYPES2, envelope2, decodeSessionRecord2, decodeCommitRecord2, decodeRunRecord2, decodeSeenRecord2, decodeInboxRecord2, decodePartRecord2, decodeReceiptRecord2, decodeWorkspaceRecord2, decodeTrustRecord2, decodeCallRecord2, decodePrincipalRecord2, decodeLease2, decodeProcessRecord2, decodeJobRecord2, decodeHostIdentity2, decodeKvValue2 };

package/dist/chunks/{compose-s2aew2c9.js → compose-gxvetm0j.js}

@@ -3,7 +3,7 @@ import {
 } from "./compose-q6c7wswc.js";
 import {
   workspaceRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   dev2
 } from "./compose-n116fnmp.js";
@@ -11,19 +11,19 @@ import {
   STALE2,
   put2,
   attempt2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-pnsvwd3m.js";
 import {
   readWorkspace2,
   workspaceRecords2
-} from "./compose-0bpspysf.js";
+} from "./compose-qknd62yj.js";
 import {
   sessionsOn2,
   byIdentity2,
   changed2
-} from "./compose-eqr5qwp1.js";
+} from "./compose-tb5ywdfk.js";
 
 // src/env/worktrees.ts
 import { asId, SdkError } from "@nyte-ai/schema";

package/dist/chunks/{compose-cq1zx4gp.js → compose-h14pmqv3.js}

@@ -1,6 +1,6 @@
 import {
   START2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 
 // src/fold/draft.ts
 import { asId } from "@nyte-ai/schema";