sneakoscope 7.1.0 → 7.3.0

package/dist/core/agent-bridge/agent-manifest.js

@@ -1,6 +1,6 @@
-import { COMMANDS } from '../../cli/command-registry.js';
+import { COMMAND_MANIFEST_BY_NAME, COMMAND_MANIFEST_LITE, commandInputSchema, commandManifestNames } from '../../cli/command-manifest-lite.js';
 import { nowIso, PACKAGE_VERSION, sha256 } from '../fsx.js';
-import { NARUTO_ACTIONS, commandContract, validateCommandContractRegistry } from '../safety/command-contract/index.js';
+import { NARUTO_ACTIONS } from '../safety/command-contract/types.js';
 export const HOST_CAPABILITY_DESCRIPTORS = [
     {
         id: 'host.workspace.files.v1',
@@ -121,29 +121,28 @@ function exampleInvocation(name, jsonSupported) {
     return jsonSupported ? `sks ${name} --json` : `sks ${name}`;
 }
 function buildEntry(name, command) {
-    const contract = commandContract(name);
-    if (!contract)
-        throw new Error(`Missing command contract for ${name}`);
+    const remoteAllowed = command.risk === 'R3' ? false : command.remoteAllowed;
     return {
         name,
         description: command.summary,
-        read_only: contract.read_only,
-        requires_explicit_opt_in: contract.risk === 'R2' || contract.risk === 'R3',
-        json_output_supported: contract.supports_json,
-        latency_class: contract.latency,
-        example_invocation: exampleInvocation(name, contract.supports_json),
+        read_only: command.risk === 'R0',
+        requires_explicit_opt_in: command.risk === 'R2' || command.risk === 'R3',
+        json_output_supported: command.supportsJson,
+        latency_class: command.latency,
+        example_invocation: exampleInvocation(name, command.supportsJson),
         maturity: command.maturity,
-        contract_schema: contract.schema,
-        risk: contract.risk,
-        remote_allowed: contract.remote_allowed,
-        telegram_allowed: contract.telegram_allowed,
-        input_schema: contract.input_schema,
-        required_capabilities: [...contract.required_capabilities]
+        contract_schema: 'sks.command-contract.v2',
+        risk: command.risk,
+        remote_allowed: remoteAllowed,
+        telegram_allowed: remoteAllowed && command.telegramAllowed,
+        input_schema: commandInputSchema(command.inputProfile),
+        required_capabilities: [...command.requiredCapabilities]
     };
 }
 export function buildAgentManifest() {
-    const names = Object.keys(COMMANDS).sort();
-    const tools = names.map((name) => buildEntry(name, COMMANDS[name]));
+    const tools = [...COMMAND_MANIFEST_LITE]
+        .sort((left, right) => compareCodePoint(left.name, right.name))
+        .map((command) => buildEntry(command.name, command));
     return {
         schema: 'sks.agent-manifest.v1',
         generated_at: nowIso(),
@@ -154,16 +153,15 @@ export function buildAgentManifest() {
 }
 export function validateAgentManifest(manifest) {
     const candidate = manifest;
-    const expectedNames = Object.keys(COMMANDS).sort();
+    const expectedNames = commandManifestNames();
     const tools = Array.isArray(candidate?.tools) ? candidate.tools : [];
     const observedNames = tools.map((tool) => String(tool?.name || '')).filter(Boolean);
     const observedSet = new Set(observedNames);
     const duplicateNames = [...new Set(observedNames.filter((name, index) => observedNames.indexOf(name) !== index))].sort();
     const missingNames = expectedNames.filter((name) => !observedSet.has(name));
-    const unexpectedNames = [...observedSet].filter((name) => !(name in COMMANDS)).sort();
+    const unexpectedNames = [...observedSet].filter((name) => !Object.hasOwn(COMMAND_MANIFEST_BY_NAME, name)).sort();
     const sortedNames = [...observedNames].sort();
     const issues = [];
-    const contractValidation = validateCommandContractRegistry();
     if (candidate?.schema !== 'sks.agent-manifest.v1')
         issues.push('schema');
     if (!candidate?.compatibility || typeof candidate.compatibility !== 'object' || Array.isArray(candidate.compatibility)) {
@@ -247,8 +245,6 @@ export function validateAgentManifest(manifest) {
                 issues.push(`host_capabilities:missing:${expected.id}`);
         }
     }
-    if (!contractValidation.ok)
-        issues.push(...contractValidation.issues.map((entry) => `command_contract:${entry}`));
     if (!Array.isArray(candidate?.tools))
         issues.push('tools');
     if (duplicateNames.length)
@@ -285,15 +281,15 @@ export function validateAgentManifest(manifest) {
             issues.push(`invalid_input_schema:${name || '<missing>'}`);
     }
     const naruto = tools.find((tool) => tool?.name === 'naruto');
-    const expectedNaruto = commandContract('naruto');
+    const expectedNaruto = buildEntry('naruto', COMMAND_MANIFEST_BY_NAME.naruto);
     const narutoActions = naruto?.input_schema?.properties?.action?.enum;
     if (JSON.stringify(narutoActions) !== JSON.stringify(NARUTO_ACTIONS))
         issues.push('naruto_action_contract_mismatch');
     if (naruto?.risk !== expectedNaruto?.risk || naruto?.risk !== 'R2')
         issues.push('contract_risk_mismatch:naruto');
-    if (naruto?.latency_class !== expectedNaruto?.latency || naruto?.latency_class !== 'long')
+    if (naruto?.latency_class !== expectedNaruto?.latency_class || naruto?.latency_class !== 'long')
         issues.push('contract_latency_mismatch:naruto');
-    if (naruto?.json_output_supported !== expectedNaruto?.supports_json || naruto?.json_output_supported !== true)
+    if (naruto?.json_output_supported !== expectedNaruto?.json_output_supported || naruto?.json_output_supported !== true)
         issues.push('contract_json_mismatch:naruto');
     if (naruto?.remote_allowed !== expectedNaruto?.remote_allowed || naruto?.remote_allowed !== false)
         issues.push('contract_remote_mismatch:naruto');

package/dist/core/agent-bridge/host-capability-policy.js

@@ -2,6 +2,7 @@ import { sha256 } from '../fsx.js';
 import { testMcpConnection } from '../mcp-config/health-check.js';
 import { listMcpInventory } from '../mcp-config/inventory.js';
 import { HOST_CAPABILITY_DESCRIPTORS, hostCapabilityDigest } from './agent-manifest.js';
+import { uniqueStringsSorted as uniqueStrings } from '../text/strings.js';
 export const HOST_CAPABILITY_RUNTIME_SCHEMA = 'sks.host-capability-runtime.v1';
 export const HOST_CAPABILITY_MCP_SERVER = 'acas-tools';
 const MAX_OBSERVED_TOOL_NAMES = 256;
@@ -22,11 +23,13 @@ export function requestHostCapabilities(goal) {
     ]);
     const spreadsheetCreate = blankWorkbook || matches(text, [
         /\b(?:create|generate|produce|deliver|make|build|prepare|convert|export)\b.{0,48}\b(?:xlsx|excel|spreadsheet|workbook)\b/i, /\b(?:xlsx|excel|spreadsheet|workbook)\b.{0,48}\b(?:create|generate|produce|deliver|make|build|prepare|convert|export)\b/i,
-        /(?:엑셀|스프레드시트|xlsx).{0,32}(?:생성|작성|만들|납품)/i, /(?:생성|작성|만들|납품).{0,32}(?:엑셀|스프레드시트|xlsx)/i
+        /(?:엑셀|스프레드시트|xlsx).{0,32}(?:생성|작성|만들|납품)/i, /(?:생성|작성|만들|납품).{0,32}(?:엑셀|스프레드시트|xlsx)/i,
+        /(?:엑셀로 정리|엑셀 파일로 저장|엑셀로 내보내|스프레드시트 보고서|xlsx로 변환|표를 엑셀로)/i
     ]);
     const spreadsheetMutation = matches(text, [
         /\b(?:edit|update|modify|populate|fill|append|import)\b.{0,56}\b(?:xlsx|excel|spreadsheet|workbook)\b/i, /\b(?:xlsx|excel|spreadsheet|workbook)\b.{0,56}\b(?:edit|update|modify|populate|fill|append|import)\b/i,
-        /(?:엑셀|스프레드시트|xlsx).{0,36}(?:수정|편집|업데이트|입력|채우|반영|추가)/i, /(?:수정|편집|업데이트|입력|채우|반영|추가).{0,36}(?:엑셀|스프레드시트|xlsx)/i
+        /(?:엑셀|스프레드시트|xlsx).{0,36}(?:수정|편집|업데이트|입력|채우|반영|추가)/i, /(?:수정|편집|업데이트|입력|채우|반영|추가).{0,36}(?:엑셀|스프레드시트|xlsx)/i,
+        /기존 엑셀 수식 오류를 고쳐/i
     ]);
     const spreadsheetInspection = matches(text, [
         /\binspect\b.{0,56}\b(?:xlsx|excel|spreadsheet|workbook)\b/i, /\b(?:xlsx|excel|spreadsheet|workbook)\b.{0,56}\binspect\b/i,
@@ -38,16 +41,36 @@ export function requestHostCapabilities(goal) {
     const queryPatterns = [
         /\b(?:query|retrieve|fetch|load|analy[sz]e|show|list)\b.{0,56}\b(?:database|datasource|data|rows?|records?|results?)\b/i, /\b(?:database|datasource|data|rows?|records?|results?)\b.{0,56}\b(?:query|retrieve|fetch|load|analy[sz]e|show|list)\b/i,
         /\b(?:get|read)\b.{0,56}\b(?:data|rows?|records?|results?)\b.{0,48}\b(?:from|in)\s+(?:the\s+)?(?:database|datasource|db)\b/i, /\bpull\b.{0,64}\b(?:from|out\s+of)\s+(?:the\s+)?(?:database|datasource|db)\b/i,
-        /\b(?:from|in)\s+(?:the\s+)?(?:database|datasource|db)\b.{0,56}\b(?:get|read|pull)\b.{0,48}\b(?:data|rows?|records?|results?)\b/i, /(?:db|데이터베이스|데이터소스|데이터).{0,36}(?:조회|가져오|검색|분석|질의)/i, /(?:조회|가져오|검색|분석|질의).{0,36}(?:db|데이터베이스|데이터소스|데이터)/i
+        /\b(?:from|in)\s+(?:the\s+)?(?:database|datasource|db)\b.{0,56}\b(?:get|read|pull)\b.{0,48}\b(?:data|rows?|records?|results?)\b/i, /(?:db|데이터베이스|데이터소스|데이터).{0,36}(?:조회|가져오|검색|분석|질의)/i, /(?:조회|가져오|검색|분석|질의).{0,36}(?:db|데이터베이스|데이터소스|데이터)/i,
+        /(?:DB에서 뽑아|데이터베이스 집계)/i
+    ];
+    const genericAggregatePatterns = [/(?:월별 합계|통계 내줘|현황 조회|상위\s*(?:N|\d+)\s*건)/i];
+    const datasourceCuePatterns = [
+        /(?:\bdb\b|데이터베이스|데이터소스|\bmysql\b|\bpostgres(?:ql)?\b|\bsupabase\b|\bconnector\b)/i,
+        /\b[a-z][a-z0-9_-]*:[a-z0-9][a-z0-9_.-]*\b/i
+    ];
+    const fileDataContextPatterns = [
+        /(?:\bcsv\b|\bjson\b|\bxlsx\b|문서|파일)(?:\s*(?:안|내부))?(?:의|에서|에\s*있는)\s*(?:데이터|내용|행|레코드)?/i,
+        /(?:\bcsv\b|\bjson\b|\bxlsx\b)\s*(?:data|데이터)/i
+    ];
+    const queryExecutionExclusions = [
+        ...executionExclusions,
+        /(?:sql|쿼리|질의).{0,24}(?:실행(?:은|을)?\s*(?:금지|하지\s*마|없이)|만\s*(?:작성|생성))/i,
+        /(?:실행(?:은|을)?\s*(?:금지|하지\s*마|없이)|만\s*(?:작성|생성)).{0,24}(?:sql|쿼리|질의)/i
     ];
     const sqlGeneration = matches(text, sqlPatterns);
     const clauses = text.split(/\n+/).map((clause) => clause.trim()).filter(Boolean);
     const datasourceQuery = clauses.some((clause, index) => {
         const nearby = [clauses[index - 1], clause, clauses[index + 1]].filter((value) => Boolean(value));
-        return !(matches(clause, sqlPatterns) && nearby.some((value) => matches(value, executionExclusions))) && matches(clause, queryPatterns);
+        if (matches(clause, fileDataContextPatterns) || matches(clause, queryExecutionExclusions))
+            return false;
+        if (matches(clause, sqlPatterns) && nearby.some((value) => matches(value, queryExecutionExclusions)))
+            return false;
+        return matches(clause, queryPatterns)
+            || (matches(clause, genericAggregatePatterns) && matches(clause, datasourceCuePatterns));
     });
-    const documentRender = matches(text, [/\b(?:render|generate|create|export|deliver)\b.{0,48}\b(?:pdf|png|document screenshot)\b/i, /\b(?:pdf|png|document screenshot)\b.{0,48}\b(?:render|generate|create|export|deliver)\b/i, /(?:pdf|png|문서).{0,32}(?:렌더|생성|작성|내보내|납품)/i, /(?:렌더|생성|작성|내보내|납품).{0,32}(?:pdf|png|문서)/i]);
-    const webCapture = matches(text, [/\b(?:capture|take|create)\b.{0,40}\b(?:url|web|page)\b.{0,24}\bscreenshot\b/i, /\b(?:url|web|page)\b.{0,40}\bscreenshot\b/i, /(?:url|웹|페이지).{0,32}(?:스크린샷|캡처)/i]);
+    const documentRender = matches(text, [/\b(?:render|generate|create|export|deliver)\b.{0,48}\b(?:pdf|png|document screenshot)\b/i, /\b(?:pdf|png|document screenshot)\b.{0,48}\b(?:render|generate|create|export|deliver)\b/i, /(?:pdf|png|문서).{0,32}(?:렌더|생성|작성|내보내|납품)/i, /(?:렌더|생성|작성|내보내|납품).{0,32}(?:pdf|png|문서)/i, /(?:PDF 파일로 저장|문서를 PDF로|화면을 PNG로)/i, /(?:html|문서|보고서).{0,32}(?:pdf|png|렌더|이미지로)/i]);
+    const webCapture = matches(text, [/\b(?:capture|take|create)\b.{0,40}\b(?:url|web|site|page)\b.{0,24}\bscreenshot\b/i, /\b(?:url|web|site|page)\b.{0,40}\bscreenshot\b/i, /(?:url|웹|사이트|페이지).{0,32}(?:스크린샷|캡처|이미지로)/i]);
     const workspace = (action, korean) => matches(text, [new RegExp(`\\bworkspace\\b.{0,48}\\b(?:${action})\\b`, 'i'), new RegExp(`\\b(?:${action})\\b.{0,48}\\bworkspace\\b`, 'i'), new RegExp(`워크스페이스.{0,36}(?:${korean})`, 'i'), new RegExp(`(?:${korean}).{0,36}워크스페이스`, 'i')]);
     const workspaceRead = workspace('read|open|inspect', '읽|열|검사|점검');
     const workspaceFind = workspace('find|search', '찾|검색');
@@ -72,7 +95,7 @@ export function requestHostCapabilities(goal) {
         workflows.add('spreadsheet_edit');
     }
     if (documentRender) {
-        const tools = [...(/\bpdf\b/i.test(text) ? ['html_to_pdf'] : []), ...(/\b(?:png|document screenshot)\b/i.test(text) || /(?:png|문서 스크린샷)/i.test(text) ? ['html_to_screenshot'] : [])];
+        const tools = [...(/\bpdf\b/i.test(text) ? ['html_to_pdf'] : []), ...(/\b(?:png|document screenshot)\b/i.test(text) || /(?:png|문서 스크린샷|화면을 PNG로|페이지 이미지로)/i.test(text) ? ['html_to_screenshot'] : [])];
         request('host.workspace.files.v1', ['write_file']);
         request('host.document.render.v1', tools.length ? tools : ['html_to_pdf', 'html_to_screenshot']);
         workflows.add('workspace_files');
@@ -180,9 +203,87 @@ function codeMaintenance(text) {
 function directExecution(text) {
     return matches(text, [/\b(?:create|generate|make|build|prepare|render)\s+(?:an?\s+|the\s+)?(?:xlsx|excel workbook|excel report|spreadsheet(?: file| report)?|workbook(?: file)?|pdf(?: file| document| report)?|png(?: file| image)?)\b(?!\s+(?:parser|reader|writer|module|tests?|specs?|fixtures?|code|implementation)\b)/i, /\b(?:populate|fill)\b.{0,24}\b(?:new|blank|empty)\b.{0,24}\b(?:xlsx|excel(?: workbook)?|spreadsheet|workbook)\b/i, /\b(?:deliver|export|save|produce)\b.{0,32}\b(?:xlsx|excel|spreadsheet|workbook|pdf|png|artifact|deliverable)\b/i, /\b(?:edit|update|modify|populate|fill|append|import|inspect)\s+(?:the\s+|an?\s+)?(?:existing\s+)?(?:xlsx|excel(?: workbook)?|spreadsheet|workbook)\b(?!\s+(?:parser|reader|writer|module|tests?|specs?|fixtures?|code|implementation)\b)/i, /\b(?:edit|update|modify|populate|fill|append|import)\b.{0,48}\b[A-Za-z0-9._/-]+\.xlsx\b/i, /\b(?:inspect|open)\b.{0,64}\b[A-Za-z0-9._/-]+\.xlsx\b.{0,48}\b(?:and\s+)?(?:edit|update|modify|populate|fill|append|import)\s+(?:it|the\s+(?:file|workbook|spreadsheet))\b/i, /\b(?:run|execute)\b.{0,32}\b(?:read[- ]only\s+)?(?:query|select|cte)\b(?!\s+(?:(?:unit|integration|regression)\s+)?tests?\b)/i, /\b(?:query|retrieve|fetch|load)\b.{0,40}\b(?:database|datasource|rows?|records?|results?|(?:customer|sales|database)?\s*data)\b/i, /\b(?:get|read)\b.{0,56}\b(?:data|rows?|records?|results?)\b.{0,48}\b(?:from|in)\s+(?:the\s+)?(?:database|datasource|db)\b/i, /\bpull\b.{0,64}\b(?:from|out\s+of)\s+(?:the\s+)?(?:database|datasource|db)\b/i, /\b(?:from|in)\s+(?:the\s+)?(?:database|datasource|db)\b.{0,56}\b(?:get|read|pull)\b.{0,48}\b(?:data|rows?|records?|results?)\b/i, /\banaly[sz]e\b.{0,40}\b(?:database\s+data|datasource\s+data|rows?|records?|query\s+results?|customer\s+data|sales\s+data)\b/i, /\b(?:test|inspect|review)\b.{0,32}\b(?:pdf|png)\b.{0,24}\band\s+(?:export|deliver|save|render)\s+(?:it|the\s+(?:file|document|image))\b/i, /(?:엑셀|스프레드시트|xlsx)(?!\s*(?:파서|리더|라이터|모듈|코드|테스트|스펙|픽스처)).{0,20}(?:업데이트|수정|편집|입력|채우|반영)/i, /(?:업데이트|수정|편집|입력|채우|반영).{0,20}(?:엑셀|스프레드시트|xlsx)/i, /(?:엑셀|스프레드시트|xlsx|pdf|png).{0,24}(?:파일|문서|보고서|산출물).{0,24}(?:생성|작성|만들|렌더|내보내|납품|저장)/i, /(?:생성|작성|만들|렌더|내보내|납품|저장).{0,24}(?:엑셀|스프레드시트|xlsx|pdf|png)(?:\s*(?:파일|문서|보고서|산출물))?/i, /(?:실행|조회|가져오).{0,24}(?:읽기\s*전용\s*)?(?:쿼리|질의|행|레코드|결과)/i]);
 }
+export function renderHostCapabilityBlockedLines(blockers, fallback) {
+    const codes = uniqueStrings(blockers
+        .map((value) => String(value || '').trim().split(/\r?\n/, 1)[0] || '')
+        .map((value) => value.match(/^[a-z][a-z0-9.-]*(?:_[a-z0-9.-]+)+(?::[a-z0-9_.-]+)*/i)?.[0] || '')
+        .map((value) => value.slice(0, 180))
+        .filter(Boolean));
+    const prioritized = [...codes].sort((left, right) => blockerPriority(left) - blockerPriority(right));
+    const primary = prioritized[0] || 'host_capability_blocked';
+    const guidance = blockerGuidance(primary, fallback);
+    return [
+        '상태: 차단',
+        `이유: ${guidance.reason}`,
+        `조치: ${guidance.action}`,
+        `코드: ${primary}`
+    ];
+}
+function blockerPriority(code) {
+    if (/^(?:host_capability_project_trust_missing|host_tool_call_not_allowed)/.test(code))
+        return 0;
+    if (/^(?:host_capability_missing|host_capability_unhealthy|host_capability_project_mcp_inventory_unhealthy)|mcp.*(?:connection|inventory|health|missing|tool)/.test(code))
+        return 1;
+    if (/(?:datasource|readonly_query).*(?:mismatch|schema)|spreadsheet.*(?:sequence|inspection_not_completed|resource_mismatch|update_count_invalid)|document.*(?:source|path|required|resource_mismatch)|(?:input|argument|contract).*(?:invalid|required|mismatch)/.test(code))
+        return 2;
+    if (/host_tool_response_malformed|artifact.*missing|receipt.*missing|error_cell/.test(code))
+        return 3;
+    if (/(?:proof|receipt).*mismatch|parent_receipts_mismatch/.test(code))
+        return 4;
+    return 4;
+}
+function blockerGuidance(code, fallback) {
+    if (code.startsWith('host_tool_call_not_allowed')) {
+        const tool = code.split(':')[1] || '요청한 도구';
+        return {
+            reason: `현재 에이전트에 ${tool === 'spreadsheet_update' ? '엑셀 수정' : '요청한'} 도구가 허용되지 않았습니다.`,
+            action: `ACAS 에이전트 도구 권한에서 ${tool}를 허용한 뒤 같은 요청을 다시 실행하세요.`
+        };
+    }
+    if (code.startsWith('host_capability_project_trust_missing'))
+        return {
+            reason: '프로젝트 신뢰가 확인되지 않아 호스트 도구를 사용할 수 없습니다.',
+            action: '프로젝트를 신뢰한 뒤 --trusted-project로 같은 요청을 다시 실행하세요.'
+        };
+    if (code.startsWith('host_capability_missing'))
+        return {
+            reason: '요청한 호스트 기능이 현재 ACAS 도구 목록에 없습니다.',
+            action: 'ACAS 에이전트 도구 권한과 acas-tools 구성을 확인한 뒤 다시 실행하세요.'
+        };
+    if (blockerPriority(code) === 1)
+        return {
+            reason: 'acas-tools MCP 연결 또는 상태 확인에 실패했습니다.',
+            action: '프로젝트 MCP inventory와 acas-tools health를 복구한 뒤 다시 실행하세요.'
+        };
+    if (code.startsWith('host_tool_response_malformed:datasource_query_readonly'))
+        return {
+            reason: 'DB 조회 결과가 SKS가 검증할 수 있는 응답 형식을 따르지 않았습니다.',
+            action: 'ACAS Agent를 최신 호환 버전으로 업데이트한 뒤 같은 mission을 재실행하세요.'
+        };
+    if (code.startsWith('host_tool_response_malformed'))
+        return {
+            reason: '호스트 도구 결과가 SKS가 검증할 수 있는 응답 형식을 따르지 않았습니다.',
+            action: 'ACAS Agent를 최신 호환 버전으로 업데이트한 뒤 같은 mission을 재실행하세요.'
+        };
+    if (/(?:datasource|readonly_query).*(?:mismatch|schema)/.test(code))
+        return {
+            reason: '데이터 조회가 선행 스키마 정보와 일치하지 않습니다.',
+            action: '같은 datasource의 schema context를 다시 받고 matching snapshot으로 조회하세요.'
+        };
+    if (/spreadsheet.*(?:sequence|inspection_not_completed|resource_mismatch|update_count_invalid)/.test(code))
+        return {
+            reason: '엑셀 작업 순서 또는 대상 파일이 검사 결과와 일치하지 않습니다.',
+            action: '같은 파일을 create/update 뒤 inspect하고 허용된 mutation 상한 안에서 다시 실행하세요.'
+        };
+    if (blockerPriority(code) >= 3)
+        return {
+            reason: '최종 산출물 또는 proof receipt 검증이 완료되지 않았습니다.',
+            action: '산출물을 다시 생성·검사하고 최종 mutation 또는 render receipt를 제출하세요.'
+        };
+    return fallback;
+}
 function matches(text, patterns) { return patterns.some((pattern) => pattern.test(text)); }
 function tomlArray(values) { return `[${values.map((value) => JSON.stringify(value)).join(', ')}]`; }
-function uniqueStrings(values) { return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))].sort(); }
 function uniqueWorkflows(values) {
     const valid = new Set(['datasource_sql_generation', 'datasource_query', 'spreadsheet_create', 'spreadsheet_edit', 'document_render', 'web_capture', 'workspace_files', 'artifact_delivery']);
     return uniqueStrings(values).filter((value) => valid.has(value));

package/dist/core/agent-bridge/host-capability-runtime.js

@@ -1,6 +1,8 @@
 import { sha256 } from '../fsx.js';
 import { HOST_CAPABILITY_DESCRIPTORS, hostCapabilityDigest } from './agent-manifest.js';
 import { HOST_CAPABILITY_MCP_SERVER, HOST_CAPABILITY_RUNTIME_SCHEMA, hostCapabilityRuntimeDigest } from './host-capability-policy.js';
+import { isRecord } from '../json/records.js';
+import { uniqueStringsSorted as uniqueStrings } from '../text/strings.js';
 export { HOST_CAPABILITY_MCP_SERVER, HOST_CAPABILITY_RUNTIME_SCHEMA, hostCapabilityCodexConfigArgs, inspectHostCapabilityRuntime, requestHostCapabilities } from './host-capability-policy.js';
 export const HOST_CAPABILITY_EVIDENCE_SCHEMA = 'sks.host-capability-evidence.v1';
 export const HOST_CAPABILITY_HOOK_RUNTIME_SCHEMA = 'sks.host-capability-hook-runtime.v1';
@@ -10,7 +12,9 @@ export const HOST_CAPABILITY_HOOK_RUNTIME_FILENAME = 'host-capability-runtime.js
 export const HOST_CAPABILITY_HOOK_PENDING_RUNTIME_FILENAME = 'host-capability-runtime-pending.json';
 export const HOST_CAPABILITY_HOOK_OBSERVATIONS_FILENAME = 'host-capability-hook-observations.json';
 export const HOST_CAPABILITY_HOOK_EVIDENCE_FILENAME = 'host-capability-evidence.json';
-const MAX_EVENT_LINE_BYTES = 512 * 1024;
+const MAX_HOST_TOOL_STRUCTURED_RESULT_BYTES = 4 * 1024 * 1024;
+const MAX_EVENT_LINE_BYTES = 5 * 1024 * 1024;
+const MAX_EVENT_BUFFER_BYTES = 10 * 1024 * 1024;
 const MAX_MCP_TOOL_CALLS = 1024;
 const MAX_PRE_TOOL_OBSERVATIONS = 2048;
 const MAX_RECEIPT_JSON_STRING_BYTES = 64 * 1024;
@@ -123,7 +127,15 @@ export function sanitizeHostCapabilityPreToolUse(runtime, payload) {
     if (!tool || !toolUseId)
         return null;
     const toolInput = isRecord(payload.tool_input) ? payload.tool_input : {};
-    const resourceKey = extractToolResourceKey({ arguments: payload.tool_input });
+    const documentRender = tool === 'html_to_pdf' || tool === 'html_to_screenshot';
+    const documentSourcePath = documentRender ? normalizeDocumentSourcePath(toolInput.source_path) : null;
+    const documentSourceBlocker = documentRender
+        && (Object.prototype.hasOwnProperty.call(toolInput, 'html') || !documentSourcePath)
+        ? 'host_capability_document_source_path_required'
+        : null;
+    const resourceKey = documentRender
+        ? documentSourcePath && workspaceResourceKey(documentSourcePath)
+        : extractToolResourceKey({ arguments: payload.tool_input });
     const datasource = tool === 'datasource_schema_context' || tool === 'datasource_query_readonly'
         ? boundedIdentity(toolInput.datasource)
         : null;
@@ -132,14 +144,15 @@ export function sanitizeHostCapabilityPreToolUse(runtime, payload) {
         : null;
     const allowed = runtime.ok
         && runtime.allowed_tool_names.includes(tool)
-        && !explicitlyDeniedHostCapabilityTool(tool);
+        && !explicitlyDeniedHostCapabilityTool(tool)
+        && !documentSourceBlocker;
     const blocker = !runtime.ok
         ? 'host_capability_runtime_unavailable'
         : explicitlyDeniedHostCapabilityTool(tool)
             ? `host_tool_call_explicitly_denied:${tool}`
             : !runtime.allowed_tool_names.includes(tool)
                 ? `host_tool_call_not_allowed:${tool}`
-                : null;
+                : documentSourceBlocker;
     return {
         tool_use_id_sha256: `sha256:${sha256(toolUseId)}`,
         tool,
@@ -170,9 +183,9 @@ export function sanitizeHostCapabilityPostToolUse(payload) {
         ? 'failed'
         : 'passed';
     const artifacts = status === 'passed'
-        ? extractArtifactReceipts(payload.tool_response)
+        ? extractArtifactReceipts(response)
         : [];
-    const resourceKey = extractToolResourceKey({
+    const resourceKey = extractHostToolResourceKey(tool, {
         arguments: payload.tool_input,
         result: payload.tool_response
     });
@@ -315,6 +328,19 @@ function authorizePreToolReservation(runtime, current, observation) {
             return denyPreToolReservation(observation, 'host_capability_spreadsheet_update_inspection_not_completed');
         }
     }
+    if (observation.tool === 'html_to_pdf' || observation.tool === 'html_to_screenshot') {
+        const completedSourceWrites = [
+            ...completedPassedToolCalls(current, 'write_file'),
+            ...completedPassedToolCalls(current, 'edit_file')
+        ];
+        if (completedSourceWrites.length === 0) {
+            return denyPreToolReservation(observation, 'host_capability_document_source_sequence_invalid');
+        }
+        if (!observation.resource_key
+            || !completedSourceWrites.some((call) => call.resource_key === observation.resource_key)) {
+            return denyPreToolReservation(observation, 'host_capability_document_source_resource_mismatch');
+        }
+    }
     return {
         ...observation,
         decision: 'allowed',
@@ -573,20 +599,20 @@ export function createHostCapabilityEventCollector(runtime) {
             event_sha256: rawHash,
             raw_hash: rawHash,
             index: callIndex,
-            resource_key: extractToolResourceKey(item),
+            resource_key: extractHostToolResourceKey(tool, item),
             semantic_receipt: semantic.receipt
         });
         if (semantic.blocker)
             blockers.push(semantic.blocker);
         if (status === 'passed') {
-            for (const artifact of extractArtifactReceipts(item.result?.structured_content ?? item.result?.structuredContent ?? item.result)) {
+            for (const artifact of extractArtifactReceipts(response)) {
                 observedArtifacts.push({ ...artifact, source_tool: tool, source_hash: rawHash, source_index: callIndex });
             }
         }
     };
     const push = (chunk) => {
         buffer += String(chunk || '');
-        if (Buffer.byteLength(buffer, 'utf8') > MAX_EVENT_LINE_BYTES * 2 && !buffer.includes('\n')) {
+        if (Buffer.byteLength(buffer, 'utf8') > MAX_EVENT_BUFFER_BYTES && !buffer.includes('\n')) {
             blockers.push('host_tool_event_buffer_too_large');
             buffer = '';
             return;
@@ -712,36 +738,47 @@ function validateCapabilityWorkflow(runtime, descriptor, calls, allCalls, artifa
         blockers.push('host_capability_schema_call_missing');
     }
     if (descriptor.id === 'host.datasource.query.readonly.v1') {
-        const schemaCall = allCalls.find((call) => call.tool === 'datasource_schema_context' && call.status === 'passed') || null;
+        const schemaCalls = allCalls.filter((call) => (call.tool === 'datasource_schema_context' && call.status === 'passed'));
         const queryCalls = passed('datasource_query_readonly');
-        const schemaIndex = schemaCall?.index ?? -1;
         if (queryCalls.length === 0)
             blockers.push('host_capability_readonly_query_call_missing');
         if (runtime.task_workflows.includes('datasource_query')
             && (queryCalls.length < 1 || queryCalls.length > MAX_DATASOURCE_QUERY_RESERVATIONS)) {
             blockers.push('host_capability_readonly_query_count_invalid');
         }
-        if (runtime.task_workflows.includes('datasource_query')
-            && (schemaIndex < 0 || queryCalls.some((call) => call.index <= schemaIndex))) {
-            blockers.push('host_capability_datasource_sequence_invalid');
-        }
-        const schemaReceipt = schemaCall?.semantic_receipt?.kind === 'datasource_schema'
-            ? schemaCall.semantic_receipt
-            : null;
-        const queryReceipts = queryCalls
-            .map((call) => call.semantic_receipt?.kind === 'datasource_query' ? call.semantic_receipt : null);
-        if (queryCalls.length > 0 && queryReceipts.some((receipt) => !receipt)) {
-            blockers.push('host_capability_readonly_query_receipt_invalid');
-        }
-        if (schemaCall && !schemaReceipt)
-            blockers.push('host_capability_schema_receipt_invalid');
-        if (schemaReceipt && queryReceipts.some((receipt) => receipt
-            && schemaReceipt.schema_snapshot_sha256 !== receipt.schema_snapshot_sha256)) {
-            blockers.push('host_capability_readonly_query_schema_mismatch');
-        }
-        if (schemaReceipt && queryReceipts.some((receipt) => receipt
-            && schemaReceipt.datasource_sha256 !== receipt.datasource_sha256)) {
-            blockers.push('host_capability_readonly_query_datasource_mismatch');
+        for (const queryCall of queryCalls) {
+            const precedingSchemaCalls = schemaCalls.filter((call) => call.index < queryCall.index);
+            const sequenceInvalid = runtime.task_workflows.includes('datasource_query')
+                && precedingSchemaCalls.length === 0;
+            if (sequenceInvalid)
+                blockers.push('host_capability_datasource_sequence_invalid');
+            const precedingSchemaReceipts = precedingSchemaCalls
+                .map((call) => call.semantic_receipt?.kind === 'datasource_schema' ? call.semantic_receipt : null);
+            const validSchemaReceipts = precedingSchemaReceipts.filter(Boolean);
+            const queryReceipt = queryCall.semantic_receipt?.kind === 'datasource_query'
+                ? queryCall.semantic_receipt
+                : null;
+            if (!queryReceipt)
+                blockers.push('host_capability_readonly_query_receipt_invalid');
+            if (precedingSchemaCalls.length > 0 && validSchemaReceipts.length === 0) {
+                blockers.push('host_capability_schema_receipt_invalid');
+            }
+            if (!queryReceipt || sequenceInvalid || validSchemaReceipts.length === 0)
+                continue;
+            const matchingSchemaCall = [...precedingSchemaCalls]
+                .sort((left, right) => right.index - left.index)
+                .find((call) => (call.semantic_receipt?.kind === 'datasource_schema'
+                && call.semantic_receipt.datasource_sha256 === queryReceipt.datasource_sha256
+                && call.semantic_receipt.schema_snapshot_sha256 === queryReceipt.schema_snapshot_sha256));
+            if (matchingSchemaCall)
+                continue;
+            const matchingDatasourceReceipts = validSchemaReceipts.filter((receipt) => (receipt.datasource_sha256 === queryReceipt.datasource_sha256));
+            if (matchingDatasourceReceipts.length === 0) {
+                blockers.push('host_capability_readonly_query_datasource_mismatch');
+            }
+            else {
+                blockers.push('host_capability_readonly_query_schema_mismatch');
+            }
         }
     }
     if (descriptor.id === 'host.spreadsheet.workbook.v1') {
@@ -835,11 +872,17 @@ function validateCapabilityWorkflow(runtime, descriptor, calls, allCalls, artifa
             blockers.push('host_capability_document_render_call_missing');
         }
         else {
-            const sourceWrite = allCalls.find((call) => (call.status === 'passed'
+            const firstRender = renderCalls[0];
+            const precedingSourceWrites = allCalls.filter((call) => (call.status === 'passed'
                 && (call.tool === 'write_file' || call.tool === 'edit_file')
-                && call.index < renderCalls[0].index));
-            if (!sourceWrite)
+                && call.index < firstRender.index));
+            if (precedingSourceWrites.length === 0) {
                 blockers.push('host_capability_document_source_sequence_invalid');
+            }
+            else if (!firstRender.resource_key
+                || !precedingSourceWrites.some((call) => call.resource_key === firstRender.resource_key)) {
+                blockers.push('host_capability_document_source_resource_mismatch');
+            }
             const finalRender = renderCalls.at(-1);
             if (!artifacts.some((artifact) => (artifact.source_tool === finalRender.tool
                 && artifact.source_index === finalRender.index
@@ -853,18 +896,53 @@ function validateCapabilityWorkflow(runtime, descriptor, calls, allCalls, artifa
         && passed('capture_url_screenshot').length === 0) {
         blockers.push('host_capability_web_capture_call_missing');
     }
-    if (descriptor.id === 'host.artifact.receipt.v1' && artifacts.length === 0) {
-        blockers.push('host_capability_artifact_receipt_missing');
+    if (descriptor.id === 'host.artifact.receipt.v1') {
+        const artifactReceiptExceptions = new Set([
+            'spreadsheet_inspect',
+            'read_file',
+            'find_workspace_files',
+            'list_workspace'
+        ]);
+        const artifactProducingTools = new Set(descriptor.tool_names.filter((tool) => !artifactReceiptExceptions.has(tool)));
+        const passedArtifactCalls = calls.filter((call) => (call.status === 'passed' && artifactProducingTools.has(call.tool)));
+        if (artifacts.length === 0 || passedArtifactCalls.some((call) => !artifacts.some((artifact) => (artifact.source_tool === call.tool && artifact.source_index === call.index)))) {
+            blockers.push('host_capability_artifact_receipt_missing');
+        }
     }
     return uniqueStrings(blockers);
 }
+function normalizeDocumentSourcePath(value) {
+    const normalized = normalizeWorkspaceResourcePath(value);
+    return typeof value === 'string'
+        && value === normalized
+        && /\.html$/i.test(normalized)
+        ? normalized
+        : null;
+}
+function workspaceResourceKey(resourcePath) {
+    return `sha256:${sha256(resourcePath)}`;
+}
+function extractHostToolResourceKey(tool, item) {
+    if ((tool === 'html_to_pdf' || tool === 'html_to_screenshot') && isRecord(item)) {
+        const toolInput = isRecord(item.arguments)
+            ? item.arguments
+            : isRecord(item.input)
+                ? item.input
+                : {};
+        const sourcePath = normalizeDocumentSourcePath(toolInput.source_path);
+        return sourcePath ? workspaceResourceKey(sourcePath) : null;
+    }
+    return extractToolResourceKey(item);
+}
 function extractToolResourceKey(item) {
     if (!isRecord(item))
         return null;
+    const result = item.result;
+    const resultRecord = isRecord(result) ? result : null;
     const queue = [
         { value: item.arguments, depth: 0 },
         { value: item.input, depth: 0 },
-        { value: item.result?.structured_content ?? item.result?.structuredContent ?? item.result, depth: 0 }
+        { value: resultRecord?.structured_content ?? resultRecord?.structuredContent ?? result, depth: 0 }
     ];
     let visited = 0;
     while (queue.length > 0 && visited < 256) {
@@ -883,7 +961,7 @@ function extractToolResourceKey(item) {
             if (/^(?:path|file_path|filepath|workbook_path|workbook|source_path|target_path|output_path)$/i.test(key)) {
                 const resourcePath = normalizeWorkspaceResourcePath(value);
                 if (resourcePath)
-                    return `sha256:${sha256(resourcePath)}`;
+                    return workspaceResourceKey(resourcePath);
             }
             queue.push({ value, depth: current.depth + 1 });
         }
@@ -914,7 +992,7 @@ function isSpreadsheetDeliverable(artifact) {
 }
 function artifactMatchesResource(artifact, resourceKey) {
     const artifactPath = normalizeWorkspaceResourcePath(artifact.path);
-    return Boolean(resourceKey && artifactPath && `sha256:${sha256(artifactPath)}` === resourceKey);
+    return Boolean(resourceKey && artifactPath && workspaceResourceKey(artifactPath) === resourceKey);
 }
 function isDocumentRenderDeliverable(artifact, tool) {
     const artifactPath = normalizeWorkspaceResourcePath(artifact.path);
@@ -1067,7 +1145,7 @@ function normalizePreToolObservation(value) {
         || (value.decision === 'allowed' && reservationStatus === 'denied'))
         return null;
     return {
-        tool_use_id_sha256: value.tool_use_id_sha256,
+        tool_use_id_sha256: String(value.tool_use_id_sha256),
         tool: value.tool,
         resource_key: resourceKey,
         datasource_sha256: datasourceSha256,
@@ -1204,10 +1282,25 @@ function hostCapabilityRuntimeMatchesRequest(runtime, request) {
 function structuredHostToolResponse(value) {
     if (!isRecord(value))
         return null;
-    const nested = value.structured_content ?? value.structuredContent;
-    if (nested !== undefined)
-        return parseJsonObject(nested);
-    return value;
+    const structuredContent = parseBoundedHostToolJsonObject(value.structured_content, MAX_HOST_TOOL_STRUCTURED_RESULT_BYTES) ?? parseBoundedHostToolJsonObject(value.structuredContent, MAX_HOST_TOOL_STRUCTURED_RESULT_BYTES);
+    const contentObjects = Array.isArray(value.content)
+        ? value.content
+            .filter((item) => isRecord(item) && item.type === 'text')
+            .map((item) => parseBoundedHostToolJsonObject(item.text, MAX_EVENT_LINE_BYTES))
+            .filter((item) => item !== null)
+        : [];
+    const distinctContentObjects = distinctJsonObjects(contentObjects);
+    if (distinctContentObjects.length > 1)
+        return null;
+    const contentObject = distinctContentObjects[0] ?? null;
+    if (structuredContent) {
+        return contentObject && !sameJsonObject(structuredContent, contentObject)
+            ? null
+            : structuredContent;
+    }
+    if (value.structured_content !== undefined || value.structuredContent !== undefined)
+        return null;
+    return contentObject;
 }
 function normalizeHostToolSemanticReceipt(tool, toolInput, response) {
     if (tool === 'datasource_schema_context') {
@@ -1425,8 +1518,46 @@ function parseJsonObject(value) {
     }
     return null;
 }
-function uniqueStrings(values) {
-    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))].sort();
+function parseBoundedHostToolJsonObject(value, maxBytes) {
+    if (isRecord(value)) {
+        try {
+            return Buffer.byteLength(JSON.stringify(value), 'utf8') <= maxBytes
+                ? value
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    const trimmed = value.trim();
+    if (Buffer.byteLength(trimmed, 'utf8') > maxBytes)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function distinctJsonObjects(values) {
+    const distinct = new Map();
+    for (const value of values)
+        distinct.set(canonicalJson(value), value);
+    return [...distinct.values()];
+}
+function sameJsonObject(left, right) {
+    return canonicalJson(left) === canonicalJson(right);
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
 }
 function arrayStrings(value) {
     return Array.isArray(value)
@@ -1446,6 +1577,3 @@ function uniqueWorkflows(values) {
     ]);
     return uniqueStrings(values).filter((value) => valid.has(value));
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}