@nyte-ai/host 0.0.23 → 0.0.25-beta.1

package/dist/src/local/provider.js

@@ -1,7 +1,7 @@
 import {
   localProvider2
-} from "../../chunks/canvas-preview-e3vnkkc5.js";
-import"../../chunks/canvas-preview-2jwbe14k.js";
+} from "../../chunks/canvas-preview-9bxhwjrh.js";
+import"../../chunks/canvas-preview-bg63k8n7.js";
 import"../../chunks/canvas-preview-5ekjx6sw.js";
 import"../../chunks/canvas-preview-8xc0vn7v.js";
 import"../../chunks/canvas-preview-1sq7z9jq.js";

package/dist/src/local/worktrees.d.ts

@@ -22,11 +22,15 @@ export declare function hasBranch(cwd: string, name: string, options?: {
 }): Promise<boolean>;
 /**
  * Returns git worktrees for local workspaces (`git`, default `git` on the
- * PATH), each under `<home>/.nyte/worktrees/<repository>/<slug>` on the branch
- * `nyte/<slug>`, the slug the title's words and a hash of the name.
+ * PATH), each under `<home>/.nyte/worktrees/<repository>/<branch>` on a branch
+ * named by `branchName`: at most three hyphenated words from the title.
  *
  * `create` refuses a folder outside a repository or one without a commit, then
- * answers the worktree already on that branch, or adds one from HEAD and
+ * answers the worktree on the branch whose `branch.<branch>.nyte-session`
+ * config is `name`, or claims the first name with no folder or listed worktree
+ * at its path by creating its branch at HEAD (git refuses an existing branch,
+ * which also settles a race with a concurrent create: the loser tries the next
+ * name), records `name` in that config, and adds a worktree for it; then it
  * copies the workspace's uncommitted changes in: the worktree's tracked and
  * untracked files, ignored ones aside, are written to a tree through a
  * temporary index seeded from the real one (which is never touched), and the

package/dist/src/local/worktrees.js

@@ -3,9 +3,8 @@ import {
   addWorktree2,
   hasBranch2,
   localWorktrees2
-} from "../../chunks/canvas-preview-2jwbe14k.js";
+} from "../../chunks/canvas-preview-bg63k8n7.js";
 import"../../chunks/canvas-preview-bxnqt8cd.js";
-import"../../chunks/canvas-preview-0nq75h9k.js";
 export {
   addWorktree2 as addWorktree,
   hasBranch2 as hasBranch,

package/dist/src/open.js

@@ -1,13 +1,13 @@
 import {
   openHost2
-} from "../chunks/canvas-preview-ayayyd43.js";
+} from "../chunks/canvas-preview-dt89p9pm.js";
 import"../chunks/canvas-preview-4e0pxa32.js";
 import"../chunks/canvas-preview-y5y6ghaw.js";
 import"../chunks/canvas-preview-ec2mt7es.js";
 import"../chunks/canvas-preview-befkjea2.js";
 import"../chunks/canvas-preview-9aqczacs.js";
-import"../chunks/canvas-preview-e3vnkkc5.js";
-import"../chunks/canvas-preview-2jwbe14k.js";
+import"../chunks/canvas-preview-9bxhwjrh.js";
+import"../chunks/canvas-preview-bg63k8n7.js";
 import"../chunks/canvas-preview-5ekjx6sw.js";
 import"../chunks/canvas-preview-8xc0vn7v.js";
 import"../chunks/canvas-preview-1sq7z9jq.js";
@@ -26,10 +26,10 @@ import"../chunks/canvas-preview-s94ebwf5.js";
 import"../chunks/canvas-preview-kdqgrstc.js";
 import"../chunks/canvas-preview-mstbvwz3.js";
 import"../chunks/canvas-preview-zaaj99wd.js";
-import"../chunks/canvas-preview-whfdhma6.js";
-import"../chunks/canvas-preview-9e15hp6q.js";
-import"../chunks/canvas-preview-d97wvref.js";
-import"../chunks/canvas-preview-gm0frf4b.js";
+import"../chunks/canvas-preview-8sv3j0vt.js";
+import"../chunks/canvas-preview-da6dwy05.js";
+import"../chunks/canvas-preview-1r9sgbj3.js";
+import"../chunks/canvas-preview-2yzyt077.js";
 import"../chunks/canvas-preview-rp4x6y1h.js";
 import"../chunks/canvas-preview-skzwvw4d.js";
 import"../chunks/canvas-preview-bxnqt8cd.js";

package/dist/src/serve/binding.d.ts

@@ -34,6 +34,5 @@ export type Binding = CallBinding & FrameBinding & ByteBinding & OutputBinding;
 export type BindingOptions = {
     readonly server: ServerHost;
 };
-/** Returns each row bound to the call it names: ids bind handles on the connection, handles returned become ids, `Set`s and `Map`s become their wire forms; `head.move`, `files.batch` and `browser.open` go through the server port's wire operations with their wire id (§40o, §40x). `head.watch` sends the head's view from the host's fold whole, then each later view as its changes (`viewFrames`), the core watch marking the principal's seen tip (§40a, §54a); `sessions.watch` sends the list whole, then each later list as its order and changed rows (`sessionsFrames`). Authority is the caller's gate: the server checks each row's before binding. */
 export declare function bindConnection(connection: Connection, options: BindingOptions): Binding;
 export {};

package/dist/src/serve/binding.js

@@ -1,6 +1,6 @@
 import {
   bindConnection2
-} from "../../chunks/canvas-preview-gm0frf4b.js";
+} from "../../chunks/canvas-preview-2yzyt077.js";
 export {
   bindConnection2 as bindConnection
 };

package/dist/src/serve/handler.js

@@ -1,7 +1,7 @@
 import {
   createHandler2
-} from "../../chunks/canvas-preview-d97wvref.js";
-import"../../chunks/canvas-preview-gm0frf4b.js";
+} from "../../chunks/canvas-preview-1r9sgbj3.js";
+import"../../chunks/canvas-preview-2yzyt077.js";
 import"../../chunks/canvas-preview-rp4x6y1h.js";
 export {
   createHandler2 as createHandler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyte-ai/host",
-  "version": "0.0.23",
+  "version": "0.0.25-beta.1",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -79,14 +79,6 @@
     "./usage-worker": {
       "types": "./dist/src/usage-worker.d.ts",
       "import": "./dist/src/usage-worker.js"
-    },
-    "./deploy/cloudflare": {
-      "types": "./dist/src/deploy/cloudflare/worker.d.ts",
-      "import": "./dist/src/deploy/cloudflare/worker.js"
-    },
-    "./deploy/vercel": {
-      "types": "./dist/src/deploy/vercel/nitro.config.d.ts",
-      "import": "./dist/src/deploy/vercel/nitro.config.js"
     }
   },
   "publishConfig": {
@@ -96,11 +88,11 @@
   "dependencies": {
     "@earendil-works/pi-mcp": "^1.3.0",
     "@lydell/node-pty": "^1.2.0-beta.15",
-    "@nyte-ai/ai": "0.0.23",
-    "@nyte-ai/core": "0.0.23",
-    "@nyte-ai/plugin": "0.0.23",
-    "@nyte-ai/protocol": "0.0.23",
-    "@nyte-ai/schema": "0.0.23",
+    "@nyte-ai/ai": "0.0.25-beta.1",
+    "@nyte-ai/core": "0.0.25-beta.1",
+    "@nyte-ai/plugin": "0.0.25-beta.1",
+    "@nyte-ai/protocol": "0.0.25-beta.1",
+    "@nyte-ai/schema": "0.0.25-beta.1",
     "@silvia-odwyer/photon": "^0.3.3",
     "fflate": "^0.8.3",
     "ignore": "^7.0.13",
@@ -113,29 +105,14 @@
     "@types/node": "^26.6.5",
     "@types/pg": "^8.23.1",
     "fast-check": "^4.10.2",
-    "nitro": "^3.0.260903-beta",
-    "typescript": "6.0.3",
-    "vitest": "^5.0.5",
-    "workflow": "^5.2.3"
-  },
-  "peerDependencies": {
-    "nitro": "^3.0.260903-beta",
-    "workflow": "^5.2.3"
-  },
-  "peerDependenciesMeta": {
-    "nitro": {
-      "optional": true
-    },
-    "workflow": {
-      "optional": true
-    }
+    "vitest": "^5.0.5"
   },
   "engines": {
     "node": ">=26.4.0"
   },
   "scripts": {
     "clean": "rm -rf node_modules .turbo",
-    "typecheck": "tsrs --noEmit && tsrs --noEmit -p src/deploy/vercel",
+    "typecheck": "tsc --noEmit",
     "test": "vitest --run",
     "check:store": "node scripts/check-store.ts",
     "build:package": "bun ../../scripts/sdk-packages.mjs build host"

package/src/durable-object.ts

@@ -44,7 +44,7 @@ const ROW_LIMIT = 2_000_000;
 
 const encoder = new TextEncoder();
 
-/** Returns a `Store` over a Durable Object's SQLite storage, node-free, with the sqlite store's tables, row helpers (`store-rows.ts`) and semantics (§41f): `objects(id TEXT PRIMARY KEY, body TEXT NULL, bytes BLOB NULL)`, `refs(name TEXT PRIMARY KEY, target TEXT NULL, revision TEXT NOT NULL)` and `log(session TEXT, seq INTEGER, at INTEGER, event TEXT, PRIMARY KEY (session, seq))`, brought to core's `STORE_VERSION` by `migrateStore` on first `open()`, each commit one `transactionSync` and no backup; the open rejects with `SdkError("unavailable")` for a store a newer Nyte migrated. `put` ids the value with core's `objectId` and stores its JSON once; `putBlob` buffers the stream, ids it with `blobId` and stores the bytes once as an `ArrayBuffer`; an object and a blob that share an id share the row, each column filled once; `blob` reads the bytes back with their size and a null mime; a body, blob or logged event past the Durable Object's 2 MB row limit throws `SdkError("invalid")` before anything is written (§42k). `refs.set` runs inside one `transactionSync` with no await between its reads and writes, first rejecting with `SdkError("unavailable")` when a newer Nyte has migrated the store, with `RefStore.set`'s semantics, each revision a random UUID, any throw inside rolling the whole batch back. `list(prefix)` reads the name range from `prefix` in name order; `log` returns the events after `after` in seq order up to `limit`, each validated as a `SessionEvent`; `tail` is the session's last seq, or 0. Every `open()` returns a connection over the one storage; `close()` releases nothing, the storage being the object's. In workerd, which allows code generation only while modules load, the Worker turns TypeBox acceleration off at startup (`Settings.Set({ useAcceleration: false })` from `typebox/system`, as `deploy/cloudflare/worker.ts` does), or `log`'s validation throws inside a request. */
+/** Returns a `Store` over a Durable Object's SQLite storage, node-free, with the sqlite store's tables, row helpers (`store-rows.ts`) and semantics (§41f): `objects(id TEXT PRIMARY KEY, body TEXT NULL, bytes BLOB NULL)`, `refs(name TEXT PRIMARY KEY, target TEXT NULL, revision TEXT NOT NULL)` and `log(session TEXT, seq INTEGER, at INTEGER, event TEXT, PRIMARY KEY (session, seq))`, brought to core's `STORE_VERSION` by `migrateStore` on first `open()`, each commit one `transactionSync` and no backup; the open rejects with `SdkError("unavailable")` for a store a newer Nyte migrated. `put` ids the value with core's `objectId` and stores its JSON once; `putBlob` buffers the stream, ids it with `blobId` and stores the bytes once as an `ArrayBuffer`; an object and a blob that share an id share the row, each column filled once; `blob` reads the bytes back with their size and a null mime; a body, blob or logged event past the Durable Object's 2 MB row limit throws `SdkError("invalid")` before anything is written (§42k). `refs.set` runs inside one `transactionSync` with no await between its reads and writes, first rejecting with `SdkError("unavailable")` when a newer Nyte has migrated the store, with `RefStore.set`'s semantics, each revision a random UUID, any throw inside rolling the whole batch back. `list(prefix)` reads the name range from `prefix` in name order; `log` returns the events after `after` in seq order up to `limit`, each validated as a `SessionEvent`; `tail` is the session's last seq, or 0. Every `open()` returns a connection over the one storage; `close()` releases nothing, the storage being the object's. In workerd, which allows code generation only while modules load, the Worker turns TypeBox acceleration off at startup (`Settings.Set({ useAcceleration: false })` from `typebox/system`, as `packages/examples/cloudflare/worker.ts` does), or `log`'s validation throws inside a request. */
 export function durableObjectStore(storage: DurableObjectSql): Store {
   let connection: StoreConnection | null = null;
 

package/src/listen-fetch.ts

@@ -36,7 +36,7 @@ type Device = {
 
 const encoder = new TextEncoder();
 
-/** Serves a composed host as a bare fetch handler with no socket and no `node:*` import, so a Worker can serve it (§41j): `before`, the unauthenticated identity and describe routes, then `createHandler` over one cached connection per principal and authority, every response carrying `X-Nyte-Host` (§43a, §43j). A request authenticates by a pairing code, then the listener token (compared in constant time over SHA-256 digests) or a device token remembered until a commit from another process moves the host's principals, then `authorize` under `custom`; a revoke aborts that principal's open requests and streams. A `token` shorter than 16 characters throws `SdkError("invalid")`; `execution` (default: run covering all) drives covered sessions in process on an `admit-only` host, covers their leases otherwise and takes nothing on a `dispatch` host (§42v); `close()` disconnects the clients and releases the execution once, after which every request answers `unavailable`. */
+/** Serves a composed host as a bare fetch handler with no socket and no `node:*` import, so a Worker can serve it (§41j): `before`, the unauthenticated identity and describe routes, then `createHandler` over one cached connection per principal and authority, every response carrying `X-Nyte-Host` (§43a, §43j). A request authenticates by a pairing code, then the listener token (compared in constant time over SHA-256 digests, granting `auth.authority`) or a device token remembered until a commit from another process moves the host's principals, then `authorize` under `custom`; a revoke aborts that principal's open requests and streams. A `token` shorter than 16 characters throws `SdkError("invalid")`; `execution` (default: run covering all) drives covered sessions in process on an `admit-only` host, covers their leases otherwise and takes nothing on a `dispatch` host (§42v); `close()` disconnects the clients and releases the execution once, after which every request answers `unavailable`. */
 export async function listenFetch(
   host: ServedHost,
   options: ListenOptions & { readonly transport: { readonly kind: "fetch" } },
@@ -161,6 +161,9 @@ export async function listenFetch(
   const isListenerToken: (token: string) => Promise<boolean> =
     auth.kind === "token" ? (token) => sameSecret(token, auth.token) : async () => false;
 
+  const listenerAuthority =
+    auth.kind === "token" ? (auth.authority ?? TOKEN_AUTHORITY) : TOKEN_AUTHORITY;
+
   const fallback: (request: Request, token: string | undefined) => Promise<Verdict> =
     auth.kind === "custom"
       ? async (request) => {
@@ -207,8 +210,8 @@ export async function listenFetch(
     if (token !== undefined) {
       if (await isListenerToken(token))
         return {
-          connection: connectionFor(flight, TOKEN, TOKEN_AUTHORITY, token),
-          authority: TOKEN_AUTHORITY,
+          connection: connectionFor(flight, TOKEN, listenerAuthority, token),
+          authority: listenerAuthority,
         };
       const remembered = await findDevice(token);
 

package/src/local/provider.ts

@@ -18,7 +18,7 @@ const PLUGIN_FILE = /\.(?:ts|mts|js|mjs)$/;
 
 const ROOT_SOURCES = [".nyte/SYSTEM.md", ".nyte/APPEND_SYSTEM.md", ".nyte/mcp.json"];
 
-/** Returns the local environment provider (`kind: "local"`): a folder on this machine. `inspect` answers a `{ kind: "local", path }` target's `folderIdentity` (§41d), `available` when the path is a readable directory (else `unavailable { unreachable }`; a target without a path `unavailable { unsupported }`, identified by the hash of its locator), and the project sources present under it, relative to it, in this order: the plugin files `.nyte/plugins/<name>.{ts,mts,js,mjs}` and `.nyte/plugins/<name>/index.<ext>`, the skills `.nyte/skills/<name>/SKILL.md` and `.agents/skills/<name>/SKILL.md`, the prompts `.nyte/prompts/<name>.md`, then `.nyte/SYSTEM.md`, `.nyte/APPEND_SYSTEM.md` and `.nyte/mcp.json`: the files project trust gates. Context files such as `AGENTS.md` load without trust and are not listed. `attach` resolves the real path (a target that is not a directory throws `SdkError("unavailable")`) and returns an `ExecutionEnv` with that identity, `cwd` the real path, `files` from `localFiles` (with `ripgrep` and `formatter`), `exec` from `localExec`, and a `close` that ends its file watches and the jobs' readers, leaving running jobs alone. `git` is `localGit` (with `git`), `github` is `localGitHub` (with `gh` and `git`; the login is the machine's, `localGitHubAccount`), `snapshots` is `localSnapshots` storing tree walks under `<home>/.nyte/snapshots` (`home` default `os.homedir()`), and absent for a folder that contains `<home>/.nyte` or lies inside it outside `<home>/.nyte/worktrees` (the home folder itself, its ancestors, Nyte's own state): there a snapshot would walk or stage everything under home, the store and secrets included, to report changes in the store it just wrote; `worktrees` is `localWorktrees` (with `home` and `git`); no `browser` (the desktop wraps one in); `destroy` rejects with `SdkError("unavailable")`: a local folder is never torn down. */
+/** Returns the local environment provider (`kind: "local"`): a folder on this machine. `inspect` answers a `{ kind: "local", path }` target's `folderIdentity` (§41d), `available` when the path is a readable directory (else `unavailable { unreachable }`; a target without a path `unavailable { unsupported }`, identified by the hash of its locator), and the project sources present under it, relative to it, in this order: the plugin files `.nyte/plugins/<name>.{ts,mts,js,mjs}` and `.nyte/plugins/<name>/index.<ext>`, the skills `.nyte/skills/<name>/SKILL.md` and `.agents/skills/<name>/SKILL.md`, the prompts `.nyte/prompts/<name>.md`, then `.nyte/SYSTEM.md`, `.nyte/APPEND_SYSTEM.md` and `.nyte/mcp.json`: the files project trust gates. Context files such as `AGENTS.md` load without trust and are not listed. `attach` resolves the real path (a target that is not a directory throws `SdkError("unavailable")`) and returns an `ExecutionEnv` with that identity, `cwd` the real path, `files` from `localFiles` (with `ripgrep` and `formatter`), `exec` from `localExec`, and a `close` that ends its file watches and the jobs' readers, leaving running jobs alone. `git` is `localGit` (with `git`), `github` is `localGitHub` (with `gh` and `git`; the login is the machine's, `localGitHubAccount`), `snapshots` is `localSnapshots` storing tree walks under `<home>/.nyte/snapshots` (`home` default `os.homedir()`), and absent for a folder that contains `<home>/.nyte` or lies inside it outside `<home>/.nyte/worktrees` (the home folder itself, its ancestors, Nyte's own state): there a snapshot would walk or stage everything under home, the store and secrets included, to report changes in the store it just wrote; `worktrees` is `localWorktrees` (with `home` and `git`); `realpath` is `fs.promises.realpath` (the native one, which spells each name as the disk stores it), a relative path resolved against `env.cwd`, null where it fails; no `browser` (the desktop wraps one in); `destroy` rejects with `SdkError("unavailable")`: a local folder is never torn down. */
 export function localProvider(options?: {
   readonly home?: string;
   readonly git?: string;
@@ -95,6 +95,8 @@ export function localProvider(options?: {
         : localSnapshots(env, { store, git: options?.git });
     },
     worktrees: localWorktrees({ home, git: options?.git }),
+    realpath: (env, path) =>
+      realpath(isAbsolute(path) ? path : join(env.cwd, path)).catch(() => null),
     async destroy() {
       throw new SdkError("unavailable", "A local folder is never torn down.");
     },

package/src/local/worktrees.ts

@@ -1,15 +1,65 @@
 import { randomUUID } from "node:crypto";
 import { copyFile, mkdir, realpath, rm, stat } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { SdkError } from "@nyte-ai/schema";
 import type { WorkspaceTarget } from "@nyte-ai/schema";
 import type { WorktreeProvider } from "@nyte-ai/core";
-import { sha256 } from "../hash.ts";
 import { run } from "./command.ts";
 
 const ENV: Readonly<Record<string, string>> = { GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" };
 
+/** The branch config key (`branch.<name>.nyte-session`) naming the session a worktree's branch was made for; `git branch -D` drops it with the branch. */
+const SESSION_KEY = "nyte-session";
+
+const STOPWORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "of",
+  "to",
+  "in",
+  "on",
+  "for",
+  "with",
+  "from",
+  "by",
+  "at",
+  "into",
+  "as",
+  "is",
+  "are",
+  "be",
+  "it",
+  "its",
+  "this",
+  "that",
+  "my",
+  "our",
+  "your",
+]);
+
+const TYPE_WORDS = new Set([
+  "feat",
+  "feature",
+  "fix",
+  "add",
+  "chore",
+  "refactor",
+  "docs",
+  "test",
+  "perf",
+  "build",
+  "ci",
+  "revert",
+  "update",
+]);
+
+/** How many names `create` tries before giving up: `<words>`, then `<two words>-2` up to this. */
+const MAX_ATTEMPTS = 100;
+
 /** One checkout of a repository: its folder and the branch it has out, null when HEAD is detached. */
 export interface ListedWorktree {
   readonly path: string;
@@ -81,11 +131,15 @@ export async function hasBranch(
 
 /**
  * Returns git worktrees for local workspaces (`git`, default `git` on the
- * PATH), each under `<home>/.nyte/worktrees/<repository>/<slug>` on the branch
- * `nyte/<slug>`, the slug the title's words and a hash of the name.
+ * PATH), each under `<home>/.nyte/worktrees/<repository>/<branch>` on a branch
+ * named by `branchName`: at most three hyphenated words from the title.
  *
  * `create` refuses a folder outside a repository or one without a commit, then
- * answers the worktree already on that branch, or adds one from HEAD and
+ * answers the worktree on the branch whose `branch.<branch>.nyte-session`
+ * config is `name`, or claims the first name with no folder or listed worktree
+ * at its path by creating its branch at HEAD (git refuses an existing branch,
+ * which also settles a race with a concurrent create: the loser tries the next
+ * name), records `name` in that config, and adds a worktree for it; then it
  * copies the workspace's uncommitted changes in: the worktree's tracked and
  * untracked files, ignored ones aside, are written to a tree through a
  * temporary index seeded from the real one (which is never touched), and the
@@ -126,6 +180,77 @@ export function localWorktrees(options?: {
     }
   };
 
+  const findClaimedBranch = async (root: string, name: string): Promise<string | null> => {
+    const out = await git(root, [
+      "config",
+      "-z",
+      "--get-regexp",
+      `^branch\\..*\\.${SESSION_KEY}$`,
+    ]).catch(() => "");
+
+    for (const entry of out.split("\0")) {
+      const newline = entry.indexOf("\n");
+      const branch = entry.slice("branch.".length, newline - SESSION_KEY.length - 1);
+
+      if (
+        newline > 0 &&
+        entry.slice(newline + 1) === name &&
+        (await hasBranch(root, branch, options))
+      )
+        return branch;
+    }
+
+    return null;
+  };
+
+  const claimBranch = async (
+    root: string,
+    parent: string,
+    listed: readonly ListedWorktree[],
+    input: { readonly name: string; readonly title: string | null },
+    head: string,
+  ): Promise<string> => {
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      const branch = branchName(input.title, attempt);
+      const folder = join(parent, branch);
+
+      if (
+        listed.some((worktree) => worktree.path === folder) ||
+        (await stat(folder).catch(() => null)) !== null
+      )
+        continue;
+
+      const [created] = await Promise.allSettled([
+        git(root, ["branch", "--no-track", branch, head]),
+      ]);
+
+      if (created.status === "rejected") {
+        if (await hasBranch(root, branch, options)) continue;
+        throw created.reason;
+      }
+
+      await writeConfig(root, `branch.${branch}.${SESSION_KEY}`, input.name);
+
+      return branch;
+    }
+
+    throw new SdkError(
+      "unavailable",
+      `Every worktree name for "${input.title ?? input.name}" is taken in ${root}.`,
+    );
+  };
+
+  const writeConfig = async (root: string, key: string, value: string): Promise<void> => {
+    for (let attempt = 1; ; attempt++) {
+      const [written] = await Promise.allSettled([git(root, ["config", key, value])]);
+
+      if (written.status === "fulfilled") return;
+
+      if (attempt >= 20) throw written.reason;
+      await new Promise((settle) => setTimeout(settle, 10 * attempt));
+    }
+  };
+
   return {
     async create(env, input) {
       const repo = await readRepository(git, env.cwd);
@@ -143,42 +268,41 @@ export function localWorktrees(options?: {
           `${repo.root} has no commits yet, so a worktree has nothing to branch from.`,
         );
 
-      const slug = worktreeSlug(input.name, input.title);
-      const branch = `nyte/${slug}`;
       const below = (root: string): WorkspaceTarget => ({
         kind: "local",
         path: resolve(root, repo.prefix),
       });
 
-      const listed = (await listWorktrees(repo.root, options)).find(
-        (worktree) => worktree.branch === branch,
-      );
+      const listed = await listWorktrees(repo.root, options);
+      const claimed = await findClaimedBranch(repo.root, input.name);
+      const open = listed.find((worktree) => claimed !== null && worktree.branch === claimed);
 
-      if (listed !== undefined)
+      if (claimed !== null && open !== undefined)
         return {
-          target: below(listed.path),
-          branch,
-          base: (await commitAt(repo.root, `refs/heads/${branch}`)) ?? head,
+          target: below(open.path),
+          branch: claimed,
+          base: (await commitAt(repo.root, `refs/heads/${claimed}`)) ?? head,
         };
 
-      const folder = join(folders, basename(repo.root), slug);
-      const branched = await hasBranch(repo.root, branch, options);
-      const base = branched ? ((await commitAt(repo.root, `refs/heads/${branch}`)) ?? head) : head;
+      const parent = join(folders, basename(repo.root));
+      await mkdir(parent, { recursive: true });
+      const realParent = await realpath(parent);
+      const branch = claimed ?? (await claimBranch(repo.root, realParent, listed, input, head));
+
+      const base =
+        claimed === null ? head : ((await commitAt(repo.root, `refs/heads/${claimed}`)) ?? head);
+
+      const folder = join(realParent, branch);
       const tree = await workingTree(repo);
 
-      await mkdir(dirname(folder), { recursive: true });
-      await addWorktree(
-        repo.root,
-        branched ? { path: folder, branch } : { path: folder, branch, from: head },
-        options,
-      );
+      await addWorktree(repo.root, { path: folder, branch }, options);
 
       if (tree !== (await git(folder, ["rev-parse", "HEAD^{tree}"])).trim()) {
         await git(folder, ["read-tree", "-m", "-u", "HEAD", tree]);
         await git(folder, ["reset", "-q"]);
       }
 
-      return { target: below(await realpath(folder)), branch, base };
+      return { target: below(folder), branch, base };
     },
     async remove(worktree) {
       const path = "path" in worktree.target ? worktree.target.path : null;
@@ -227,13 +351,24 @@ async function readRepository(git: Git, cwd: string): Promise<Repository | null>
     : { root: resolve(root), gitDir: resolve(gitDir), prefix };
 }
 
-function worktreeSlug(name: string, title: string | null): string {
+/**
+ * Names a worktree's branch from its title: lowercase ASCII words, stopwords
+ * dropped, and type words such as `fix` or `add` too while two words are left
+ * without them; three words on the first attempt, then two and `-<attempt>`,
+ * so a name never has more than three hyphenated parts. `worktree` stands in
+ * for a title with no words.
+ */
+function branchName(title: string | null, attempt: number): string {
   const words = (title ?? "")
+    .normalize("NFKD")
     .toLowerCase()
-    .replace(/[^a-z0-9]+/gu, "-")
-    .slice(0, 40)
-    .replace(/^-+|-+$/gu, "");
-  const key = sha256(name).slice(0, 8);
+    .split(/[^a-z0-9]+/u)
+    .filter((word) => word !== "");
+
+  const kept = words.filter((word) => !STOPWORDS.has(word));
+  const content = kept.filter((word) => !TYPE_WORDS.has(word));
+  const chosen = content.length >= 2 ? content : kept.length > 0 ? kept : words;
+  const stem = chosen.length === 0 ? "worktree" : chosen.slice(0, attempt === 1 ? 3 : 2).join("-");
 
-  return words === "" ? key : `${words}-${key}`;
+  return attempt === 1 ? stem : `${stem}-${attempt}`;
 }

package/src/open.ts

@@ -50,6 +50,8 @@ import { defaultSecrets } from "./secrets.ts";
 import type { SecretsSource } from "./secrets.ts";
 import { sqliteStore, storePath } from "./sqlite.ts";
 
+declare const NYTE_BUILT_VERSION: string | undefined;
+
 const RELOAD_DEBOUNCE_MS = 250;
 
 const STORE_POLL_MS = 500;
@@ -441,7 +443,11 @@ async function settingsSeed(home: string): Promise<{
 }
 
 function hostDescription(): HostDescription {
-  return { name: hostname(), platform: process.platform, version: manifest.version };
+  return {
+    name: hostname(),
+    platform: process.platform,
+    version: typeof NYTE_BUILT_VERSION === "string" ? NYTE_BUILT_VERSION : manifest.version,
+  };
 }
 
 function settingsPath(home: string): string {

package/src/serve/binding.ts

@@ -103,7 +103,6 @@ const attempts = new WeakMap<ServerHost, Map<string, Attempt>>();
 
 const holds = new WeakMap<ServerHost, Map<string, Page[]>>();
 
-/** Returns each row bound to the call it names: ids bind handles on the connection, handles returned become ids, `Set`s and `Map`s become their wire forms; `head.move`, `files.batch` and `browser.open` go through the server port's wire operations with their wire id (§40o, §40x). `head.watch` sends the head's view from the host's fold whole, then each later view as its changes (`viewFrames`), the core watch marking the principal's seen tip (§40a, §54a); `sessions.watch` sends the list whole, then each later list as its order and changed rows (`sessionsFrames`). Authority is the caller's gate: the server checks each row's before binding. */
 export function bindConnection(connection: Connection, options: BindingOptions): Binding {
   const { wire } = options.server;
   const { principal } = connection;
@@ -285,6 +284,11 @@ export function bindConnection(connection: Connection, options: BindingOptions):
 
       return viewFrames(session(id).head(head).watch(options));
     },
+    "head.see": async ({ session: id, head, commit }) => {
+      await session(id).head(head).see(commit);
+
+      return null;
+    },
     "head.history": ({ session: id, head, before, limit }) =>
       session(id).head(head).history({ before, limit }),
     "head.tree": ({ session: id, head }) => session(id).head(head).tree(),
@@ -293,6 +297,14 @@ export function bindConnection(connection: Connection, options: BindingOptions):
     }),
     "head.compact": ({ session: id, head, instructions }) =>
       session(id).head(head).compact({ instructions }),
+    "head.revise": ({ session: id, head, message, content, options }) =>
+      session(id).head(head).revise(message, content, options),
+    "head.hold": ({ session: id, head, message }) => wire.hold(id, head, message),
+    "head.release": async ({ session: id, head, message }) => {
+      await wire.release(id, head, message);
+
+      return null;
+    },
 
     "heads.create": ({ session: id, name, input }) => session(id).heads.create(name, input),
     "heads.merge": ({ session: id, name, options }) => session(id).heads.merge(name, options),
@@ -347,6 +359,11 @@ export function bindConnection(connection: Connection, options: BindingOptions):
         ? null
         : { action: String(answer.action), input: toJson(answer.input) };
     },
+    "part.watch": async ({ session: id, part }) => {
+      await session(id).info();
+
+      return session(id).part(part).watch();
+    },
     "part.close": async ({ session: id, part }) => {
       await session(id).part(part).close();
 

package/src/usage-history.ts

@@ -159,7 +159,6 @@ async function* historyLines(path: string, start: number, signal: AbortSignal |
       const chunk = pending.length === 0 ? read : Buffer.concat([pending, read]);
       let from = 0;
 
-      // oxlint-disable-next-line nyte-code/no-index-of -- a byte search keeps offsets exact, which decoded text cannot
       for (let newline = chunk.indexOf(0x0a); newline !== -1; newline = chunk.indexOf(0x0a, from)) {
         yield {
           text: chunk.toString("utf8", from, newline),