noteconnection 1.8.0 → 1.9.0

package/dist/src/learning/PublicEvidenceSelection.test.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+const regressionCorpus = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../fixtures/answer-quality/v2.json'), 'utf8'));
+async function answer(message, documents, language = 'en') {
+    const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+    await platform.ingestKnowledge({ documents, relationRecomputeMode: 'none' });
+    const request = { message, answerLanguage: language, responseMode: 'full', persistMemory: false,
+        scope: { documentIds: documents.map(document => document.documentId) } };
+    return { platform, response: await platform.agentConversation(request) };
+}
+describe('public evidence source selection', () => {
+    test.each(['en', 'zh'])('keeps scoped topic distractors out of the %s answer, citations and required claims', async (language) => {
+        const entry = regressionCorpus.cases.find((candidate) => candidate.id === `confirm-wal-${language}`);
+        const { platform, response } = await answer(entry.query, entry.documents, language);
+        const excludedDocumentId = entry.documents[1].documentId;
+        expect(response.answer).not.toMatch(/cardinals|bird.watching|红雀|观鸟/iu);
+        expect(response.answer).toMatch(language === 'en' ? /durable log.*reconstruct/iu : /持久日志重建/u);
+        expect(response.citations.every(citation => citation.documentId !== excludedDocumentId)).toBe(true);
+        expect(response.answerReleaseReview?.auditGraphAnswerPlan?.claims.every(claim => (claim.evidenceRefs.every(reference => reference.sourcePath !== entry.documents[1].sourcePath)))).toBe(true);
+        expect(response.trace.ragContextPack?.sourceDecisions).toContainEqual(expect.objectContaining({
+            documentId: excludedDocumentId, status: 'fragment_dropped', reason: 'query_subject_mismatch', charsRead: 0,
+        }));
+        const retrieval = await platform.queryKnowledge({ query: entry.query, topK: 12,
+            scope: { documentIds: entry.documents.map((document) => document.documentId) } });
+        expect(retrieval.items.some(item => item.atom.documentId === excludedDocumentId)).toBe(true);
+    });
+    test('retains a second source whose body establishes the requested subject', async () => {
+        const { response } = await answer('Explain recovery point objectives.', [
+            { documentId: 'rpo-definition', sourcePath: 'quality/rpo.md', content: '# Recovery Point Objectives\nA recovery point objective bounds the acceptable age of recovered data.' },
+            { documentId: 'rpo-scheduling', sourcePath: 'quality/schedule.md', content: '# Scheduling Policy\nRecovery point objectives determine how frequently snapshots must be taken.' },
+            { documentId: 'business-objectives', sourcePath: 'quality/business.md', content: '# Business Objectives\nBusiness objectives guide revenue targets and quarterly sales reviews.' },
+        ]);
+        expect(response.answer).toMatch(/acceptable age/iu);
+        expect(response.answer).toMatch(/how frequently snapshots/iu);
+        expect(response.answer).not.toMatch(/revenue|quarterly sales/iu);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['rpo-definition', 'rpo-scheduling']));
+    });
+    test('retains both comparison operands while rejecting a shared-word distractor', async () => {
+        const { response } = await answer('Compare an exclusive lock and a shared lock.', [
+            { documentId: 'exclusive', sourcePath: 'quality/exclusive.md', content: '# Exclusive Lock\nAn exclusive lock permits only one owner to access the protected resource.' },
+            { documentId: 'shared', sourcePath: 'quality/shared.md', content: '# Shared Lock\nA shared lock permits several readers to access the protected resource concurrently.' },
+            { documentId: 'door', sourcePath: 'quality/door.md', content: '# Door Lock\nA door lock may be painted bright yellow to match a wooden door.' },
+        ]);
+        expect(response.answer).toMatch(/only one owner/iu);
+        expect(response.answer).toMatch(/several readers/iu);
+        expect(response.answer).not.toMatch(/bright yellow|wooden door/iu);
+        expect(response.citations.map(citation => citation.documentId)).not.toContain('door');
+    });
+    test('does not choose a winner among competing observations of the same subject', async () => {
+        const { response } = await answer('What is the Echo clock rate?', [
+            { documentId: 'echo-a', sourcePath: 'quality/echo-a.md', content: '# Echo Clock Rate\nThe Echo clock rate is 4 Hz.' },
+            { documentId: 'echo-b', sourcePath: 'quality/echo-b.md', content: '# Echo Clock Rate Record\nThe Echo clock rate is 9 Hz.' },
+        ]);
+        expect(response.answer).toMatch(/4\s*Hz/iu);
+        expect(response.answer).toMatch(/9\s*Hz/iu);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['echo-a', 'echo-b']));
+    });
+});

package/dist/src/learning/PublicMeasurementDisclosure.test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+const agentConversationSerialization_1 = require("./agentConversationSerialization");
+async function answerMeasurements(request, first, second) {
+    const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+    await platform.ingestKnowledge({ relationRecomputeMode: 'none', documents: [
+            { documentId: 'clock-primary', sourcePath: 'quality/clock-primary.md', content: first },
+            { documentId: 'clock-secondary', sourcePath: 'quality/clock-secondary.md', content: second },
+        ] });
+    return platform.agentConversation({ ...request, persistMemory: false });
+}
+describe('public measurement conflict disclosure', () => {
+    test.each(['slim', 'full'])('keeps conflicting English observations and their citations in %s', async (responseMode) => {
+        const response = await answerMeasurements({ message: 'What is the Echo clock rate?', answerLanguage: 'en', responseMode }, '# Echo Clock Rate\nThe Echo clock rate is 4 Hz.', '# Echo Clock Rate Record\nThe Echo clock rate is 9 Hz.');
+        expect(response.trace.ragContextPack?.fragments.some(fragment => fragment.role === 'conflict')).toBe(true);
+        expect(response.answer).toMatch(/4\s*Hz/iu);
+        expect(response.answer).toMatch(/9\s*Hz/iu);
+        expect(response.answer).toMatch(/conflict|contradict|disagree/iu);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['clock-primary', 'clock-secondary']));
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
+    test.each(['slim', 'full'])('keeps conflicting Chinese observations and their citations in %s', async (responseMode) => {
+        const response = await answerMeasurements({ message: '回声时钟频率是多少？', answerLanguage: 'zh', responseMode }, '# 回声时钟频率\n回声时钟频率是4赫兹。', '# 回声时钟频率记录\n回声时钟频率是9赫兹。');
+        expect(response.trace.ragContextPack?.fragments.some(fragment => fragment.role === 'conflict')).toBe(true);
+        expect(response.answer).toContain('4赫兹');
+        expect(response.answer).toContain('9赫兹');
+        expect(response.answer).toMatch(/冲突|矛盾|不一致/u);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['clock-primary', 'clock-secondary']));
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
+    test.each(['slim', 'full'])('does not manufacture conflicts between equivalent observations in %s', async (responseMode) => {
+        const response = await answerMeasurements({ message: 'What is the Echo clock rate?', answerLanguage: 'en', responseMode }, '# Echo Clock Rate\nThe Echo clock rate is 1 kHz.', '# Echo Clock Rate Record\nThe Echo clock rate is 1000 Hz.');
+        expect(response.trace.ragContextPack?.fragments.some(fragment => fragment.role === 'conflict')).toBe(false);
+        expect(response.answer).not.toMatch(/conflict|contradict|disagree/iu);
+        expect(response.answer).toMatch(/(?:1\s*kHz|1000\s*Hz)/iu);
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
+    test('retains the same conflict and citations through bounded JSON, SSE and replay', async () => {
+        const response = await answerMeasurements({ message: 'What is the Echo clock rate?', answerLanguage: 'en', responseMode: 'full' }, '# Echo Clock Rate\nThe Echo clock rate is 4 Hz.', '# Echo Clock Rate Record\nThe Echo clock rate is 9 Hz.');
+        response.responseBudget.runtimeGovernor.maxSerializedBytes = 6000;
+        const http = (0, agentConversationSerialization_1.serializeAgentConversationHttpResponse)(response);
+        const event = { type: 'turn_completed', turnId: 'conflict-disclosure', emittedAt: '2026-09-13T00:00:00.000Z', result: response };
+        const live = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', event);
+        const replay = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', { ...event, result: http.result });
+        expect(http.truncated).toBe(true);
+        expect(JSON.parse(live.json).result).toEqual(http.result);
+        expect(JSON.parse(replay.json).result).toEqual(http.result);
+        expect(http.result.answer).toMatch(/observations conflict/iu);
+        expect(http.result.answer).toMatch(/4\s*Hz/iu);
+        expect(http.result.answer).toMatch(/9\s*Hz/iu);
+        expect(http.result.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['clock-primary', 'clock-secondary']));
+    });
+});

package/dist/src/learning/agentConversationExecution.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentConversationExecution = exports.AgentConversationExecutionError = exports.DEFAULT_AGENT_CONVERSATION_EXECUTION_POLICY = void 0;
+exports.normalizeAgentConversationExecutionPolicy = normalizeAgentConversationExecutionPolicy;
+const promises_1 = require("fs/promises");
+const async_hooks_1 = require("async_hooks");
+const agentResponseBudget_1 = require("./agentResponseBudget");
+exports.DEFAULT_AGENT_CONVERSATION_EXECUTION_POLICY = Object.freeze({
+    timeoutMs: 180000,
+    maxSourceBytes: 4 * 1024 * 1024,
+    maxTotalSourceBytes: 16 * 1024 * 1024,
+    maxPendingTurns: 8,
+    maxSourceLines: 16384,
+    maxSourceFacts: 4096,
+});
+class AgentConversationExecutionError extends Error {
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'AgentConversationExecutionError';
+        this.statusCode = code === 'runtime_turn_capacity' ? 429
+            : code === 'runtime_timeout' ? 504
+                : code === 'runtime_cancelled' ? 499 : 413;
+    }
+}
+exports.AgentConversationExecutionError = AgentConversationExecutionError;
+function normalizeAgentConversationExecutionPolicy(input = {}) {
+    const policy = { ...exports.DEFAULT_AGENT_CONVERSATION_EXECUTION_POLICY };
+    for (const key of Object.keys(policy)) {
+        const candidate = input[key];
+        if (candidate === undefined)
+            continue;
+        if (!Number.isFinite(candidate) || candidate < 1) {
+            throw new TypeError(`Invalid agent conversation execution policy: ${key}`);
+        }
+        policy[key] = Math.min(policy[key], Math.floor(candidate));
+    }
+    policy.maxSourceBytes = Math.min(policy.maxSourceBytes, policy.maxTotalSourceBytes);
+    return policy;
+}
+/** Owns one turn's cooperative deadline and bounded source I/O, including queued time. */
+class AgentConversationExecution {
+    constructor(budget, policy, parentSignal) {
+        this.budget = budget;
+        this.policy = policy;
+        this.parentSignal = parentSignal;
+        this.active = true;
+        this.controller = new AbortController();
+        this.startedAtMs = Date.now();
+        this.sourceBytes = 0;
+        this.sourceReads = 0;
+        this.processedFragments = 0;
+        this.sourceFacts = 0;
+        this.timeoutMs = Math.min(policy.timeoutMs, budget.runtimeGovernor.timeoutMs);
+        this.budget = { ...budget, runtimeGovernor: { ...budget.runtimeGovernor, timeoutMs: this.timeoutMs } };
+        this.onParentAbort = () => this.controller.abort(new AgentConversationExecutionError('runtime_cancelled'));
+        this.timer = setTimeout(() => {
+            this.controller.abort(new AgentConversationExecutionError('runtime_timeout'));
+        }, this.timeoutMs);
+        this.timer.unref();
+        if (parentSignal?.aborted)
+            this.onParentAbort();
+        else
+            parentSignal?.addEventListener('abort', this.onParentAbort, { once: true });
+    }
+    static async run(options, operation) {
+        const existing = this.current();
+        if (existing) {
+            existing.assertActive();
+            return operation(existing);
+        }
+        const execution = new AgentConversationExecution(options.budget, options.policy, options.signal);
+        try {
+            execution.assertActive();
+            // Keep the state lease until cooperative work has actually stopped.
+            // Racing an uncancelled promise would allow it to mutate a later turn.
+            return await this.scope.run(execution, () => operation(execution));
+        }
+        finally {
+            execution.active = false;
+            clearTimeout(execution.timer);
+            options.signal?.removeEventListener('abort', execution.onParentAbort);
+        }
+    }
+    get signal() { return this.controller.signal; }
+    get maxFragmentChars() { return this.budget.rag.maxCharsPerFragment; }
+    get truncationReason() { return this.sourceStop; }
+    static current() {
+        const execution = this.scope.getStore();
+        return execution?.active ? execution : undefined;
+    }
+    isResourceLimit(error) {
+        return error instanceof AgentConversationExecutionError && (error.code === 'runtime_source_bytes_limit'
+            || error.code === 'runtime_total_source_bytes_limit'
+            || error.code === 'runtime_fragment_limit'
+            || error.code === 'runtime_source_lines_limit'
+            || error.code === 'runtime_source_facts_limit');
+    }
+    assertActive() {
+        if (!this.active)
+            throw new AgentConversationExecutionError('runtime_cancelled');
+        if (this.signal.aborted)
+            throw this.signal.reason;
+        const decision = (0, agentResponseBudget_1.applyRuntimeGovernor)({
+            budget: this.budget,
+            startedAtMs: this.startedAtMs, nowMs: Date.now(),
+            processedFragments: this.processedFragments, serializedBytes: 0, reportChars: 0,
+        });
+        if (!decision.allowed) {
+            const code = decision.reason === 'runtime_timeout' ? 'runtime_timeout' : 'runtime_fragment_limit';
+            throw new AgentConversationExecutionError(code);
+        }
+    }
+    async yieldCheckpoint() {
+        this.assertActive();
+        await new Promise(resolve => setImmediate(resolve));
+        this.assertActive();
+    }
+    recordFragment() {
+        if (this.processedFragments >= this.budget.runtimeGovernor.maxFragmentsProcessed) {
+            this.sourceStop = 'runtime_fragment_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+        this.processedFragments++;
+        this.assertActive();
+    }
+    checkSourceLineCount(count) {
+        this.assertActive();
+        if (count > this.policy.maxSourceLines) {
+            this.sourceStop = 'runtime_source_lines_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+    }
+    recordSourceFact() {
+        this.assertActive();
+        if (this.sourceFacts >= this.policy.maxSourceFacts) {
+            this.sourceStop = 'runtime_source_facts_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+        this.sourceFacts++;
+    }
+    acceptSourceText(content) {
+        this.assertActive();
+        const bytes = Buffer.byteLength(content, 'utf8');
+        this.assertSourceFits(bytes, bytes);
+        this.sourceBytes += bytes;
+        this.sourceReads++;
+        return content;
+    }
+    async readSourceFile(filePath) {
+        this.assertActive();
+        const file = await (0, promises_1.open)(filePath, 'r');
+        try {
+            this.assertActive();
+            const stat = await file.stat();
+            if (!stat.isFile())
+                return null;
+            this.assertSourceFits(stat.size, stat.size);
+            const chunks = [];
+            let fileBytes = 0;
+            const stream = file.createReadStream({ autoClose: false, highWaterMark: 64 * 1024, signal: this.signal });
+            try {
+                for await (const chunk of stream) {
+                    this.assertActive();
+                    const bytes = chunk;
+                    fileBytes += bytes.length;
+                    // Check actual bytes too: the file can grow after stat().
+                    this.assertSourceFits(fileBytes, bytes.length);
+                    this.sourceBytes += bytes.length;
+                    chunks.push(bytes);
+                }
+            }
+            catch (error) {
+                this.assertActive();
+                throw error;
+            }
+            this.sourceReads++;
+            return Buffer.concat(chunks, fileBytes).toString('utf8');
+        }
+        finally {
+            await file.close();
+        }
+    }
+    diagnostics() {
+        return {
+            elapsedMs: Math.max(0, Date.now() - this.startedAtMs),
+            timeoutMs: this.timeoutMs,
+            maxSourceBytes: this.policy.maxSourceBytes,
+            maxTotalSourceBytes: this.policy.maxTotalSourceBytes,
+            sourceBytes: this.sourceBytes,
+            sourceReads: this.sourceReads,
+            processedFragments: this.processedFragments,
+            maxSourceLines: this.policy.maxSourceLines,
+            maxSourceFacts: this.policy.maxSourceFacts,
+            sourceFacts: this.sourceFacts,
+            ...(this.sourceStop ? { truncationReason: this.sourceStop } : {}),
+        };
+    }
+    assertSourceFits(fileBytes, additionalBytes) {
+        if (fileBytes > this.policy.maxSourceBytes) {
+            this.sourceStop = 'runtime_source_bytes_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+        if (this.sourceBytes + additionalBytes > this.policy.maxTotalSourceBytes) {
+            this.sourceStop = 'runtime_total_source_bytes_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+    }
+}
+exports.AgentConversationExecution = AgentConversationExecution;
+AgentConversationExecution.scope = new async_hooks_1.AsyncLocalStorage();

package/dist/src/learning/agentConversationExecution.test.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const agentConversationExecution_1 = require("./agentConversationExecution");
+const agentResponseBudget_1 = require("./agentResponseBudget");
+describe('agent conversation execution limits', () => {
+    const document = {
+        documentId: 'bounded-source',
+        sourcePath: 'bounded/source.md',
+        content: '# Bounded Source\n\nA bounded source explains safe execution and complete evidence. '.repeat(24),
+    };
+    test('client capability hints cannot exceed the declared host tier', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({
+            autoPersist: false,
+            responseBudgetCapability: { memoryClass: 'low', workload: 'normal' },
+        });
+        await platform.ingestKnowledge({ documents: [document] });
+        const response = await platform.agentConversation({
+            message: 'Explain bounded source', responseMode: 'full', persistMemory: false,
+            responseBudgetCapability: { memoryClass: 'high', workload: 'max' },
+        });
+        expect(response.responseBudget?.tier).toBe('standard');
+    });
+    test('declines oversized sources without claiming a complete source scan', async () => {
+        const options = {
+            autoPersist: false,
+            responseExecutionPolicy: { maxSourceBytes: 96, maxTotalSourceBytes: 128 },
+        };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        const response = await platform.agentConversation({
+            message: 'Explain bounded source', responseMode: 'full', persistMemory: false,
+        });
+        expect(response.trace.ragContextPack?.sourceDecisions).toEqual(expect.arrayContaining([
+            expect.objectContaining({ status: 'source_window_unavailable', reason: 'runtime_source_bytes_limit' }),
+        ]));
+        expect(response.summary.responseTruncated).toBe(true);
+        expect(response.trace.ragSufficiencyReview?.status).not.toBe('sufficient');
+    });
+    test('expired query work cannot progress to memory or artifact writes', async () => {
+        const backend = {
+            id: 'delayed-query',
+            query: async (context) => {
+                await new Promise(resolve => setTimeout(resolve, 25));
+                return { candidates: context.atoms.map(atom => ({ atomId: atom.id, score: 1 })) };
+            },
+        };
+        const options = { autoPersist: false, graphQueryBackend: backend, responseExecutionPolicy: { timeoutMs: 5 } };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        await expect(platform.agentConversation({
+            userId: 'deadline-user', message: 'Explain bounded source', persistMemory: true,
+        })).rejects.toEqual(expect.objectContaining({ code: 'runtime_timeout' }));
+        const memory = await platform.listConversationMemory({ userId: 'deadline-user' });
+        expect(memory.entries).toHaveLength(0);
+        expect((await platform.addConversationMemory({ userId: 'deadline-user', content: 'next operation' })).added).toBe(true);
+    });
+    test('bounds admitted turns before they enter the serialized state queue', async () => {
+        let release;
+        const held = new Promise(resolve => { release = resolve; });
+        const backend = {
+            id: 'held-query',
+            query: async (context) => {
+                await held;
+                return { candidates: context.atoms.map(atom => ({ atomId: atom.id, score: 1 })) };
+            },
+        };
+        const options = { autoPersist: false, graphQueryBackend: backend, responseExecutionPolicy: { maxPendingTurns: 2 } };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        const first = platform.agentConversation({ message: 'First', persistMemory: false });
+        const second = platform.agentConversation({ message: 'Second', persistMemory: false });
+        const rejected = platform.agentConversation({ message: 'Third', persistMemory: false }).catch(error => error);
+        await new Promise(resolve => setImmediate(resolve));
+        release();
+        await Promise.all([first, second]);
+        expect((await rejected).code).toBe('runtime_turn_capacity');
+    });
+    test('cancels cooperative query I/O without retrying or writing memory', async () => {
+        const controller = new AbortController();
+        let entered;
+        const started = new Promise(resolve => { entered = resolve; });
+        let queries = 0;
+        const backend = {
+            id: 'cancellable-query',
+            query: async (context) => {
+                queries++;
+                const signal = context.signal;
+                entered();
+                await new Promise((_resolve, reject) => {
+                    if (signal.aborted)
+                        reject(signal.reason);
+                    else
+                        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+                });
+                return { candidates: [] };
+            },
+        };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false, graphQueryBackend: backend });
+        await platform.ingestKnowledge({ documents: [document] });
+        const turn = platform.agentConversation({ userId: 'cancelled-user', message: 'Bounded source' }, controller.signal)
+            .catch(error => error);
+        await started;
+        controller.abort();
+        expect((await turn).code).toBe('runtime_cancelled');
+        expect(queries).toBe(1);
+        expect((await platform.listConversationMemory({ userId: 'cancelled-user' })).entries).toHaveLength(0);
+    });
+    test('rejects dense source structure while preserving direct evidence', async () => {
+        const options = { autoPersist: false, responseExecutionPolicy: { maxSourceLines: 4 } };
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(options);
+        await platform.ingestKnowledge({ documents: [document] });
+        const response = await platform.agentConversation({ message: 'Explain bounded source', persistMemory: false });
+        expect(response.trace.ragContextPack?.sourceDecisions.some(item => item.reason === 'runtime_source_lines_limit')).toBe(true);
+        expect(response.trace.ragSufficiencyReview?.status).not.toBe('sufficient');
+        expect(response.citations.length).toBeGreaterThan(0);
+    });
+    test('keeps the default tier conservative when only the host ceiling is configured', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({
+            autoPersist: false,
+            responseBudgetHostCapability: { memoryClass: 'high', workload: 'max' },
+        });
+        await platform.ingestKnowledge({ documents: [document] });
+        const request = { message: 'Explain bounded source', responseMode: 'full', persistMemory: false };
+        expect((await platform.agentConversation(request)).responseBudget?.tier).toBe('standard');
+        expect((await platform.agentConversation({
+            ...request, responseBudgetCapability: { memoryClass: 'high', workload: 'max' },
+        })).responseBudget?.tier).toBe('max');
+    });
+    test('a cancelled queued turn never reaches query or persistence', async () => {
+        let release;
+        let entered;
+        const started = new Promise(resolve => { entered = resolve; });
+        const held = new Promise(resolve => { release = resolve; });
+        const query = jest.fn(async () => { entered(); await held; return { candidates: [] }; });
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false, graphQueryBackend: { id: 'held', query } });
+        const first = platform.agentConversation({ message: 'First', persistMemory: false });
+        await started;
+        const controller = new AbortController();
+        const second = platform.agentConversation({ userId: 'queued', message: 'Second' }, controller.signal).catch(error => error);
+        controller.abort();
+        release();
+        await first;
+        expect((await second).code).toBe('runtime_cancelled');
+        expect(query).toHaveBeenCalledTimes(1);
+        expect((await platform.listConversationMemory({ userId: 'queued' })).entries).toHaveLength(0);
+    });
+});
+describe('bounded source file I/O', () => {
+    let directory;
+    beforeEach(async () => { directory = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'source-budget-')); });
+    afterEach(async () => {
+        jest.restoreAllMocks();
+        await promises_1.default.rm(directory, { recursive: true, force: true });
+    });
+    test('counts UTF-8 bytes at the exact file limit and charges cumulative reads', async () => {
+        const filePath = path_1.default.join(directory, 'unicode.md');
+        const source = '知识🧠';
+        const bytes = Buffer.byteLength(source);
+        await promises_1.default.writeFile(filePath, source);
+        await agentConversationExecution_1.AgentConversationExecution.run({
+            budget: (0, agentResponseBudget_1.resolveAgentResponseBudget)(),
+            policy: (0, agentConversationExecution_1.normalizeAgentConversationExecutionPolicy)({ maxSourceBytes: bytes, maxTotalSourceBytes: bytes }),
+        }, async (execution) => {
+            expect(await execution.readSourceFile(filePath)).toBe(source);
+            expect(execution.diagnostics().sourceBytes).toBe(bytes);
+            await expect(execution.readSourceFile(filePath)).rejects.toHaveProperty('code', 'runtime_total_source_bytes_limit');
+        });
+    });
+    test('bounds actual bytes when a source grows after stat and closes the descriptor', async () => {
+        const filePath = path_1.default.join(directory, 'growing.md');
+        await promises_1.default.writeFile(filePath, 'small');
+        const file = await promises_1.default.open(filePath, 'r');
+        const oldStat = await file.stat();
+        await promises_1.default.appendFile(filePath, 'x'.repeat(128 * 1024));
+        jest.spyOn(file, 'stat').mockResolvedValueOnce(oldStat);
+        const close = jest.spyOn(file, 'close');
+        jest.spyOn(promises_1.default, 'open').mockResolvedValueOnce(file);
+        await expect(agentConversationExecution_1.AgentConversationExecution.run({
+            budget: (0, agentResponseBudget_1.resolveAgentResponseBudget)(),
+            policy: (0, agentConversationExecution_1.normalizeAgentConversationExecutionPolicy)({ maxSourceBytes: 16 }),
+        }, execution => execution.readSourceFile(filePath))).rejects.toHaveProperty('code', 'runtime_source_bytes_limit');
+        expect(close).toHaveBeenCalled();
+        await expect(file.stat()).rejects.toHaveProperty('code', 'EBADF');
+    });
+    test('aborts a source stream and closes its descriptor', async () => {
+        const filePath = path_1.default.join(directory, 'cancelled.md');
+        await promises_1.default.writeFile(filePath, Buffer.alloc(256 * 1024, 65));
+        const file = await promises_1.default.open(filePath, 'r');
+        const controller = new AbortController();
+        const createReadStream = file.createReadStream.bind(file);
+        jest.spyOn(file, 'createReadStream').mockImplementation(options => {
+            const stream = createReadStream(options);
+            stream.once('data', () => controller.abort());
+            return stream;
+        });
+        jest.spyOn(promises_1.default, 'open').mockResolvedValueOnce(file);
+        await expect(agentConversationExecution_1.AgentConversationExecution.run({
+            budget: (0, agentResponseBudget_1.resolveAgentResponseBudget)(), policy: (0, agentConversationExecution_1.normalizeAgentConversationExecutionPolicy)(), signal: controller.signal,
+        }, execution => execution.readSourceFile(filePath))).rejects.toHaveProperty('code', 'runtime_cancelled');
+        await expect(file.stat()).rejects.toHaveProperty('code', 'EBADF');
+    });
+});