@gotcos/glasses-server 6.28.0 → 6.30.0

package/CHANGELOG.md

@@ -2219,6 +2219,58 @@ unsaved capture, and makes batch status stop lying about finished work.
 
 # Changelog
 
+## [6.30.0] - 2026-08-16
+
+### Sessions know which threads are live
+
+- `GET /api/agent-sessions` now stamps each row with `running` (an agent is
+  working in this thread right now) and `running_foreign` (it is held by
+  something that is not COS, so a Continue would be refused), plus a
+  `runningDegraded` flag on the payload when a probe could not see clearly.
+- `running` counts COS's own queued turn too. Two different questions: whether an
+  agent is working (the badge) and whether a write would be refused (the
+  affordance). Counting only foreign owners would hide your own turn from the
+  screen you open to watch it.
+- **This is a display hint and never a write gate.** Attach and turn keep probing
+  at the moment of the write, unchanged, so a desktop session opened between the
+  list render and the tap is still caught.
+- Fails the opposite way to the gate: doubt reports `degraded` rather than
+  painting every session busy.
+- One scan for the whole page, measured at 7ms for 45 real sessions (was 792ms
+  before a scan-scoped memo and skipping lsof when no Codex writer lock exists).
+
+**Required by COS Glasses 6.8.364.**
+
+## [6.29.0] - 2026-08-16
+
+### Continue is queued instead of holding the phone
+
+- An attached turn is admitted with **202** and delivered in the background. A
+  provider turn runs up to 21 minutes and iOS suspends the WebView the moment the
+  phone is pocketed, so a synchronous turn was lost exactly when the user did the
+  natural thing.
+- Every safety gate stays synchronous: body, replay, queued-prompt, lease, target,
+  epoch, fence, claim, occupancy, head baseline, pin. A refusal still reaches the
+  user immediately and precisely. Only the spawn moved.
+- **New:** `GET /api/agent-sessions/bindings/:bindingId/turns/:clientTurnId`
+  serves the same durable ledger record the replay path serves, so a poll and a
+  retry can never disagree about what a turn did. Reports `unknown` rather than
+  `failed` for a key it has never seen.
+- Fixed: a post-202 refusal recorded nothing, so the status route would have
+  answered `pending` forever. Pre-202 refusals keep the old semantics and stay
+  re-evaluatable.
+
+### Fork, ungated
+
+- `POST /api/agent-sessions/:provider/:threadId/fork` is registered whether or not
+  `COS_THREAD_ATTACH_ENABLED` is set. Fork appends to nothing: the original is left
+  byte-identical. It is what every refusal tells the user to do instead, and a
+  refusal pointing at a route that 404s is a dead end.
+
+**Required by COS Glasses 6.8.363.** Continue still needs
+`COS_THREAD_ATTACH_ENABLED=1`; with it unset the write routes are not registered
+and behavior is unchanged.
+
 ## 6.12.7
 
 Pairs the public server with COS Glasses build 227+ meeting follow-ups while

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.28.0",
+  "version": "6.30.0",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, or Cursor Agent CLI",
   "type": "module",
   "bin": {

package/server/index.ts

@@ -26,6 +26,7 @@ import { cosSpawnedPids } from './lib/agent-session-ownership-store.js'
 import { realOccupancyDirs, realOccupancyProbes } from './lib/occupancy-probes.js'
 import { realAttachedWorkspaceDeps, resolveAttachedWorkspace } from './lib/attached-workspace.js'
 import { deliverAttachedTurn, realAttachedTurnDeps } from './lib/attached-provider-adapter.js'
+import { forkThread, realForkDeps } from './lib/fork-thread.js'
 import { nativeHead, realNativeHeadDeps } from './lib/native-head.js'
 import { threadOccupancy } from './lib/thread-occupancy.js'
 import { displayRouter } from './routes/display.js'
@@ -376,6 +377,43 @@ const deliverAttachedTurnForRoute = async (request: {
   })
 }
 
+/**
+ * The shim for FORK — the action seventeen refusal strings in this feature already
+ * recommend, and which until 6.29 existed nowhere in the server or the app.
+ *
+ * Deliberately much thinner than the attached shim above, and every difference is
+ * load-bearing:
+ *
+ *  - NO PREFLIGHT. `realAttachedTurnDeps` takes an occupancy re-check because it is
+ *    about to APPEND to a thread someone may have open on their desktop. A fork
+ *    appends to nothing: verified byte-for-byte on both providers on 2026-08-16,
+ *    source sha256 unchanged across the run. A live desktop owner must therefore
+ *    NOT block a fork — gating it here would refuse at exactly the moment fork is
+ *    the only path the user has left.
+ *  - NO `onSpawn` HAND-BACK. The turns route owns its own ledger record because it
+ *    holds the `recordedPids` list that its `finally` releases from. The fork route
+ *    holds no such list, so `fork-thread.ts` records and releases the child itself,
+ *    exactly once, on every exit path — which keeps the recorded:released ratio the
+ *    operator reads for leak detection at 1:1.
+ *  - A WATERMARK IS SUPPLIED, and it is the point. `nativeHead` of the SOURCE, read
+ *    once before the spawn and once after the child settles, is what turns "a fork
+ *    does not touch the original" from a promise into a checked property. It is
+ *    SYNCHRONOUS (native-head.ts:491), which is what lets the module read the
+ *    baseline at the spawn boundary without an await. Unwired, the module can only
+ *    ever report `unverified`, and it would report that honestly rather than
+ *    claiming a verification it never performed.
+ */
+const forkThreadForRoute = (request: {
+  provider: 'claude' | 'codex'
+  nativeThreadId: string
+  prompt: string
+  cwd: string
+  policy: 'read_only'
+}): Promise<unknown> => forkThread({
+  ...request,
+  deps: realForkDeps((provider, threadId) => nativeHead(provider, threadId, nativeHeadDeps)),
+})
+
 // API routes
 app.use('/api', healthRouter)
 app.use('/api', diagRouter)
@@ -413,6 +451,13 @@ app.use('/api', createAgentSessionBindingsRouter({
   },
   nativeHead: (provider, threadId) => nativeHead(provider, threadId, nativeHeadDeps),
   deliverAttachedTurn: deliverAttachedTurnForRoute as never,
+  forkThread: forkThreadForRoute,
+  // The fork's real spawn directory. Separate from `resolveTarget` above, which
+  // deliberately yields only fingerprints because plan 3.3 keeps a filesystem path
+  // off anything client-visible. Null refuses: never fall back to the server's own
+  // working directory, which is wherever the LaunchAgent happened to start.
+  resolveForkWorkspace: (provider, threadId) =>
+    resolveAttachedWorkspace(provider, threadId, attachedWorkspaceDeps)?.path ?? null,
   // One instance per process. The epoch high-water mark is only monotonic if a
   // single reader owns the durable store, so this must never be constructed twice.
   // `open()` never throws: an unreadable store yields a DEGRADED registry whose