feat: add economy/maximum presets, tool-lab and subagent-cursor extensions

- new economy and maximum agent presets with three-role pipeline skill
- new packages/extensions/tool-lab (home-lab ComfyUI/Docling/Whishper tools)
- new packages/subagent/subagent-cursor provider
- openrouter balance UI with on-demand refresh
- session projection context-seed boundary fold
- regenerate docs catalogs; keep local searxng benchmark scripts

packages/session/session-projection/tests/registry.spec.ts

@@ -12,9 +12,12 @@ import { Context } from '@deepseek-ai/cordis'
 import { z } from 'zod'
 import SessionStore from '@deepseek-ai/dsh-session'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
-import SessionProjectionRegistry from '@deepseek-ai/dsh-session-projection'
+import SessionProjectionRegistry, { foldContextOf } from '@deepseek-ai/dsh-session-projection'
 import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection'
 
+/** The fold context of a session with no inherited fork prefix. */
+const NO_SEED = foldContextOf({})
+
 declare module '@deepseek-ai/dsh-session-projection/types' {
   interface SessionProjectionMap {
     'test/marks': { marks: string[] }
@@ -49,6 +52,19 @@ const countUnit = (): ProjectionDefinition<'test/count', number> => ({
   stateVersion: 1,
 })
 
+/**
+ * A unit counting only events the fold context marks as this session's OWN
+ * work, so its value proves the context reached `apply`.
+ */
+const ownCountUnit = (): ProjectionDefinition<'test/count', number> => ({
+  key: 'test/count',
+  schema: z.number().int().nonnegative(),
+  init: () => 0,
+  apply: (state, event, context) => (event.seq < context.seedLength ? state : state + 1),
+  view: state => state,
+  stateVersion: 1,
+})
+
 async function harness(): Promise<{ ctx: Context; session: Session }> {
   const ctx = new Context()
   await ctx.plugin(SessionStore)
@@ -263,7 +279,7 @@ describe('SessionProjectionRegistry drive', () => {
     expect(() => ctx.sessionProjections.restore({
       'test/marks': { ver: 1, seq: 2, val: { marks: ['old'] } },
       'test/count': { ver: 99, seq: 2, val: 3 },
-    }, tail, 3)).toThrow(/re-read from seq 0/)
+    }, tail, 3, NO_SEED)).toThrow(/re-read from seq 0/)
     // The full-log re-read (baseSeq 0) refolds the mismatched key from init.
     const full: SessionEvent[] = [
       { type: 'turn/start', seq: 0, time: 0, data: { turn: 1 } },
@@ -274,7 +290,7 @@ describe('SessionProjectionRegistry drive', () => {
     const { snapshot, checkpoint } = ctx.sessionProjections.restore({
       'test/marks': { ver: 1, seq: 2, val: { marks: ['old', '2'] } },
       'test/count': { ver: 99, seq: 2, val: 3 },
-    }, full, 0)
+    }, full, 0, NO_SEED)
     expect(snapshot.asOfSeq).toBe(4)
     expect(snapshot.values['test/marks']).toEqual({ marks: ['new'] })
     expect(snapshot.values['test/count']).toBe(5) // refolded from init over all 5 events
@@ -295,7 +311,7 @@ describe('SessionProjectionRegistry drive', () => {
       { type: 'turn/start', seq: 3, time: 3, data: { turn: 2 } },
       { type: 'turn/end', seq: 4, time: 4, data: { turn: 2, reason: { kind: 'completed' } } },
     ]
-    const { snapshot } = ctx.sessionProjections.restore(rows, tail, 3)
+    const { snapshot } = ctx.sessionProjections.restore(rows, tail, 3, NO_SEED)
     expect(snapshot.asOfSeq).toBe(4)
     // marks already covers the tail (watermark 4): nothing re-applied.
     expect(snapshot.values['test/marks']).toEqual({ marks: ['done'] })
@@ -306,7 +322,7 @@ describe('SessionProjectionRegistry drive', () => {
     const { snapshot: current } = ctx.sessionProjections.restore({
       'test/marks': { ver: 1, seq: 4, val: { marks: ['done'] } },
       'test/count': { ver: 1, seq: 4, val: 5 },
-    }, [], 5)
+    }, [], 5, NO_SEED)
     expect(current.asOfSeq).toBe(4)
     expect(current.values['test/count']).toBe(5)
   })
@@ -324,6 +340,48 @@ describe('SessionProjectionRegistry drive', () => {
     expect(ctx.sessionProjections.viewCheckpoint({})).toEqual({})
   })
 
+  it('folds every unit against the fold context of the session header', async () => {
+    const { ctx, session: parent } = await harness()
+    ctx.sessionProjections.register(ownCountUnit())
+    mark(parent, ['a'])
+    mark(parent, ['b'])
+    const inherited = parent.seq
+    expect(ctx.sessionProjections.snapshot(parent).values['test/count']).toBe(inherited)
+
+    // The forked child inherits the parent's log; only its own appends count.
+    const seed = [...parent.events]
+    const child = ctx.sessions.create(undefined, { seed, meta: { seedLength: seed.length } })
+    mark(child, ['own'])
+    expect(child.header.seedLength).toBe(seed.length)
+    expect(ctx.sessionProjections.snapshot(child).values['test/count'])
+      .toBe(child.seq - seed.length)
+  })
+
+  it('passes the fold context to a cell built lazily after events flowed', async () => {
+    const { ctx, session: parent } = await harness()
+    mark(parent, ['a'])
+    const seed = [...parent.events]
+    const child = ctx.sessions.create(undefined, { seed, meta: { seedLength: seed.length } })
+    mark(child, ['own'])
+    // Registered only now: the lazy full-log build must see the same context.
+    ctx.sessionProjections.register(ownCountUnit())
+    expect(ctx.sessionProjections.snapshot(child).values['test/count'])
+      .toBe(child.seq - seed.length)
+  })
+
+  it('restore folds against the caller-supplied fold context', async () => {
+    const { ctx } = await harness()
+    ctx.sessionProjections.register(ownCountUnit())
+    const events: SessionEvent[] = [
+      { type: 'turn/start', seq: 0, time: 0, data: { turn: 1 } },
+      { type: 'turn/end', seq: 1, time: 1, data: { turn: 1, reason: { kind: 'completed' } } },
+      { type: 'turn/start', seq: 2, time: 2, data: { turn: 2 } },
+    ]
+    expect(ctx.sessionProjections.restore({}, events, 0, NO_SEED).snapshot.values['test/count']).toBe(3)
+    expect(ctx.sessionProjections.restore({}, events, 0, foldContextOf({ seedLength: 2 }))
+      .snapshot.values['test/count']).toBe(1)
+  })
+
   it('restore rejects a row claiming events past the supplied log end (shrunk log ⇒ re-read)', async () => {
     const { ctx } = await harness()
     ctx.sessionProjections.register(countUnit())
@@ -334,16 +392,16 @@ describe('SessionProjectionRegistry drive', () => {
     expect(floor).toBe(9)
     // …an intact log serves the anchor event and the checkpoint stands as-is.
     const anchor: SessionEvent = { type: 'turn/end', seq: 9, time: 9, data: { turn: 2, reason: { kind: 'completed' } } }
-    expect(ctx.sessionProjections.restore(rows, [anchor], 9).snapshot.values['test/count']).toBe(10)
+    expect(ctx.sessionProjections.restore(rows, [anchor], 9, NO_SEED).snapshot.values['test/count']).toBe(10)
     // …while a log crash-repaired down to fewer events returns an empty tail:
     // the row overreaches the proven end and a tail read cannot fix this key.
-    expect(() => ctx.sessionProjections.restore(rows, [], 9)).toThrow(/re-read from seq 0/)
+    expect(() => ctx.sessionProjections.restore(rows, [], 9, NO_SEED)).toThrow(/re-read from seq 0/)
     // The full re-read discards the overreaching row and refolds from init.
     const events: SessionEvent[] = [
       { type: 'turn/start', seq: 0, time: 0, data: { turn: 1 } },
       { type: 'turn/end', seq: 1, time: 1, data: { turn: 1, reason: { kind: 'completed' } } },
     ]
-    const { snapshot } = ctx.sessionProjections.restore(rows, events, 0)
+    const { snapshot } = ctx.sessionProjections.restore(rows, events, 0, NO_SEED)
     expect(snapshot.asOfSeq).toBe(1)
     expect(snapshot.values['test/count']).toBe(2)
   })