@orboto/mcp 0.230.8 → 0.230.9

package/dist/server.js

@@ -75,6 +75,7 @@ import { checkToolConfig, makeCheckHandler, uncheckToolConfig, makeUncheckHandle
 import { listUsersToolConfig, makeListUsersHandler, getAuditLogToolConfig, makeGetAuditLogHandler, triggerBackupToolConfig, makeTriggerBackupHandler, } from './tools/admin-writes.js';
 import { freeBusyToolConfig, makeFreeBusyHandler } from './tools/free-busy.js';
 import { createFullBackupToolConfig, makeCreateFullBackupHandler, listBackupsToolConfig, makeListBackupsHandler, downloadBackupToolConfig, makeDownloadBackupHandler, } from './tools/backup.js';
+import { importNumberingToolConfig, makeImportNumberingHandler, importApplyToolConfig, makeImportApplyHandler, } from './tools/import-numbering.js';
 import { primerFactListToolConfig, makePrimerFactListHandler, primerFactAddToolConfig, makePrimerFactAddHandler, primerFactUpdateToolConfig, makePrimerFactUpdateHandler, primerFactSupersedeToolConfig, makePrimerFactSupersedeHandler, primerFactVerifyToolConfig, makePrimerFactVerifyHandler, primerFactDeleteToolConfig, makePrimerFactDeleteHandler, } from './tools/primer-facts.js';
 import { whoamiToolConfig, makeWhoamiHandler } from './tools/identity.js';
 import { claimToolConfig, makeClaimHandler, unclaimToolConfig, makeUnclaimHandler, } from './tools/claim.js';
@@ -332,6 +333,8 @@ export async function buildOrbotoMcpServer(opts) {
     reg('orboto_create_full_backup', createFullBackupToolConfig, makeCreateFullBackupHandler(client));
     reg('orboto_list_backups', listBackupsToolConfig, makeListBackupsHandler(client));
     reg('orboto_download_backup', downloadBackupToolConfig, makeDownloadBackupHandler(client));
+    reg('orboto_import_numbering', importNumberingToolConfig, makeImportNumberingHandler(client));
+    reg('orboto_import_apply', importApplyToolConfig, makeImportApplyHandler(client));
     reg('orboto_primer_fact_list', primerFactListToolConfig, makePrimerFactListHandler(client));
     reg('orboto_primer_fact_add', primerFactAddToolConfig, makePrimerFactAddHandler(client));
     reg('orboto_primer_fact_update', primerFactUpdateToolConfig, makePrimerFactUpdateHandler(client));

package/dist/tools/get-ticket.js

@@ -95,6 +95,7 @@ export function makeGetTicketHandler(client) {
                 } : null,
                 childCount: children.length,
                 webUrl: full.webUrl ?? null,
+                ...(full.sourceSystem || full.sourceKey ? { source: { system: full.sourceSystem ?? null, key: full.sourceKey ?? null, id: full.sourceId ?? null } } : {}),
                 blockedBy: {
                     openCount: full.blockedByOpenCount ?? 0,
                     tickets: (full.blockedByOpen ?? []).map(dependencyEdge),
@@ -221,6 +222,7 @@ function formatTicket(ticket, inc, comments, commentTotal, ticketKey, checklists
             ? `Labels: ${ticket.labels.map((l) => l.name).join(', ')}`
             : null,
         ticket.branchName ? `Branch: ${ticket.branchName}` : null,
+        ticket.sourceSystem || ticket.sourceKey ? `Source: ${[ticket.sourceSystem, ticket.sourceKey].filter(Boolean).join(' ')}` : null,
         ticket.webUrl ? `Link: ${ticket.webUrl}` : null,
         formatDependencySummary('Blocked by', ticket.blockedByOpenCount, ticket.blockedByOpen),
         formatDependencySummary('Blocks', ticket.blocksOpenCount, ticket.blocksOpen),

package/dist/tools/import-numbering.js

@@ -0,0 +1,156 @@
+/**
+ * ORB-2676 - import numbering: the plan of kept and renumbered source tickets and the apply with its double merge confirmation.
+ */
+import { z } from 'zod';
+import { OrbotoApiError } from '../orboto-client.js';
+const MERGE_NOT_CONFIRMED = 'errors.admin_import.merge_not_confirmed';
+const NUMBERING_LIST_CAP = 30;
+const TITLE_CHARS = 50;
+const clip = (value, max) => (value.length > max ? `${value.slice(0, max - 3)}...` : value);
+const moreLine = (shown, total, what) => total > shown ? [`... ${total - shown} more ${what} not listed (${total} in all)`] : [];
+export function renumberedLine(r) {
+    const from = r.sourceKey ?? `#${r.sourceNumber}`;
+    const holder = r.reason === 'number_taken' && r.existingTicketKey
+        ? `; ${r.existingTicketKey}${r.existingTicketTitle ? ` "${clip(r.existingTicketTitle, TITLE_CHARS)}"` : ''}`
+        : '';
+    return `${from} -> ${r.ticketKey} (${r.reason}${holder})`;
+}
+function renumberedPayload(rows) {
+    return rows.map((r) => ({
+        from: r.sourceKey ?? `#${r.sourceNumber}`,
+        to: r.ticketKey,
+        reason: r.reason,
+        ...(r.existingTicketKey ? { existing: r.existingTicketKey } : {}),
+    }));
+}
+export function numberingResult(plan, token) {
+    const renumbered = Array.isArray(plan.renumbered) ? plan.renumbered : [];
+    const shown = renumbered.slice(0, NUMBERING_LIST_CAP);
+    const target = plan.projectKey ?? '(no key yet)';
+    const lines = [
+        `Import numbering for staged import ${token}: target ${target}${plan.sourceProjectKey ? `, source project ${plan.sourceProjectKey}` : ''}.`,
+        plan.merge
+            ? `MERGE: ${target} already has ${plan.existingTickets} tickets. Applying needs confirmMerge: true AND confirmProjectKey: "${target}" typed by the user (orboto_import_apply).`
+            : 'Not a merge: the target has no tickets yet.',
+        `Keep their source number: ${plan.preserved}. No source number (fresh numbers after the highest): ${plan.withoutSourceNumber}. Renumbered: ${renumbered.length}. Next free number: ${plan.nextTicketNumber}.`,
+        ...(plan.projectKeyIssue ? [`The source key ${plan.sourceProjectKey ?? ''} cannot become the project key: ${plan.projectKeyIssue === 'taken' ? 'another project holds it' : 'not 2-10 letters or digits'}.`] : []),
+    ];
+    if (renumbered.length > 0) {
+        lines.push('Renumbered tickets:', ...shown.map(renumberedLine), ...moreLine(shown.length, renumbered.length, 'renumbered tickets'));
+        if (renumbered.length > shown.length)
+            lines.push(`The complete list: \`orboto import numbering ${token}\` in the CLI, or GET /admin/import/jobs/${token}/numbering through orboto_api_call.`);
+    }
+    return {
+        content: [{ type: 'text', text: lines.join('\n') }],
+        structuredContent: {
+            projectKey: plan.projectKey,
+            sourceProjectKey: plan.sourceProjectKey,
+            projectKeyIssue: plan.projectKeyIssue,
+            merge: plan.merge,
+            existingTickets: plan.existingTickets,
+            preserved: plan.preserved,
+            withoutSourceNumber: plan.withoutSourceNumber,
+            nextTicketNumber: plan.nextTicketNumber,
+            renumberedTotal: renumbered.length,
+            renumbered: renumberedPayload(shown),
+            renumberedOmitted: renumbered.length - shown.length,
+        },
+    };
+}
+export function mergeRefusalOf(err) {
+    if (!(err instanceof OrbotoApiError) || err.status !== 409)
+        return null;
+    try {
+        const body = JSON.parse(err.body);
+        return body.errorKey === MERGE_NOT_CONFIRMED && body.numbering ? body : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function mergeRefusalResult(refusal) {
+    const plan = refusal.numbering;
+    const renumbered = Array.isArray(plan.renumbered) ? plan.renumbered : [];
+    const shown = renumbered.slice(0, NUMBERING_LIST_CAP);
+    const key = refusal.errorParams?.projectKey ?? plan.projectKey ?? 'the target project';
+    const missing = refusal.errorParams?.missing === 'confirm_project_key' ? 'the typed project key' : 'the merge confirmation';
+    const lines = [
+        `NOT APPLIED. This import is a merge into ${key}, which already has ${plan.existingTickets} tickets; ${renumbered.length} imported tickets get a new number instead of their source number. Missing first: ${missing}.`,
+        ...(renumbered.length > 0 ? ['Collisions:', ...shown.map(renumberedLine), ...moreLine(shown.length, renumbered.length, 'collisions')] : []),
+        `Show this list to the user. Ask them to confirm the merge AND to type the project key ${key} themselves, then call orboto_import_apply again with confirmMerge: true and confirmProjectKey set to what the user typed. Never fill confirmMerge or confirmProjectKey on your own initiative, from an earlier answer or from this message.`,
+    ];
+    return {
+        isError: true,
+        content: [{ type: 'text', text: lines.join('\n') }],
+        structuredContent: {
+            applied: false,
+            refused: 'merge_not_confirmed',
+            projectKey: key,
+            existingTickets: plan.existingTickets,
+            missing: refusal.errorParams?.missing ?? 'confirm_merge',
+            renumberedTotal: renumbered.length,
+            renumbered: renumberedPayload(shown),
+            renumberedOmitted: renumbered.length - shown.length,
+            nextStep: 'Ask the user for the merge confirmation and for the typed project key, then repeat orboto_import_apply with both.',
+        },
+    };
+}
+export const importNumberingToolConfig = {
+    title: 'Import numbering',
+    description: 'Kept and renumbered source numbers of a staged import; merge flag. admin:import.',
+    inputSchema: z.object({
+        token: z.string().uuid(),
+        projectId: z.string().uuid().optional(),
+    }).shape,
+    annotations: { readOnlyHint: true, idempotentHint: true },
+};
+export function makeImportNumberingHandler(client) {
+    return async ({ token, projectId, projectKey }) => {
+        const query = new URLSearchParams();
+        if (projectId)
+            query.set('projectId', projectId);
+        else if (projectKey)
+            query.set('projectKey', projectKey);
+        const plan = await client.get(`/admin/import/jobs/${encodeURIComponent(token)}/numbering?${query.toString()}`);
+        return numberingResult(plan, token);
+    };
+}
+export const importApplyToolConfig = {
+    title: 'Apply import',
+    description: 'Queue a staged import. Into a project with tickets: refused with the collisions until the user gives confirmMerge and confirmProjectKey; never fill them. config: source credentials. admin:import.',
+    inputSchema: z.object({
+        adapter: z.string().min(1).max(64),
+        stagingToken: z.string().uuid(),
+        mapping: z.record(z.unknown()),
+        projectKey: z.string().trim().max(10).optional(),
+        confirmMerge: z.boolean().optional(),
+        confirmProjectKey: z.string().trim().max(10).optional(),
+        config: z.record(z.unknown()).optional(),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+};
+export function makeImportApplyHandler(client) {
+    return async (args) => {
+        const { adapter, stagingToken, mapping, projectKey, confirmMerge, confirmProjectKey, config } = args;
+        try {
+            const job = await client.post(`/admin/import/${encodeURIComponent(adapter)}/apply-async`, {
+                stagingToken,
+                mapping,
+                ...(projectKey ? { projectKey } : {}),
+                ...(confirmMerge !== undefined ? { confirmMerge } : {}),
+                ...(confirmProjectKey ? { confirmProjectKey } : {}),
+                ...(config ? { config } : {}),
+            });
+            return {
+                content: [{ type: 'text', text: `Import ${job.status} (job ${job.jobId ?? 'none'}, token ${job.token}). Follow it with GET /admin/import/jobs/${job.token} through orboto_api_call; the finished result carries the numbering report.` }],
+                structuredContent: { applied: true, jobId: job.jobId, token: job.token, status: job.status },
+            };
+        }
+        catch (err) {
+            const refusal = mergeRefusalOf(err);
+            if (refusal)
+                return mergeRefusalResult(refusal);
+            throw err;
+        }
+    };
+}

package/dist/tools/import-numbering.test.js

@@ -0,0 +1,166 @@
+/**
+ * ORB-2676 - orboto_import_numbering and orboto_import_apply.
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { OrbotoApiError } from '../orboto-client.js';
+import { applyResponseBudget, budgetFor, measureHalves } from '../response-budget.js';
+import { toolInToolset } from '../toolset.js';
+import { makeImportApplyHandler, makeImportNumberingHandler, mergeRefusalOf, renumberedLine, } from './import-numbering.js';
+const TOKEN = '3f2b6c1e-8a4d-4e5f-9b7a-1c2d3e4f5a6b';
+const PROJECT_ID = '9b7a1c2d-3e4f-4a6b-8c1d-2e3f4a5b6c7d';
+const textOf = (result) => result.content[0].text;
+function ticket(n, reason = 'number_taken') {
+    return {
+        sourceId: `10${n}`,
+        sourceKey: `PROJ-${n}`,
+        sourceNumber: n,
+        reason,
+        existingTicketKey: reason === 'number_taken' ? `KEY-${n}` : null,
+        existingTicketTitle: reason === 'number_taken' ? `Existing ticket number ${n}` : null,
+        ticketNumber: 100 + n,
+        ticketKey: `KEY-${100 + n}`,
+    };
+}
+function plan(overrides = {}) {
+    return {
+        projectKey: 'KEY',
+        sourceProjectKey: 'PROJ',
+        projectKeyIssue: null,
+        merge: true,
+        existingTickets: 12,
+        preserved: 40,
+        withoutSourceNumber: 2,
+        renumbered: [ticket(2), ticket(5, 'duplicate_source_number')],
+        nextTicketNumber: 160,
+        ...overrides,
+    };
+}
+function refusal(overrides = {}) {
+    const numbering = plan();
+    return {
+        error: 'This import merges into KEY',
+        errorKey: 'errors.admin_import.merge_not_confirmed',
+        errorParams: { projectKey: 'KEY', existingTickets: 12, renumbered: numbering.renumbered.length, missing: 'confirm_merge' },
+        numbering,
+        ...overrides,
+    };
+}
+const conflict = (body) => new OrbotoApiError(409, typeof body === 'string' ? body : JSON.stringify(body), 'https://orboto.example.com/admin/import/jira/apply-async');
+describe('orboto_import_numbering', () => {
+    it('reads the numbering route with the project id and prints counts plus one line per renumbered ticket', async () => {
+        const get = vi.fn().mockResolvedValue(plan());
+        const result = await makeImportNumberingHandler({ get })({ token: TOKEN, projectId: PROJECT_ID });
+        expect(get).toHaveBeenCalledWith(`/admin/import/jobs/${TOKEN}/numbering?projectId=${PROJECT_ID}`);
+        const text = textOf(result);
+        expect(text).toContain('MERGE: KEY already has 12 tickets');
+        expect(text).toContain('confirmProjectKey: "KEY" typed by the user');
+        expect(text).toContain('Keep their source number: 40. No source number (fresh numbers after the highest): 2. Renumbered: 2. Next free number: 160.');
+        expect(text).toContain('PROJ-2 -> KEY-102 (number_taken; KEY-2 "Existing ticket number 2")');
+        expect(text).toContain('PROJ-5 -> KEY-105 (duplicate_source_number)');
+        expect(result.structuredContent).toMatchObject({
+            merge: true, existingTickets: 12, preserved: 40, renumberedTotal: 2, renumberedOmitted: 0,
+            renumbered: [{ from: 'PROJ-2', to: 'KEY-102', reason: 'number_taken', existing: 'KEY-2' }, { from: 'PROJ-5', to: 'KEY-105', reason: 'duplicate_source_number' }],
+        });
+    });
+    it('sends the proposed key of a new project, says it is no merge and names an unusable source key', async () => {
+        const get = vi.fn().mockResolvedValue(plan({ merge: false, existingTickets: 0, renumbered: [], projectKey: 'NEWK', projectKeyIssue: 'taken' }));
+        const result = await makeImportNumberingHandler({ get })({ token: TOKEN, projectKey: 'NEWK' });
+        expect(get).toHaveBeenCalledWith(`/admin/import/jobs/${TOKEN}/numbering?projectKey=NEWK`);
+        expect(textOf(result)).toContain('Not a merge');
+        expect(textOf(result)).toContain('cannot become the project key: another project holds it');
+        expect(textOf(result)).not.toContain('Renumbered tickets');
+    });
+    it('falls back to a source number line for a ticket without a source key', () => {
+        expect(renumberedLine({ ...ticket(7), sourceKey: null })).toBe('#7 -> KEY-107 (number_taken; KEY-7 "Existing ticket number 7")');
+    });
+    it('lists the first 30 renumbered tickets and says explicitly how many it left out, inside the default budget', async () => {
+        const many = Array.from({ length: 2000 }, (_, i) => ticket(i + 1));
+        const get = vi.fn().mockResolvedValue(plan({ renumbered: many }));
+        const result = await makeImportNumberingHandler({ get })({ token: TOKEN });
+        expect(get).toHaveBeenCalledWith(`/admin/import/jobs/${TOKEN}/numbering?`);
+        expect(textOf(result)).toContain('... 1970 more renumbered tickets not listed (2000 in all)');
+        expect(textOf(result)).toContain(`orboto import numbering ${TOKEN}`);
+        expect(result.structuredContent).toMatchObject({ renumberedTotal: 2000, renumberedOmitted: 1970 });
+        expect(result.structuredContent.renumbered).toHaveLength(30);
+        const { textChars, structuredChars } = measureHalves(result);
+        expect(Math.max(textChars, structuredChars)).toBeLessThanOrEqual(budgetFor('orboto_import_numbering', {}));
+        const budgeted = applyResponseBudget('orboto_import_numbering', result, {});
+        expect(budgeted.truncatedChars).toBe(0);
+    });
+    it('is cut explicitly by the central budget when the answer is still too long', () => {
+        const long = Array.from({ length: 30 }, (_, i) => ({ ...ticket(i + 1), sourceKey: `PROJ-${'K'.repeat(400)}-${i}` }));
+        const get = vi.fn().mockResolvedValue(plan({ renumbered: long }));
+        return makeImportNumberingHandler({ get })({ token: TOKEN }).then((result) => {
+            const budgeted = applyResponseBudget('orboto_import_numbering', result, {});
+            expect(budgeted.responseChars).toBeLessThanOrEqual(budgetFor('orboto_import_numbering', {}) + 700);
+            expect(budgeted.handle).toBeTruthy();
+        });
+    });
+});
+describe('orboto_import_apply', () => {
+    const mapping = { projectId: PROJECT_ID, statusMap: { Open: 'todo' } };
+    it('queues the apply with the confirmations and the credentials only when given', async () => {
+        const post = vi.fn().mockResolvedValue({ jobId: 'job-1', token: TOKEN, status: 'queued' });
+        const handler = makeImportApplyHandler({ post });
+        const plain = await handler({ adapter: 'jira', stagingToken: TOKEN, mapping });
+        expect(post).toHaveBeenLastCalledWith('/admin/import/jira/apply-async', { stagingToken: TOKEN, mapping });
+        expect(textOf(plain)).toContain(`Import queued (job job-1, token ${TOKEN}`);
+        expect(plain.structuredContent).toEqual({ applied: true, jobId: 'job-1', token: TOKEN, status: 'queued' });
+        expect(plain.isError).toBeUndefined();
+        await handler({
+            adapter: 'jira', stagingToken: TOKEN, mapping, projectKey: 'NEWK', confirmMerge: true, confirmProjectKey: 'KEY', config: { baseUrl: 'https://jira.example.com', apiToken: 'secret' },
+        });
+        expect(post).toHaveBeenLastCalledWith('/admin/import/jira/apply-async', {
+            stagingToken: TOKEN, mapping, projectKey: 'NEWK', confirmMerge: true, confirmProjectKey: 'KEY', config: { baseUrl: 'https://jira.example.com', apiToken: 'secret' },
+        });
+    });
+    it('turns the 409 merge refusal into an error result that lists the collisions and asks the user for both confirmations', async () => {
+        const post = vi.fn().mockRejectedValue(conflict(refusal()));
+        const result = await makeImportApplyHandler({ post })({ adapter: 'jira', stagingToken: TOKEN, mapping });
+        expect(result.isError).toBe(true);
+        const text = textOf(result);
+        expect(text).toContain('NOT APPLIED');
+        expect(text).toContain('merge into KEY, which already has 12 tickets; 2 imported tickets get a new number');
+        expect(text).toContain('Missing first: the merge confirmation');
+        expect(text).toContain('PROJ-2 -> KEY-102 (number_taken; KEY-2 "Existing ticket number 2")');
+        expect(text).toContain('Ask them to confirm the merge AND to type the project key KEY themselves');
+        expect(text).toContain('Never fill confirmMerge or confirmProjectKey on your own initiative');
+        expect(result.structuredContent).toMatchObject({
+            applied: false, refused: 'merge_not_confirmed', projectKey: 'KEY', existingTickets: 12, missing: 'confirm_merge', renumberedTotal: 2,
+        });
+    });
+    it('names the typed project key as the missing confirmation when the merge was confirmed alone', async () => {
+        const body = refusal({ errorParams: { projectKey: 'KEY', existingTickets: 12, renumbered: 2, missing: 'confirm_project_key' } });
+        const post = vi.fn().mockRejectedValue(conflict(body));
+        const result = await makeImportApplyHandler({ post })({ adapter: 'jira', stagingToken: TOKEN, mapping, confirmMerge: true });
+        expect(textOf(result)).toContain('Missing first: the typed project key');
+        expect(result.structuredContent).toMatchObject({ missing: 'confirm_project_key' });
+    });
+    it('rethrows every other failure, including a 409 that is not the merge refusal', async () => {
+        const handler = (err) => makeImportApplyHandler({ post: vi.fn().mockRejectedValue(err) })({ adapter: 'jira', stagingToken: TOKEN, mapping });
+        const forbidden = new OrbotoApiError(403, '{"error":"no"}', 'u');
+        await expect(handler(forbidden)).rejects.toBe(forbidden);
+        const other = conflict({ error: 'busy', errorKey: 'errors.system.import_already_running' });
+        await expect(handler(other)).rejects.toBe(other);
+        const garbled = conflict('not json');
+        await expect(handler(garbled)).rejects.toBe(garbled);
+        const plain = new Error('network');
+        await expect(handler(plain)).rejects.toBe(plain);
+    });
+    it('recognises only the merge refusal with a numbering plan', () => {
+        expect(mergeRefusalOf(conflict(refusal()))?.errorParams?.projectKey).toBe('KEY');
+        expect(mergeRefusalOf(conflict({ errorKey: 'errors.admin_import.merge_not_confirmed' }))).toBeNull();
+        expect(mergeRefusalOf(new OrbotoApiError(400, JSON.stringify(refusal()), 'u'))).toBeNull();
+        expect(mergeRefusalOf(new Error('x'))).toBeNull();
+    });
+});
+describe('toolsets', () => {
+    it('keeps the two import tools out of the curated, minimal and channel sets', () => {
+        for (const name of ['orboto_import_numbering', 'orboto_import_apply']) {
+            expect(toolInToolset(name, 'full')).toBe(true);
+            expect(toolInToolset(name, 'curated')).toBe(false);
+            expect(toolInToolset(name, 'minimal')).toBe(false);
+            expect(toolInToolset(name, 'channel')).toBe(false);
+        }
+    });
+});

package/dist/tools/phase-b-tools.test.js

@@ -323,6 +323,29 @@ describe('orboto_get_ticket', () => {
         const sc = res.structuredContent;
         expect(sc.waitingForGitIngestion).toBe(true);
     });
+    it('ORB-2676: an imported ticket shows its source system and key; a native ticket shows no Source line', async () => {
+        const row = { id: 't1', projectId: 'p1', ticketKey: 'ACME-280', title: 'Imported', status: 'TODO', statusName: 'To Do', statusCategory: 'todo', type: 'task', priority: 'normal' };
+        stub([
+            { json: PROJ },
+            { json: { ...row, gitActivityCount: 0, parentTicketId: null } },
+            { json: { ...row, sourceSystem: 'jira', sourceKey: 'PROJ-280', sourceId: '10280' } },
+            NO_CHILDREN,
+            { json: [] },
+        ]);
+        const imported = await makeGetTicketHandler(client)({ ticketKey: 'ACME-280' });
+        expect(imported.content[0].text).toContain('Source: jira PROJ-280');
+        expect(imported.structuredContent.source).toEqual({ system: 'jira', key: 'PROJ-280', id: '10280' });
+        stub([
+            { json: PROJ },
+            { json: { ...row, gitActivityCount: 0, parentTicketId: null } },
+            { json: { ...row, sourceSystem: null, sourceKey: null, sourceId: null } },
+            NO_CHILDREN,
+            { json: [] },
+        ]);
+        const native = await makeGetTicketHandler(client)({ ticketKey: 'ACME-280' });
+        expect(native.content[0].text).not.toContain('Source:');
+        expect(native.structuredContent.source).toBeUndefined();
+    });
     it('include: ["checklistItems"] reads effectiveCompleted (not done) + surfaces linked-ticket suffix', async () => {
         stub([
             { json: PROJ },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orboto/mcp",
-  "version": "0.230.8",
+  "version": "0.230.9",
   "description": "Model Context Protocol server for orboto - exposes tickets, projects, milestones, time, docs, primer-facts, alerts and absences as MCP tools for Claude Desktop / Cursor / Copilot Chat / any MCP-aware AI client.",
   "license": "MIT",
   "type": "module",