@nyte-ai/core 0.0.18 → 0.0.21

package/dist/chunks/{compose-eqr5qwp1.js → compose-d1m94kzq.js}

@@ -1,6 +1,6 @@
 import {
   decodeRunRecord2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   objectId2
 } from "./compose-q6c7wswc.js";
@@ -8,44 +8,49 @@ import {
   runRef2,
   endedRunRef2,
   workspaceRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   MAIN2,
   STALE2,
   load2,
   readSession2,
   liveRuns2,
+  threadStart2,
   put2,
   attempt2,
   listSessionRecords2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
+import {
+  commit2
+} from "./compose-bbhk8vnr.js";
 import {
   latest2,
   closable2,
   coalesce2
 } from "./compose-zfjxkavf.js";
-import {
-  commit2
-} from "./compose-xpfr4wt3.js";
 import {
   createJobs2,
   jobHandle2
-} from "./compose-yn2et568.js";
+} from "./compose-nkxwrphm.js";
 import {
   inspectWorkspaceAvailability2,
   readWorkspace2,
   workspaceRecords2
-} from "./compose-0bpspysf.js";
+} from "./compose-4ppmas7g.js";
 import {
   readFolderTrust2,
   decideTrust2
-} from "./compose-5w5bbakh.js";
+} from "./compose-8pp3vtv0.js";
 import {
   dropScans2
-} from "./compose-y478gv6x.js";
+} from "./compose-jmmyw9hd.js";
 import {
   mcpApi2
-} from "./compose-1gd9vkye.js";
+} from "./compose-gj2ypr7q.js";
+import {
+  readAttributedPaths2,
+  ownedChanges2
+} from "./compose-yfcb6w2h.js";
 
 // src/env/workspaces.ts
 import { asId, SdkError } from "@nyte-ai/schema";
@@ -264,13 +269,13 @@ function workspaceHandle2(kernel, context, id, client = null) {
     },
     jobs: createJobs2(kernel, context, id),
     job: (job) => jobHandle2(kernel, job),
-    async changes(run) {
+    async changes(source) {
       const found = await snapshots();
-      const range = await runSnapshots(kernel.store, id, run);
-      return found.diff(range?.from ?? await found.before(run), range?.to ?? await found.after(run));
+      const range = await changeRange(kernel.store, id, source, found);
+      return source.kind === "session" ? ownedChanges2(kernel.store, found, source.session, range.to) : found.diff(range.from, range.to);
     },
-    patches(run, paths, options) {
-      return streamWorkspacePatches(kernel, { workspace: id, run, paths, options, snapshots });
+    patches(source, paths, options) {
+      return streamWorkspacePatches(kernel, { workspace: id, source, paths, options, snapshots });
     },
     files: async () => (await capabilities()).files,
     git: async () => (await capabilities()).git,
@@ -314,14 +319,12 @@ function settle2(kernel, session, workspace, activation) {
   changed2(kernel, workspace);
 }
 async function* streamWorkspacePatches(kernel, input) {
-  const { run, options } = input;
+  const { source, options } = input;
   const snapshots = await input.snapshots();
-  const range = await runSnapshots(kernel.store, input.workspace, run);
-  const from = range?.from ?? await snapshots.before(run);
-  const to = range?.to ?? await snapshots.after(run);
+  const { from, to } = await changeRange(kernel.store, input.workspace, source, snapshots);
   let statuses = null;
   const caches = kernel.workspaceState.patches;
-  const key = JSON.stringify([input.workspace, run, options?.ignoreWhitespace === true]);
+  const key = JSON.stringify([input.workspace, source, options?.ignoreWhitespace === true]);
   const previous = caches.get(key);
   const current = previous?.revision === to ? previous : { revision: to, slots: new Map };
   caches.delete(key);
@@ -332,7 +335,8 @@ async function* streamWorkspacePatches(kernel, input) {
     caches.delete(oldest);
   }
   const held = previous === current ? null : previous ?? null;
-  const paths = [...new Set(input.paths)];
+  const attributed = source.kind === "session" ? await readAttributedPaths2(kernel.store, source.session) : null;
+  const paths = [...new Set(input.paths)].filter((path) => attributed === null || attributed.has(path));
   const unread = paths.filter((path) => !current.slots.has(path));
   const limit = limiter(PATCH_READS);
   const mine = new Map;
@@ -424,6 +428,42 @@ function limiter(size) {
       queue.push(run);
   });
 }
+async function changeRange(store, workspace, source, snapshots) {
+  switch (source.kind) {
+    case "run": {
+      const range = await runSnapshots(store, workspace, source.run);
+      return {
+        from: range?.from ?? await snapshots.before(source.run),
+        to: range?.to ?? await snapshots.after(source.run)
+      };
+    }
+    case "session":
+      return sessionSnapshots(store, source.session, snapshots);
+    default: {
+      const _exhaustive = source;
+      return _exhaustive;
+    }
+  }
+}
+async function sessionSnapshots(store, session, snapshots) {
+  const [found, from] = await Promise.all([
+    readSession2(store, session),
+    threadStart2(store, session)
+  ]);
+  if (found === null || from === null)
+    throw new SdkError("unavailable", `No run of session ${session} has snapshotted its workspace.`);
+  const [live] = await liveRuns2(store, session);
+  if (live !== undefined)
+    return { from, to: await snapshots.after(live.record.view.id) };
+  const [last] = found.record.heads.flatMap((head) => head.lastRun === null ? [] : [head.lastRun]).toSorted((left, right) => right.endedAt - left.endedAt);
+  if (last === undefined)
+    return { from, to: from };
+  const ended = await load2(store, await store.refs.get(endedRunRef2(session, last.id)), decodeRunRecord2);
+  return {
+    from,
+    to: ended?.record.lastSnapshot ?? ended?.record.snapshot ?? await snapshots.after(last.id)
+  };
+}
 async function runSnapshots(store, workspace, run) {
   for (const session of await sessionsOn2(store, workspace)) {
     const live = await load2(store, await store.refs.get(runRef2(session, run)), decodeRunRecord2);

package/dist/chunks/{compose-drdej9yt.js → compose-d95fwwvw.js}

@@ -3,22 +3,22 @@ import {
 } from "./compose-bj54tkph.js";
 import {
   tool2
-} from "./compose-bjx8s01m.js";
+} from "./compose-fqsqjbrf.js";
 import {
   decodePartRecord2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   parseSessionRef2,
   headRef2,
   partRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   load2,
   readRefExpectation2,
   put2,
   toCommitObjectId2,
   readCall2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 
 // src/store/parts.ts
 import { asId } from "@nyte-ai/schema";

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-s2aew2c9.js → compose-e2fyz3xc.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-bbhk8vnr.js";
 import {
   readWorkspace2,
   workspaceRecords2
-} from "./compose-0bpspysf.js";
+} from "./compose-4ppmas7g.js";
 import {
   sessionsOn2,
   byIdentity2,
   changed2
-} from "./compose-eqr5qwp1.js";
+} from "./compose-d1m94kzq.js";
 
 // src/env/worktrees.ts
 import { asId, SdkError } from "@nyte-ai/schema";

package/dist/chunks/{compose-gg8b9b21.js → compose-e9f6nrwp.js}

@@ -1,7 +1,10 @@
+import {
+  CORE_CONTEXT2
+} from "./compose-5z835ej2.js";
 import {
   decodeSessionRecord2,
   decodeSeenRecord2
-} from "./compose-1jz2j92f.js";
+} from "./compose-gxjc6vz9.js";
 import {
   objectId2
 } from "./compose-q6c7wswc.js";
@@ -10,7 +13,7 @@ import {
   headRef2,
   seenRef2,
   workspaceRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   MAIN2,
   STALE2,
@@ -24,7 +27,7 @@ import {
   attempt2,
   coversRecord2,
   sessionEvent2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   traced2,
   followTrace2,
@@ -32,10 +35,10 @@ import {
 } from "./compose-sd0stm97.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-bbhk8vnr.js";
 import {
   stopRun2
-} from "./compose-9m19b27b.js";
+} from "./compose-w6zb11k1.js";
 import {
   refusalError2,
   staticContributions2
@@ -44,17 +47,17 @@ import {
   receiptHandle2,
   sendReceipt2,
   withdraw2
-} from "./compose-52afaf3v.js";
+} from "./compose-fnncnk81.js";
 import {
   sendNow2,
   admitDeciding2
-} from "./compose-cdy4q5mv.js";
+} from "./compose-t9fcqtby.js";
 import {
   recordAcquisition2
-} from "./compose-rehp8epe.js";
+} from "./compose-byse0eqj.js";
 import {
   runHandle2
-} from "./compose-vmhv4e00.js";
+} from "./compose-qxfq6dn9.js";
 import {
   latest2,
   closable2,
@@ -63,29 +66,29 @@ import {
 import {
   isolateWorkspace2,
   releaseWorktree2
-} from "./compose-s2aew2c9.js";
+} from "./compose-e2fyz3xc.js";
 import {
   releaseStart2,
   stopStart2,
   discardSession2
-} from "./compose-dc2ns6gd.js";
+} from "./compose-a8ddt55n.js";
 import {
   runCommand2,
   completeSessionCommand2
-} from "./compose-064y3n82.js";
+} from "./compose-ae5t6v5b.js";
 import {
   configure2
-} from "./compose-xd0kdp3t.js";
+} from "./compose-753gc057.js";
 import {
   headHandle2,
   createHead2,
   mergeHead2,
   removeHead2
-} from "./compose-xtkavyrw.js";
+} from "./compose-1r0wr5dc.js";
 import {
   createPart2,
   partHandle2
-} from "./compose-wgphshsn.js";
+} from "./compose-r8tz1xfj.js";
 
 // src/api/session.ts
 import { asId, SdkError } from "@nyte-ai/schema";
@@ -301,11 +304,11 @@ async function start(kernel, context, input) {
   const trace = (origin === null ? null : followedTrace2(origin.session)) ?? receipt;
   followTrace2(id, trace);
   return traced2("host.admit", trace, { session: id }, async () => {
-    await attempt2(`Starting ${id}`, async () => {
+    const chosen = await attempt2(`Starting ${id}`, async () => {
       if (await readSession2(kernel.store, id) !== null) {
         const started = (await readReceipt2(kernel.store, id, receipt))?.record;
         if (started?.kind === "send" && started.digest === digest)
-          return id;
+          return null;
         throw new SdkError("invalid", `Session ${id} already exists.`);
       }
       const parent = input.parent === undefined ? null : await requireSession2(kernel.store, input.parent);
@@ -356,9 +359,11 @@ async function start(kernel, context, input) {
           principal: context.principal
         })
       ]);
-      return outcome.kind === "set" ? id : STALE2;
+      return outcome.kind === "set" ? selected : STALE2;
     });
     await releaseStart2(kernel, context, id);
+    if (chosen !== null && context !== CORE_CONTEXT2 && origin === null && context.authority.has("owner"))
+      await kernel.rememberChoice(chosen, "model");
     return id;
   });
 }

package/dist/chunks/{compose-52afaf3v.js → compose-fnncnk81.js}

@@ -1,10 +1,10 @@
 import {
   LOCAL2
-} from "./compose-mryw0674.js";
+} from "./compose-5z835ej2.js";
 import {
   inboxRef2,
   receiptRef2
-} from "./compose-kb22bkpt.js";
+} from "./compose-cqpjcx2t.js";
 import {
   STALE2,
   readReceipt2,
@@ -13,19 +13,19 @@ import {
   readRefExpectation2,
   put2,
   attempt2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   commit2
-} from "./compose-xpfr4wt3.js";
+} from "./compose-bbhk8vnr.js";
 import {
   withFold2
-} from "./compose-6vf6dkk2.js";
+} from "./compose-xhtgytrh.js";
 import {
   waitFor2
-} from "./compose-ef936rsa.js";
+} from "./compose-bz70g01d.js";
 import {
   stopRun2
-} from "./compose-9m19b27b.js";
+} from "./compose-w6zb11k1.js";
 
 // src/engine/receipts.ts
 import { asId, SdkError } from "@nyte-ai/schema";

package/dist/chunks/{compose-bjx8s01m.js → compose-fqsqjbrf.js}

@@ -44,7 +44,7 @@ var thinking2 = definePart2({
 var tool2 = definePart2({
   kind: "tool",
   state: ToolPartStateSchema,
-  actions: { stop: { input: EMPTY_INPUT } },
+  actions: { stop: { input: EMPTY_INPUT }, background: { input: EMPTY_INPUT } },
   fallback: (state, { id }) => `${clip(state.name)} ${state.phase}${state.phase === "settled" ? ` ${state.outcome.kind}` : ""} [${id}]`
 });
 var compaction2 = definePart2({

package/dist/chunks/{compose-1gd9vkye.js → compose-gj2ypr7q.js}

@@ -1,15 +1,15 @@
 import {
   requireSession2
-} from "./compose-n10w4nkk.js";
+} from "./compose-vn7b7fdj.js";
 import {
   forwarded2
 } from "./compose-zfjxkavf.js";
 import {
   readWorkspace2
-} from "./compose-0bpspysf.js";
+} from "./compose-4ppmas7g.js";
 import {
   projectTrust2
-} from "./compose-5w5bbakh.js";
+} from "./compose-8pp3vtv0.js";
 
 // src/env/mcp.ts
 import { SdkError } 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-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-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";