@orboto/mcp 0.178.0

package/dist/tools/work-sessions.test.js

@@ -0,0 +1,358 @@
+/**
+ * ORB-1609 - unit tests for the work-session tools.
+ *
+ * The behaviours worth pinning are the ones an agent's control flow
+ * depends on: the 409 must surface the HOLDER (otherwise a colliding
+ * agent cannot decide what to do next without another call), and the
+ * idempotent finish must read as success rather than as an error.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { OrbotoClient } from '../orboto-client.js';
+import { makeWorkSessionStartHandler, makeWorkSessionFinishHandler, makeWorkSessionsHandler, makeWorkSessionClaimsAddHandler, makeWorkSessionClaimsReleaseHandler, makeWorkFinishHandler, } from './work-sessions.js';
+beforeEach(() => { vi.restoreAllMocks(); });
+afterEach(() => { vi.restoreAllMocks(); });
+function stub(responses) {
+    const calls = [];
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, init) => {
+        calls.push({
+            url: url.toString(),
+            method: init?.method ?? 'GET',
+            body: init?.body ? JSON.parse(init.body) : undefined,
+        });
+        const r = responses.shift();
+        if (!r)
+            throw new Error('unexpected extra fetch');
+        return {
+            ok: r.ok ?? true,
+            status: r.status ?? 200,
+            statusText: 'OK',
+            json: async () => ('json' in r ? r.json : {}),
+            text: async () => r.text ?? '',
+        };
+    });
+    return calls;
+}
+const client = new OrbotoClient({ baseUrl: 'https://orboto.example.com', apiKey: 'orb_x' });
+const PROJ = { id: 'p1', key: 'ACME', name: 'Acme', description: null, status: 'active' };
+const TICKET = { id: 't1', ticketKey: 'ACME-42', title: 'Do the thing', projectId: 'p1' };
+const SESSION = {
+    id: 'ws1',
+    ticketId: 't1',
+    role: 'implementation',
+    status: 'active',
+    startedAt: '2026-07-24T10:00:00Z',
+    leaseUntil: '2026-07-24T10:15:00Z',
+    activeTimerId: 'timer1',
+    commitSha: null,
+    ticketKey: 'ACME-42',
+};
+describe('orboto_work_session_start', () => {
+    it('acquires the lease and reports the session id + expiry', async () => {
+        const calls = stub([
+            { json: [PROJ] },
+            { json: TICKET },
+            { json: { session: SESSION, reused: false } },
+        ]);
+        const res = await makeWorkSessionStartHandler(client)({ ticketKey: 'ACME-42' });
+        const post = calls[calls.length - 1];
+        expect(post.method).toBe('POST');
+        expect(post.url).toContain('/work-sessions');
+        expect(post.body?.ticketId).toBe('t1');
+        // The instance token must be sent unprompted - without it the lease has
+        // no owner to renew against.
+        expect(String(post.body?.agentSessionToken)).toMatch(/^mcp-/);
+        const text = res.content[0].text;
+        expect(text).toContain('Started a implementation work session on ACME-42');
+        expect(text).toContain('ws1');
+        expect(text).toContain('Timer running.');
+        expect(res.structuredContent.reused).toBe(false);
+    });
+    it('reports a renewal (not a fresh start) when the same instance re-acquires', async () => {
+        stub([
+            { json: [PROJ] },
+            { json: TICKET },
+            { json: { session: SESSION, reused: true } },
+        ]);
+        const res = await makeWorkSessionStartHandler(client)({ ticketKey: 'ACME-42' });
+        expect(res.content[0].text).toContain('Renewed your existing');
+    });
+    it('surfaces the holder on a 409 instead of throwing', async () => {
+        const holder = {
+            sessionId: 'other-session',
+            userEmail: 'rival@orboto.test',
+            userFullName: 'Rival Bot',
+            role: 'implementation',
+            startedAt: '2026-07-24T09:00:00Z',
+            leaseUntil: '2026-07-24T09:15:00Z',
+        };
+        stub([
+            { json: [PROJ] },
+            { json: TICKET },
+            {
+                ok: false,
+                status: 409,
+                text: JSON.stringify({ error: 'held', errorKey: 'errors.work_sessions.lease_held', holder }),
+            },
+        ]);
+        const res = await makeWorkSessionStartHandler(client)({ ticketKey: 'ACME-42' });
+        expect(res.isError).toBe(true);
+        const text = res.content[0].text;
+        expect(text).toContain('Rival Bot');
+        expect(text).toContain('takeover=true');
+        expect(res.structuredContent.holder.sessionId).toBe('other-session');
+    });
+    it('passes role, lease and takeover through', async () => {
+        const calls = stub([
+            { json: [PROJ] },
+            { json: TICKET },
+            { json: { session: { ...SESSION, role: 'review', activeTimerId: null }, reused: false } },
+        ]);
+        const res = await makeWorkSessionStartHandler(client)({
+            ticketKey: 'ACME-42', role: 'review', leaseSeconds: 3600, takeover: true,
+        });
+        const post = calls[calls.length - 1];
+        expect(post.body).toMatchObject({ role: 'review', leaseSeconds: 3600, takeover: true });
+        // A review session attaches without booking time by default.
+        expect(res.content[0].text).toContain('No timer started for this role.');
+    });
+});
+describe('orboto_work_session_finish', () => {
+    it('reports the booked time and the freed lease', async () => {
+        const calls = stub([
+            { json: { session: { ...SESSION, status: 'finished' }, durationMinutes: 23, changed: true } },
+        ]);
+        const res = await makeWorkSessionFinishHandler(client)({
+            sessionId: 'ws1', commitSha: 'deadbeef', verification: { build: true, tests: true },
+        });
+        expect(calls[0].url).toContain('/work-sessions/ws1/finish');
+        expect(calls[0].body).toMatchObject({ commitSha: 'deadbeef', verification: { build: true, tests: true } });
+        expect(res.content[0].text).toContain('Booked 23 min');
+    });
+    it('treats an already-finished session as success, not an error', async () => {
+        stub([{ json: { session: { ...SESSION, status: 'finished' }, durationMinutes: 0, changed: false } }]);
+        const res = await makeWorkSessionFinishHandler(client)({ sessionId: 'ws1' });
+        expect(res.isError).toBeUndefined();
+        expect(res.content[0].text).toContain('Idempotent finish');
+    });
+});
+describe('ORB-1612 - orboto_work_finish', () => {
+    it('reports the ticket transition and the completion note', async () => {
+        const calls = stub([
+            {
+                json: {
+                    session: { ...SESSION, status: 'finished', commitSha: 'deadbeef', commitVerified: false },
+                    durationMinutes: 23,
+                    changed: true,
+                    ticketTransitioned: true,
+                    ticketStatusCategory: 'done',
+                    noteCommented: true,
+                },
+            },
+        ]);
+        const res = await makeWorkFinishHandler(client)({ sessionId: 'ws1', commitSha: 'deadbeef', targetCategory: 'done' });
+        expect(calls[0].url).toContain('/work-sessions/ws1/finish-work');
+        expect(calls[0].body).toMatchObject({ commitSha: 'deadbeef', targetCategory: 'done' });
+        const text = res.content[0].text;
+        expect(text).toContain('Booked 23 min');
+        expect(text).toContain('attested - pending git verification');
+        expect(text).toContain('Ticket moved to done');
+        expect(text).toContain('Completion note posted');
+        expect(res.structuredContent.ticketTransitioned).toBe(true);
+    });
+    it('reports a verified commit distinctly from an attested-but-unverified one', async () => {
+        stub([
+            {
+                json: {
+                    session: { ...SESSION, status: 'finished', commitSha: 'cafebabe', commitVerified: true },
+                    durationMinutes: 5, changed: true, ticketTransitioned: true, ticketStatusCategory: 'done', noteCommented: true,
+                },
+            },
+        ]);
+        const res = await makeWorkFinishHandler(client)({ sessionId: 'ws1', commitSha: 'cafebabe' });
+        expect(res.content[0].text).toContain('verified by git ingestion');
+    });
+    it('reports a role/outcome that leaves the ticket untouched without treating it as an error', async () => {
+        stub([
+            {
+                json: {
+                    session: { ...SESSION, role: 'review', status: 'finished' },
+                    durationMinutes: 10, changed: true, ticketTransitioned: false, ticketStatusCategory: 'todo', noteCommented: true,
+                },
+            },
+        ]);
+        const res = await makeWorkFinishHandler(client)({ sessionId: 'ws1' });
+        expect(res.isError).toBeUndefined();
+        expect(res.content[0].text).toContain('Ticket left at todo - not transitioned this call.');
+    });
+    it('treats an idempotent no-op re-run as success with no note', async () => {
+        stub([
+            {
+                json: {
+                    session: { ...SESSION, status: 'finished' },
+                    durationMinutes: 0, changed: false, ticketTransitioned: false, ticketStatusCategory: 'done', noteCommented: false,
+                },
+            },
+        ]);
+        const res = await makeWorkFinishHandler(client)({ sessionId: 'ws1' });
+        expect(res.isError).toBeUndefined();
+        const text = res.content[0].text;
+        expect(text).toContain('Idempotent finish');
+        expect(text).toContain('No completion note posted');
+    });
+    it('surfaces a deliveryModeWarning without failing the call', async () => {
+        stub([
+            {
+                json: {
+                    session: { ...SESSION, status: 'finished' },
+                    durationMinutes: 8, changed: true, ticketTransitioned: true, ticketStatusCategory: 'done', noteCommented: true,
+                    deliveryModeWarning: { code: 'no_commit_linked', message: 'no linked commit' },
+                },
+            },
+        ]);
+        const res = await makeWorkFinishHandler(client)({ sessionId: 'ws1' });
+        expect(res.isError).toBeUndefined();
+        expect(res.content[0].text).toContain('no linked commit');
+    });
+});
+describe('orboto_work_sessions', () => {
+    it('lists the workspace coordination view by default', async () => {
+        const calls = stub([{ json: [{ ...SESSION, userFullName: 'Bot One' }] }]);
+        const res = await makeWorkSessionsHandler(client)({});
+        expect(calls[0].url).toContain('/work-sessions/active');
+        expect(res.content[0].text).toContain('ACME-42 [implementation] Bot One');
+    });
+    it('scopes to one ticket and can include the closed history', async () => {
+        const calls = stub([
+            { json: [PROJ] },
+            { json: TICKET },
+            { json: [] },
+        ]);
+        const res = await makeWorkSessionsHandler(client)({ ticketKey: 'ACME-42', includeClosed: true });
+        expect(calls[2].url).toContain('/tickets/t1/work-sessions?includeClosed=true');
+        expect(res.content[0].text).toContain('none.');
+    });
+    it('scopes to my own sessions', async () => {
+        const calls = stub([{ json: [] }]);
+        await makeWorkSessionsHandler(client)({ scope: 'mine' });
+        expect(calls[0].url).toContain('/work-sessions/mine');
+    });
+});
+describe('ORB-1610 - orboto_work_session_start with resourceClaims', () => {
+    it('passes resourceClaims + onConflict through and reports queued claims', async () => {
+        const calls = stub([
+            { json: [PROJ] },
+            { json: TICKET },
+            {
+                json: {
+                    session: { ...SESSION, resourceClaims: [{ kind: 'path', value: 'src/**', mode: 'write', state: 'waiting' }] },
+                    reused: false,
+                    queued: [{ claim: { kind: 'path', value: 'src/**', mode: 'write' }, position: 1, blockedBy: [] }],
+                },
+            },
+        ]);
+        const res = await makeWorkSessionStartHandler(client)({
+            ticketKey: 'ACME-42',
+            resourceClaims: [{ kind: 'path', value: 'src/**', mode: 'write' }],
+            onConflict: 'queue',
+        });
+        const post = calls[calls.length - 1];
+        expect(post.body).toMatchObject({
+            resourceClaims: [{ kind: 'path', value: 'src/**', mode: 'write' }],
+            onConflict: 'queue',
+        });
+        expect(res.content[0].text).toContain('Queued');
+        expect(res.content[0].text).toContain('position 1');
+    });
+    it('surfaces claim conflicts distinctly from a lease conflict on 409', async () => {
+        const conflicts = [{
+                claim: { kind: 'named', value: 'unity-editor:main', mode: 'write' },
+                holders: [{ sessionId: 's2', ticketKey: 'ACME-9', userEmail: 'rival@orboto.test', userFullName: 'Rival Bot', claim: { kind: 'named', value: 'unity-editor:main', mode: 'write' } }],
+            }];
+        stub([
+            { json: [PROJ] },
+            { json: TICKET },
+            { ok: false, status: 409, text: JSON.stringify({ error: 'held', errorKey: 'errors.work_sessions.claim_conflict', claimConflicts: conflicts }) },
+        ]);
+        const res = await makeWorkSessionStartHandler(client)({
+            ticketKey: 'ACME-42',
+            resourceClaims: [{ kind: 'named', value: 'unity-editor:main', mode: 'write' }],
+        });
+        expect(res.isError).toBe(true);
+        const text = res.content[0].text;
+        expect(text).toContain('Rival Bot');
+        expect(text).toContain('unity-editor:main');
+        expect(res.structuredContent.claimConflict).toBe(true);
+    });
+});
+describe('ORB-1610 - orboto_work_session_claims_add', () => {
+    it('adds claims and reports the granted count', async () => {
+        const calls = stub([
+            {
+                json: {
+                    session: { ...SESSION, resourceClaims: [{ kind: 'path', value: 'src/a/**', mode: 'write', state: 'granted' }] },
+                    queued: [],
+                },
+            },
+        ]);
+        const res = await makeWorkSessionClaimsAddHandler(client)({
+            sessionId: 'ws1',
+            claims: [{ kind: 'path', value: 'src/a/**', mode: 'write' }],
+        });
+        expect(calls[0].url).toContain('/work-sessions/ws1/claims');
+        expect(calls[0].method).toBe('POST');
+        expect(calls[0].body).toMatchObject({ claims: [{ kind: 'path', value: 'src/a/**', mode: 'write' }] });
+        expect(res.content[0].text).toContain('1 granted claim');
+    });
+    it('reports queued claims separately from granted ones', async () => {
+        stub([
+            {
+                json: {
+                    session: { ...SESSION, resourceClaims: [{ kind: 'path', value: 'src/b/**', mode: 'write', state: 'waiting' }] },
+                    queued: [{ claim: { kind: 'path', value: 'src/b/**', mode: 'write' }, position: 2, blockedBy: [] }],
+                },
+            },
+        ]);
+        const res = await makeWorkSessionClaimsAddHandler(client)({
+            sessionId: 'ws1',
+            claims: [{ kind: 'path', value: 'src/b/**', mode: 'write' }],
+            onConflict: 'queue',
+        });
+        const text = res.content[0].text;
+        expect(text).toContain('0 granted claim');
+        expect(text).toContain('position 2');
+    });
+    it('surfaces a claim conflict on 409 without adding anything', async () => {
+        const conflicts = [{
+                claim: { kind: 'path', value: 'src/c.ts', mode: 'write' },
+                holders: [{ sessionId: 's2', ticketKey: 'ACME-9', userEmail: null, userFullName: null, claim: { kind: 'path', value: 'src/c.ts', mode: 'write' } }],
+            }];
+        stub([{ ok: false, status: 409, text: JSON.stringify({ error: 'held', errorKey: 'errors.work_sessions.claim_conflict', claimConflicts: conflicts }) }]);
+        const res = await makeWorkSessionClaimsAddHandler(client)({
+            sessionId: 'ws1',
+            claims: [{ kind: 'path', value: 'src/c.ts', mode: 'write' }],
+        });
+        expect(res.isError).toBe(true);
+        expect(res.content[0].text).toContain('No claims were added');
+    });
+});
+describe('ORB-1610 - orboto_work_session_claims_release', () => {
+    it('releases specific claims and reports the remaining count', async () => {
+        const calls = stub([{ text: JSON.stringify({ ...SESSION, resourceClaims: [{ kind: 'path', value: 'src/b/**', mode: 'write', state: 'granted' }] }) }]);
+        const res = await makeWorkSessionClaimsReleaseHandler(client)({
+            sessionId: 'ws1',
+            claims: [{ kind: 'path', value: 'src/a/**' }],
+        });
+        expect(calls[0].url).toContain('/work-sessions/ws1/claims');
+        expect(calls[0].method).toBe('DELETE');
+        expect(calls[0].body).toMatchObject({ claims: [{ kind: 'path', value: 'src/a/**' }] });
+        expect(res.content[0].text).toContain('1 claim(s) remain');
+    });
+    it('releases everything when claims is omitted, and still sends a body', async () => {
+        const calls = stub([{ text: JSON.stringify({ ...SESSION, resourceClaims: [] }) }]);
+        const res = await makeWorkSessionClaimsReleaseHandler(client)({ sessionId: 'ws1' });
+        // A DELETE with a genuinely absent body 400s on the API's schema
+        // (ORB-1610 finding) - the handler must always send at least `{}`.
+        expect(calls[0].body).toEqual({});
+        expect(res.content[0].text).toContain('Released every claim');
+    });
+});

package/dist/toolset.js

@@ -0,0 +1,149 @@
+/**
+ * ORB-1520 - manifest triage for the Code-Mode escape hatch (epic
+ * ORB-1517).
+ *
+ * Eager-loading MCP clients (Codex, Cursor, Claude Desktop) pull EVERY
+ * tool schema at connect time - with ~190 named tools that is tens of
+ * thousands of tokens before the user says a word. The default manifest
+ * is therefore the CURATED set below; the long tail stays fully
+ * reachable through `orboto_api_search` + `orboto_api_call`, and the
+ * complete named manifest is one opt-in away - and since ORB-1805 a
+ * SMALLER one is too, for local models with an 8k/16k window:
+ *
+ *   stdio: ORBOTO_MCP_TOOLSET=minimal | curated | full
+ *   http:  .../mcp?toolset=minimal  (or header x-orboto-toolset: full;
+ *          the query param rides on every request, so no session
+ *          persistence is involved)
+ *
+ * KEEP-LIST BASIS - measured, not guessed (ORB-1520): 30-day
+ * `mcp_call_log` distribution on the core instance, 2026-08-10, 15.5k
+ * calls total. Every tool with a meaningful call volume is in; the two
+ * additions beyond the data are `orboto_my_tickets` (the natural "what
+ * am I working on" entry for interactive desktop clients - the exact
+ * audience this manifest serves; agent-dominated prod traffic
+ * under-counts it) and the escape-hatch pair itself. The numbers live
+ * in the ORB-1520 ticket comment.
+ *
+ * Tail tools are NOT deleted: their code, tests, chat mirrors and
+ * drift-guard entries are untouched - only their REGISTRATION is
+ * skipped in curated mode (the chat-tools parity guard reads server.ts
+ * SOURCE, so it keeps covering the whole set in both modes).
+ */
+/**
+ * ORB-1805 - the small-context tier.
+ *
+ * Measured 2026-09-01: the CURATED manifest alone costs ~9.4k tokens of
+ * tool schemas plus ~1k of instructions, so an 8k local model (LM Studio
+ * / Ollama defaults) dies before the first user turn:
+ * `n_keep: 13533 >= n_ctx: 8192`. `minimal` is the daily loop and
+ * nothing else - orient, find, read, write, claim, close, track time -
+ * plus the escape-hatch pair, which keeps the ENTIRE REST API reachable
+ * from 12 tools.
+ *
+ * The pair is `claim` + `close_ticket` because that is the loop the
+ * skill's own workflow mandates (SKILL.md "Claim = assign + status +
+ * timer; stop the timer the moment you finish"), not
+ * `work_next`/`work_finish` (those are not even in the curated set).
+ *
+ * Deliberately OUT, and why the loop still holds without them:
+ * - `orboto_whoami` - measured at 357 tokens, 12 % of the whole budget,
+ *   for data `orboto_session_start` already prints ("You are <name>
+ *   (<email>)." + the workspace write language). The mandated first call
+ *   covers it; a second identity tool does not earn a tier this small.
+ * - `orboto_check_similar` - `orboto_create_ticket` enforces the
+ *   duplicate block server-side (ORB-1471), so the mandated pre-create
+ *   check still happens, just inside the create.
+ * - `orboto_my_tickets` / `orboto_list_tickets` - `orboto_session_start`
+ *   already returns the caller's in-progress work, and `orboto_search`
+ *   covers "anything about X".
+ * - `orboto_move_ticket` - claim moves to in_progress and close moves to
+ *   done; any other transition goes through `orboto_api_call`.
+ * - `orboto_help` / `orboto_response_expand` - both are recovery paths
+ *   for large payloads, which is the opposite of this tier's problem.
+ *
+ * MUST stay a subset of CURATED_TOOLS (asserted in toolset.test.ts): a
+ * name that is not registered in curated cannot be registered here
+ * either, and the tier ordering minimal < curated < full is what the
+ * docs promise.
+ */
+export const MINIMAL_TOOLS = new Set([
+    // Orient (session_start also reports who you are + the write language)
+    'orboto_session_start',
+    // Find + read
+    'orboto_search',
+    'orboto_get_ticket',
+    // Write
+    'orboto_create_ticket',
+    'orboto_update_ticket',
+    'orboto_comment',
+    // The claim -> close loop + its timer
+    'orboto_claim',
+    'orboto_close_ticket',
+    'orboto_timer_start',
+    'orboto_timer_stop',
+    // Everything else, on demand
+    'orboto_api_search',
+    'orboto_api_call',
+]);
+/** Order matches the measured 30d call counts (see ticket comment). */
+export const CURATED_TOOLS = new Set([
+    // Session + identity + orientation
+    'orboto_session_start', // 662 calls/30d, and the binding-rules bootstrap
+    'orboto_whoami', // 28
+    'orboto_get_project_primer', // 131
+    'orboto_list_projects', // 27, referenced by the server instructions
+    // Reads
+    'orboto_get_ticket', // 1764
+    'orboto_list_tickets', // 161
+    'orboto_my_tickets', // interactive-client staple (see header)
+    'orboto_search', // 420
+    'orboto_query', // 26 - the OQL surface, prior art of this pattern
+    'orboto_check_similar', // 258 - mandated pre-create dup check
+    'orboto_get_doc', // 86
+    // Ticket writes (the strict claim->commit->close loop)
+    'orboto_create_ticket', // 2069
+    'orboto_bulk_create_tickets', // ORB-1694 - 48 measured runs of consecutive creates
+    'orboto_bulk_add_ticket_dependencies', // ORB-1694 - longest dependency run: 27 calls
+    'orboto_update_ticket', // 250
+    'orboto_comment', // 1838
+    'orboto_claim', // 1305
+    'orboto_move_ticket', // 1010
+    'orboto_close_ticket', // 889
+    'orboto_set_parent', // 44
+    'orboto_add_ticket_dependency', // 314 - the mandated blocker primitive
+    'orboto_check', // 103 - acceptance-criteria checklists
+    'orboto_create_milestone', // 42 - "milestone FIRST" rule for big features
+    // Time tracking (the timer rules)
+    'orboto_timer_start', // 34
+    'orboto_timer_stop', // 772
+    'orboto_log_time', // 130
+    'orboto_get_timer', // 43
+    // Transport plumbing + the escape hatch itself
+    'orboto_response_expand',
+    // ORB-1741 - the way back from one-line manifest summaries: full
+    // guidance on demand. Must ride every manifest the summaries ride.
+    'orboto_help', // ORB-1697 - the way back from a budget cut
+    'orboto_api_search', // ORB-1518 - discovery half of the escape hatch
+    'orboto_api_call', // ORB-1519 - execute half of the escape hatch
+]);
+/**
+ * Resolve the effective toolset. `explicit` (per-connection: URL query /
+ * header / BuildServerOptions) beats `envValue` (process-wide default);
+ * anything unrecognized falls through, so a typo degrades to the safe
+ * default instead of surprising with 190 tools.
+ */
+export function resolveToolset(explicit, envValue) {
+    const parse = (v) => v === 'full' ? 'full'
+        : v === 'curated' ? 'curated'
+            : v === 'minimal' ? 'minimal'
+                : null;
+    return parse(explicit) ?? parse(envValue) ?? 'curated';
+}
+/** Whether a tool registers under the given toolset. */
+export function toolInToolset(toolName, toolset) {
+    if (toolset === 'full')
+        return true;
+    if (toolset === 'minimal')
+        return MINIMAL_TOOLS.has(toolName);
+    return CURATED_TOOLS.has(toolName);
+}

package/dist/toolset.test.js

@@ -0,0 +1,150 @@
+/**
+ * ORB-1520 - manifest triage tests: the curated default, the full
+ * opt-in, and the resolution precedence.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { buildOrbotoMcpServer } from './server.js';
+import { CURATED_TOOLS, MINIMAL_TOOLS, resolveToolset, toolInToolset } from './toolset.js';
+beforeEach(() => {
+    vi.restoreAllMocks();
+    // buildOrbotoMcpServer fetches /agent-instructions at connect; offline
+    // in unit tests - the catch keeps the fallback rules, which is fine.
+    vi.spyOn(globalThis, 'fetch').mockRejectedValue(new Error('offline test'));
+    delete process.env.ORBOTO_MCP_TOOLSET;
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env.ORBOTO_MCP_TOOLSET;
+});
+function registeredTools(server) {
+    // The SDK keeps its registry on `_registeredTools` (verified against
+    // @modelcontextprotocol/sdk 1.29). If a bump renames it, this helper
+    // fails loudly rather than passing on an empty object.
+    const tools = server._registeredTools;
+    if (!tools || Object.keys(tools).length === 0) {
+        throw new Error('SDK _registeredTools not found or empty - did the SDK internals change?');
+    }
+    return Object.keys(tools).sort();
+}
+describe('resolveToolset', () => {
+    it('defaults to curated', () => {
+        expect(resolveToolset(undefined, undefined)).toBe('curated');
+        expect(resolveToolset(null, null)).toBe('curated');
+    });
+    it('explicit beats env; unknown values fall through', () => {
+        expect(resolveToolset('full', 'curated')).toBe('full');
+        expect(resolveToolset('curated', 'full')).toBe('curated');
+        expect(resolveToolset('bogus', 'full')).toBe('full');
+        expect(resolveToolset('bogus', 'nonsense')).toBe('curated');
+    });
+    // ORB-1805 - the small-context tier resolves on both surfaces and,
+    // like the others, a typo still degrades to curated rather than
+    // silently handing an 8k model 175 tools.
+    it('minimal resolves from either surface and keeps the safe fallback', () => {
+        expect(resolveToolset('minimal', undefined)).toBe('minimal');
+        expect(resolveToolset(undefined, 'minimal')).toBe('minimal');
+        expect(resolveToolset('minimal', 'full')).toBe('minimal');
+        expect(resolveToolset('minimalist', undefined)).toBe('curated');
+    });
+});
+describe('toolInToolset', () => {
+    it('full admits everything, curated only the keep-list', () => {
+        expect(toolInToolset('orboto_wiki_ask', 'full')).toBe(true);
+        expect(toolInToolset('orboto_wiki_ask', 'curated')).toBe(false);
+        expect(toolInToolset('orboto_claim', 'curated')).toBe(true);
+        expect(toolInToolset('orboto_api_call', 'curated')).toBe(true);
+    });
+    it('minimal admits only the daily loop + the escape hatch', () => {
+        expect(toolInToolset('orboto_claim', 'minimal')).toBe(true);
+        expect(toolInToolset('orboto_api_search', 'minimal')).toBe(true);
+        expect(toolInToolset('orboto_api_call', 'minimal')).toBe(true);
+        // In curated, out of minimal.
+        expect(toolInToolset('orboto_list_projects', 'minimal')).toBe(false);
+        expect(toolInToolset('orboto_help', 'minimal')).toBe(false);
+        expect(toolInToolset('orboto_wiki_ask', 'minimal')).toBe(false);
+    });
+});
+describe('ORB-1805 - the tiers nest', () => {
+    it('MINIMAL_TOOLS is a strict subset of CURATED_TOOLS', () => {
+        // A name that is not registered in curated cannot register in
+        // minimal either - the tier ordering minimal < curated < full is
+        // what the docs promise, and a typo here would silently ship an
+        // empty slot.
+        const notInCurated = [...MINIMAL_TOOLS].filter((t) => !CURATED_TOOLS.has(t));
+        expect(notInCurated).toEqual([]);
+        expect(MINIMAL_TOOLS.size).toBeLessThan(CURATED_TOOLS.size);
+    });
+    it('the daily loop is complete: orient, find, read, write, claim, close, time, escape hatch', () => {
+        for (const name of [
+            'orboto_session_start', 'orboto_search', 'orboto_get_ticket',
+            'orboto_create_ticket', 'orboto_update_ticket', 'orboto_comment',
+            'orboto_claim', 'orboto_close_ticket',
+            'orboto_timer_start', 'orboto_timer_stop',
+            'orboto_api_search', 'orboto_api_call',
+        ])
+            expect(MINIMAL_TOOLS.has(name)).toBe(true);
+        expect(MINIMAL_TOOLS.size).toBe(12);
+    });
+});
+describe('buildOrbotoMcpServer toolset gating', () => {
+    const baseOpts = { baseUrl: 'https://orboto.example.com', apiKey: 'orb_test' };
+    it('curated (default) registers exactly the keep-list', async () => {
+        const server = await buildOrbotoMcpServer(baseOpts);
+        const tools = registeredTools(server);
+        expect(tools).toEqual([...CURATED_TOOLS].sort());
+    });
+    it('full registers the whole manifest (superset, >150 tools)', async () => {
+        const server = await buildOrbotoMcpServer({ ...baseOpts, toolset: 'full' });
+        const tools = registeredTools(server);
+        expect(tools.length).toBeGreaterThan(150);
+        for (const name of CURATED_TOOLS)
+            expect(tools).toContain(name);
+    });
+    it('ORBOTO_MCP_TOOLSET=full flips the default without an explicit option', async () => {
+        process.env.ORBOTO_MCP_TOOLSET = 'full';
+        const server = await buildOrbotoMcpServer(baseOpts);
+        expect(registeredTools(server).length).toBeGreaterThan(150);
+    });
+    it('curated instructions point at the escape hatch; full keeps get_checklists', async () => {
+        const curated = await buildOrbotoMcpServer(baseOpts);
+        const full = await buildOrbotoMcpServer({ ...baseOpts, toolset: 'full' });
+        // `_instructions` verified against @modelcontextprotocol/sdk 1.29
+        // (server/index.js). Assert non-empty first so an SDK rename fails
+        // this test loudly instead of green-skipping.
+        const instructionsOf = (s) => String(s.server._instructions ?? '');
+        const curatedText = instructionsOf(curated);
+        const fullText = instructionsOf(full);
+        expect(curatedText.length).toBeGreaterThan(100);
+        expect(fullText.length).toBeGreaterThan(100);
+        expect(curatedText).toContain('orboto_api_search');
+        expect(curatedText).toContain('CURATED');
+        expect(fullText).toContain('orboto_get_checklists');
+        expect(fullText).not.toContain('CURATED tool manifest');
+    });
+    it('ORBOTO_MCP_TOOLSET=minimal registers exactly the minimal set', async () => {
+        process.env.ORBOTO_MCP_TOOLSET = 'minimal';
+        const server = await buildOrbotoMcpServer(baseOpts);
+        expect(registeredTools(server)).toEqual([...MINIMAL_TOOLS].sort());
+    });
+    it('minimal instructions keep the escape hatch + session_start and drop the rules block', async () => {
+        const minimal = await buildOrbotoMcpServer({ ...baseOpts, toolset: 'minimal' });
+        const text = String(minimal.server._instructions ?? '');
+        expect(text.length).toBeGreaterThan(100);
+        // The two things a minimal-tier agent cannot work without.
+        expect(text).toContain('orboto_session_start');
+        expect(text).toContain('orboto_api_search');
+        expect(text).toContain('MINIMAL');
+        // ORB-1805 - the workspace rules block is deliberately absent; it
+        // arrives via orboto_session_start, on the caller's budget.
+        expect(text).not.toContain('Working rules for this workspace:');
+    });
+    it('minimal drops the display title; curated keeps it', async () => {
+        const shown = async (toolset) => {
+            const s = await buildOrbotoMcpServer({ ...baseOpts, toolset });
+            const reg = s._registeredTools;
+            return reg.orboto_create_ticket?.title;
+        };
+        expect(await shown('minimal')).toBeUndefined();
+        expect(await shown('curated')).toBe('Create a ticket');
+    });
+});