dsh-scout 0.9.2 → 0.9.4

package/tests/tools.test.mjs

@@ -5,6 +5,7 @@ import { apply, Config, inject, name } from '../dist/index.js'
 import {
   createCase,
   exportCaseFiles,
+  importCaseFromFiles,
   inferEvidenceLevel,
   inferSourceType,
   isTrustedAuthorityUrl,
@@ -141,9 +142,10 @@ test('isolates identical case ids by DSH agent session identity', async () => {
 
   const reportA = (await report.execute({ caseId: 'same-id' }, execFor('session-a'))).report
   const reportB = (await report.execute({ caseId: 'same-id' }, execFor('session-b'))).report
-  assert.match(reportA, /Company A — Role A/)
+  assert.match(reportA, /^# Company A$/m)
+  assert.match(reportA, /^> 岗位：Role A/m)
   assert.doesNotMatch(reportA, /Company B/)
-  assert.match(reportB, /Company B — Role B/)
+  assert.match(reportB, /^# Company B$/m)
 })
 
 /* ------------------------------------------------------------------ *
@@ -210,8 +212,8 @@ test('scout_report stays the only tool that returns the full artifact', async ()
   assertSchemaConforms(mounted, 'scout_report', value)
   assert.equal(value.caseId, 'full')
   assert.equal(value.decision, 'VERIFY')
-  assert.match(value.report, /# Example Co — HR Head/)
-  assert.match(value.report, /## Verification checklist/)
+  assert.match(value.report, /^# Example Co$/m)
+  assert.match(value.report, /## 6\. 距离下一步还差什么/)
 })
 
 /* ------------------------------------------------------------------ *
@@ -327,7 +329,7 @@ test('auto-persist failure is surfaced instead of silently swallowed', async ()
 
   // A failed auto-persist must not claim that an export happened.
   const report = await mounted.tools.get('scout_report').execute({ caseId: 'failing' }, execFor())
-  assert.match(report.report, /# Example Co — HR Head/)
+  assert.match(report.report, /^# Example Co$/m)
   const exported = await mounted.tools.get('scout_export').execute({
     caseId: 'failing', targetDir: '/tmp/nope',
   }, execFor())
@@ -344,7 +346,7 @@ test('auto-persist without a filesystem service degrades gracefully', async () =
   assert.equal(started.persist.persisted, false)
   assert.match(started.persist.error, /Filesystem service is unavailable/)
   const report = await mounted.tools.get('scout_report').execute({ caseId: 'no-fs' }, execFor())
-  assert.match(report.report, /# Example Co — HR Head/)
+  assert.match(report.report, /^# Example Co$/m)
 })
 
 /* ------------------------------------------------------------------ *
@@ -383,7 +385,7 @@ test('a cache miss rehydrates the case from the export directory and records it'
 
   const mounted = mountPlugin({ config: { scoutDir: '/tmp/scout-cases' }, services: { fs: mockFs(store) } })
   const report = await mounted.tools.get('scout_report').execute({ caseId: 'restored' }, execFor())
-  assert.match(report.report, /# Restored Co — HR Head/)
+  assert.match(report.report, /^# Restored Co$/m)
 
   const exported = await mounted.tools.get('scout_export').execute({
     caseId: 'restored', targetDir: '/tmp/out',
@@ -449,9 +451,9 @@ test('scout_ingest batch-registers sources with inference and isolates errors',
 
   const report = (await mounted.tools.get('scout_report').execute({ caseId: 'ingest' }, execFor())).report
   assert.match(report, /gsxt\.gov\.cn/)
-  assert.match(report, /company_registry \/ E3/)
-  assert.match(report, /job_posting \/ E2/)
-  assert.match(report, /other \/ E2/)
+  assert.match(report, /工商登记 \| 官方\/权威来源/)
+  assert.match(report, /招聘平台 \| 独立来源/)
+  assert.match(report, /其他 \| 独立来源/)
 })
 
 test('scout_ingest reuses an already-registered URL instead of duplicating the source', async () => {
@@ -702,7 +704,7 @@ test('scout_report returns per-dimension coverage alongside the rendered report'
   assert.ok(value.coverage.every(entry => entry.untouched === true))
   const identity = value.coverage.find(entry => entry.dimension === 'identity')
   assert.deepEqual(identity, { dimension: 'identity', verified: 0, open: 0, untouched: true })
-  assert.match(value.report, /## Coverage/)
+  assert.match(value.report, /## 附录 C · 调查覆盖度/)
 })
 
 test('the configured language drives the report, the questions and the structured value', async () => {
@@ -712,8 +714,8 @@ test('the configured language drives the report, the questions and the structure
   }, execFor())
 
   const report = (await mounted.tools.get('scout_report').execute({ caseId: 'english' }, execFor())).report
-  assert.match(report, /- Decision: \*\*VERIFY\*\*/)
-  assert.match(report, /- Reason: /)
+  assert.match(report, /^> Role: [^|]+ \| Location: [^|]+ \| Decision: verify \(VERIFY\)$/m)
+  assert.match(report, /## 30-second verdict/)
   assert.doesNotMatch(report, /判断|理由/)
 
   const questions = await mounted.tools.get('scout_questions').execute({ caseId: 'english' }, execFor())
@@ -726,7 +728,7 @@ test('the configured language drives the report, the questions and the structure
     caseId: 'chinese', companyName: 'Example Co', roleTitle: 'HR Head', location: '',
   }, execFor())
   const zhReport = (await chinese.tools.get('scout_report').execute({ caseId: 'chinese' }, execFor())).report
-  assert.match(zhReport, /- 判断：\*\*VERIFY\*\*/)
+  assert.match(zhReport, /^> 岗位：/m)
 
   const defaults = new Config({})
   assert.equal(defaults.language, 'zh-CN')
@@ -886,7 +888,7 @@ test('a language change re-localizes untouched case-authored copy but keeps user
   assert.equal(imported.complete, true)
   const report = (await mounted.tools.get('scout_report').execute({ caseId: 'relabel' }, execFor())).report
   assert.doesNotMatch(report, cjk, 'an en deployment must not render mixed-language case prose')
-  assert.match(report, /- Objective: Decide whether this role is worth pursuing/)
+  assert.match(report, /^> Role: /m)
   const questions = await mounted.tools.get('scout_questions').execute({ caseId: 'relabel' }, execFor())
   assert.ok(questions.questions.every(question => !cjk.test(question)), 'interview questions must follow the deployment language')
 
@@ -900,7 +902,7 @@ test('a language change re-localizes untouched case-authored copy but keeps user
   // A value the user wrote is not a factory default and must survive untouched.
   await mounted.tools.get('scout_import').execute({ caseId: 'edited', sourceDir: '/tmp/edited' }, execFor())
   const edited = (await mounted.tools.get('scout_report').execute({ caseId: 'edited' }, execFor())).report
-  assert.match(edited, /Prüfen, ob diese Rolle passt\./)
+  assert.match(edited, /> (目标：|Objective: )Prüfen, ob diese Rolle passt\./)
 })
 
 /* ------------------------------------------------------------------ *
@@ -972,3 +974,367 @@ test('an absent optional service only skips that registration', async () => {
   // still loads (the real binding leaves that child fiber pending).
   assert.equal(skills.length, 1)
 })
+
+// ---------------------------------------------------------------------------
+// 0.9.4 regression coverage: host sandbox seam, source upgrades, ingest dedupe,
+// identity tiers, start guard, and input validation.
+// ---------------------------------------------------------------------------
+
+const startArgs = (caseId, overrides = {}) => ({
+  caseId, companyName: 'Example Co', roleTitle: 'HR Head', location: '', ...overrides,
+})
+const sessionExec = (cwd = '/workspace/desk') => ({
+  agent: { id: 'session-a', session: { header: { cwd } } },
+})
+
+test('export forwards the session sandbox policy to a confined filesystem backend', async () => {
+  const workspace = '/workspace/desk'
+  const writes = []
+  const confinedFs = {
+    async resolve(path) {
+      return { targetKey: path, displayPath: path }
+    },
+    async readText() {
+      throw new Error('not found')
+    },
+    async writeText(target, content, intent, signal, sandboxPolicy) {
+      // Mirrors @deepseek-ai/dsh-fs-sandbox: a missing fifth argument means
+      // "deployment-default root", which denies the session workspace.
+      if (!sandboxPolicy) {
+        throw new Error(`cannot write "${target.displayPath}": file access denied under workspace-write mode`)
+      }
+      if (!target.displayPath.startsWith(sandboxPolicy.workspaceRoot)) {
+        throw new Error(`cannot write "${target.displayPath}": file access denied under workspace-write mode`)
+      }
+      writes.push({ path: target.displayPath, policy: sandboxPolicy })
+    },
+  }
+  const sandboxPolicy = {
+    resolve(request) {
+      return {
+        mode: 'workspace-write',
+        workspaceRoot: request?.session?.header?.cwd ?? '/deployment-default',
+        ...(request?.session ? { sessionId: 'session-a' } : {}),
+      }
+    },
+  }
+  const mounted = mountPlugin({ services: { fs: confinedFs, sandboxPolicy } })
+  const exec = sessionExec(workspace)
+  await mounted.tools.get('scout_start').execute(startArgs('sandbox'), exec)
+  const exported = await mounted.tools.get('scout_export').execute({
+    caseId: 'sandbox',
+    targetDir: `${workspace}/cases/sandbox`,
+  }, exec)
+  assert.equal(exported.persisted, true)
+  assert.equal(writes.length, 7, 'marker false + five payload files + marker true')
+  assert.ok(writes.every(item => item.policy.workspaceRoot === workspace), 'the session workspace root is forwarded')
+})
+
+test('a confinement refusal carries an actionable hint instead of the raw mode text only', async () => {
+  const mounted = mountPlugin({
+    services: {
+      fs: {
+        async resolve(path) {
+          return { targetKey: path, displayPath: path }
+        },
+        async readText() {
+          throw new Error('not found')
+        },
+        async writeText() {
+          throw new Error('cannot write "/x": file access denied under workspace-write mode')
+        },
+      },
+    },
+  })
+  const exec = sessionExec('/workspace/desk')
+  await mounted.tools.get('scout_start').execute(startArgs('denied'), exec)
+  const exported = await mounted.tools.get('scout_export').execute({
+    caseId: 'denied',
+    targetDir: '/workspace/desk/cases/denied',
+  }, exec)
+  assert.equal(exported.persisted, false)
+  assert.match(exported.error, /sandbox policy/)
+  assert.match(exported.error, /writable path/)
+})
+
+test('re-ingesting a URL upgrades its metadata instead of silently dropping it', async () => {
+  const mounted = mountPlugin({ services: { fs: mockFs() } })
+  const exec = execFor()
+  await mounted.tools.get('scout_start').execute(startArgs('upgrade'), exec)
+  // First pass: the same official URL was classified as a generic page.
+  await mounted.tools.get('scout_ingest').execute({
+    caseId: 'upgrade',
+    itemsJson: JSON.stringify([{
+      url: 'https://www.gsxt.gov.cn/registry/upgrade-1',
+      title: 'Registry record',
+      sourceType: 'other',
+      evidenceLevel: 'E2',
+    }]),
+  }, exec)
+  // Second pass states the authoritative category + level for the same URL.
+  const upgraded = await mounted.tools.get('scout_ingest').execute({
+    caseId: 'upgrade',
+    itemsJson: JSON.stringify([{
+      url: 'https://www.gsxt.gov.cn/registry/upgrade-1',
+      title: 'Registry record',
+      sourceType: 'company_registry',
+      evidenceLevel: 'E3',
+    }]),
+  }, exec)
+  assert.equal(upgraded.counts.sources, 1, 'the URL is reused, not duplicated')
+  const events = mounted.ctx.fs ? [] : []
+  const report = await mounted.tools.get('scout_report').execute({ caseId: 'upgrade' }, exec)
+  assert.match(report.report, /工商登记 \| 官方\/权威来源/)
+})
+
+test('an E3 upgrade still has to satisfy the authority policy', async () => {
+  const mounted = mountPlugin({ services: { fs: mockFs() } })
+  const exec = execFor()
+  await mounted.tools.get('scout_start').execute(startArgs('upgrade-denied'), exec)
+  await mounted.tools.get('scout_ingest').execute({
+    caseId: 'upgrade-denied',
+    itemsJson: JSON.stringify([{ url: 'https://example.com/page', sourceType: 'other', evidenceLevel: 'E2' }]),
+  }, exec)
+  const refused = await mounted.tools.get('scout_ingest').execute({
+    caseId: 'upgrade-denied',
+    itemsJson: JSON.stringify([{
+      url: 'https://example.com/page', sourceType: 'company_registry', evidenceLevel: 'E3',
+    }]),
+  }, exec)
+  assert.match(refused.errors[0].error, /E3 sources require a supported registry/)
+})
+
+test('re-running the same ingest batch does not duplicate claims', async () => {
+  const mounted = mountPlugin({ services: { fs: mockFs() } })
+  const exec = execFor()
+  await mounted.tools.get('scout_start').execute(startArgs('dedupe'), exec)
+  const batch = JSON.stringify([{
+    url: 'https://www.qixin.com/brand/dedupe',
+    title: 'Aggregator page',
+    claim: { text: 'The company was founded in 2021.', dimension: 'company_and_founder' },
+  }])
+  const first = await mounted.tools.get('scout_ingest').execute({ caseId: 'dedupe', itemsJson: batch }, exec)
+  const second = await mounted.tools.get('scout_ingest').execute({ caseId: 'dedupe', itemsJson: batch }, exec)
+  assert.equal(first.counts.claims, 1)
+  assert.equal(second.counts.claims, 1, 'the ledger does not double on a retried batch')
+})
+
+test('a new case still tells the model what to do next', async () => {
+  const mounted = mountPlugin({ services: { fs: mockFs() } })
+  const started = await mounted.tools.get('scout_start').execute(startArgs('next-actions'), execFor())
+  assert.ok(started.nextActions.length >= 1)
+  assert.match(started.nextActions.join(' '), /scout_search|scout_ingest/)
+  const rendered = renderedText(renderOutput(mounted, 'scout_start', started))
+  assert.match(rendered, /^next: /m)
+})
+
+test('start refuses to overwrite a completed export unless overwrite is explicit', async () => {
+  const store = new Map()
+  const first = mountPlugin({ services: { fs: mockFs(store) } })
+  const exec = execFor()
+  await first.tools.get('scout_start').execute(startArgs('guarded'), exec)
+  await first.tools.get('scout_export').execute({ caseId: 'guarded' }, exec)
+
+  const second = mountPlugin({ services: { fs: mockFs(store) } })
+  await assert.rejects(
+    () => second.tools.get('scout_start').execute(startArgs('guarded'), exec),
+    /completed export already exists/,
+  )
+  const replaced = await second.tools.get('scout_start').execute(startArgs('guarded', { overwrite: true }), exec)
+  assert.equal(replaced.ok, true)
+})
+
+test('start validates the case id and required labels', async () => {
+  const mounted = mountPlugin({ services: { fs: mockFs() } })
+  const exec = execFor()
+  await assert.rejects(
+    () => mounted.tools.get('scout_start').execute(startArgs('../escape/x'), exec),
+    /Invalid caseId/,
+  )
+  await assert.rejects(
+    () => mounted.tools.get('scout_start').execute(startArgs('blank-company', { companyName: '   ' }), exec),
+    /companyName must not be blank/,
+  )
+  await assert.rejects(
+    () => mounted.tools.get('scout_start').execute(startArgs('blank-role', { roleTitle: '' }), exec),
+    /roleTitle must not be blank/,
+  )
+})
+
+test('identity verification reaches a labelled tier and records per-field provenance', async () => {
+  const mounted = mountPlugin({ services: { fs: mockFs() } })
+  const exec = execFor()
+  await mounted.tools.get('scout_start').execute(startArgs('tier'), exec)
+  await mounted.tools.get('scout_ingest').execute({
+    caseId: 'tier',
+    itemsJson: JSON.stringify([
+      { url: 'https://www.qixin.com/brand/tier-1', title: 'Registry aggregator A', sourceType: 'public_database', evidenceLevel: 'E2' },
+      { url: 'https://apps.apple.com/cn/app/tier/id1', title: 'App Store listing', sourceType: 'company_official', evidenceLevel: 'E2' },
+      { url: 'https://www.szns.gov.cn/news/tier-1', title: 'Government event report', sourceType: 'regulator', evidenceLevel: 'E3' },
+    ]),
+  }, exec)
+
+  // A government page that only mentions the company cannot verify the
+  // registration number: with field provenance the tier is corroborated.
+  const corroborated = await mounted.tools.get('scout_verify_identity').execute({
+    caseId: 'tier',
+    legalEntity: 'Example Co Ltd',
+    registrationNumber: '91440300TEST000001',
+    registeredRegion: 'Shenzhen',
+    legalRepresentative: 'Example Person',
+    brandRelationship: 'Operating entity',
+    sourceIds: 'src-1,src-2,src-3',
+    fieldSources: JSON.stringify({
+      legalEntity: 'src-1,src-3',
+      registrationNumber: 'src-1',
+      registeredRegion: 'src-1',
+      legalRepresentative: 'src-1',
+      brandRelationship: 'src-2',
+    }),
+  }, exec)
+  assert.equal(corroborated.identity, 'corroborated')
+  const report = await mounted.tools.get('scout_report').execute({ caseId: 'tier' }, exec)
+  assert.match(report.report, /## 1\. 公司与主体/)
+  assert.match(report.report, /已交叉核验/)
+  assert.match(report.report, /统一社会信用代码=src-1/)
+  assert.match(report.report, /已交叉核验：多个独立来源/)
+
+  // A second independent E2 source can support the registration number, but
+  // only an E3 registration source upgrades the tier to verified.
+  await mounted.tools.get('scout_ingest').execute({
+    caseId: 'tier',
+    itemsJson: JSON.stringify([{
+      url: 'https://www.gsxt.gov.cn/registry/tier-2', title: 'Official registry record',
+      sourceType: 'company_registry', evidenceLevel: 'E3',
+    }]),
+  }, exec)
+  const verified = await mounted.tools.get('scout_verify_identity').execute({
+    caseId: 'tier',
+    legalEntity: 'Example Co Ltd',
+    registrationNumber: '91440300TEST000001',
+    registeredRegion: 'Shenzhen',
+    legalRepresentative: 'Example Person',
+    brandRelationship: 'Operating entity',
+    sourceIds: 'src-1,src-2,src-3,src-4',
+    fieldSources: JSON.stringify({
+      legalEntity: 'src-1,src-3',
+      registrationNumber: 'src-4',
+      registeredRegion: 'src-4',
+      legalRepresentative: 'src-1',
+      brandRelationship: 'src-2',
+    }),
+  }, exec)
+  assert.equal(verified.identity, 'verified')
+})
+
+test('import rejects invalid evidence enums instead of casting them through', () => {
+  const files = exportCaseFiles(createCase({ caseId: 'import-enum', companyName: 'Example Co', roleTitle: 'HR Head' }))
+  const sources = JSON.parse(files['sources.json'])
+  sources.push({ sourceId: 'bad', type: 'other', title: 'bad', url: null, capturedAt: null, evidenceLevel: 'E9', status: 'captured' })
+  assert.throws(
+    () => importCaseFromFiles({ ...files, 'sources.json': JSON.stringify(sources) }),
+    /Invalid evidence level/,
+  )
+})
+
+test('scout_search summarises new results by title and reuses them silently on repeat', async () => {
+  const web = {
+    async search() {
+      return {
+        sources: [
+          { url: 'https://www.qixin.com/brand/render-1', title: '启信宝页面' },
+          { url: 'https://apps.apple.com/cn/app/render/id1', title: 'App Store 页面' },
+        ],
+        truncated: false,
+      }
+    },
+  }
+  const mounted = mountPlugin({ services: { fs: mockFs(), web } })
+  const exec = execFor()
+  await mounted.tools.get('scout_start').execute(startArgs('search-render'), exec)
+  const first = await mounted.tools.get('scout_search').execute({
+    caseId: 'search-render', query: 'render', limit: 5,
+  }, exec)
+  const firstText = renderedText(renderOutput(mounted, 'scout_search', first))
+  assert.match(firstText, /new: 启信宝页面 · (www\.)?qixin\.com/)
+  assert.match(firstText, /App Store 页面 · apps\.apple\.com/)
+  assert.equal(first.counts.sources, 2)
+
+  const second = await mounted.tools.get('scout_search').execute({
+    caseId: 'search-render', query: 'render', limit: 5,
+  }, exec)
+  assert.equal(second.counts.sources, 2, 'the same URLs are reused')
+  assert.doesNotMatch(renderedText(renderOutput(mounted, 'scout_search', second)), /^new: /m)
+})
+
+test('the /scout export command honours targetDir and cold-start commands rehydrate', async () => {
+  const store = new Map()
+  const registrations = []
+  const mountWithCommands = () => mountPlugin({
+    config: { scoutDir: '/tmp/cmd-scout' },
+    services: {
+      fs: mockFs(store),
+      commands: {
+        register(definition) {
+          registrations.push(definition)
+          return () => undefined
+        },
+      },
+    },
+  })
+  const agent = { id: 'session-a', session: { header: { cwd: '/workspace' } } }
+  const exec = { agent }
+
+  const first = mountWithCommands()
+  await first.tools.get('scout_start').execute(startArgs('cmd-export'), exec)
+  const handlerOf = () => registrations[registrations.length - 1].handler
+  const exported = await handlerOf()({ rawInput: 'export cmd-export /tmp/cmd-out', agent })
+  assert.equal(exported.kind, 'success')
+  assert.match(exported.text, /exported to \/tmp\/cmd-out/)
+  assert.ok(store.has('/tmp/cmd-out/export.complete.json'), 'targetDir token is honoured')
+
+  // A second case exported with the default scoutDir must come back from disk
+  // on a cold start; the command path used to answer "Unknown case".
+  await first.tools.get('scout_start').execute(startArgs('cmd-cold'), exec)
+  const defaultExport = await handlerOf()({ rawInput: 'export cmd-cold', agent })
+  assert.equal(defaultExport.kind, 'success')
+  assert.match(defaultExport.text, /exported to \/tmp\/cmd-scout\/cmd-cold/)
+
+  registrations.length = 0
+  mountWithCommands()
+  const status = await handlerOf()({ rawInput: 'status cmd-cold', agent })
+  assert.equal(status.kind, 'success')
+  assert.match(status.text, /identity needs_verification/)
+  assert.match(status.text, /· dsh-scout /)
+})
+
+test('scout_add_source rejects a URL already registered under another id', async () => {
+  const mounted = mountPlugin({ services: { fs: mockFs() } })
+  const exec = execFor()
+  await mounted.tools.get('scout_start').execute(startArgs('dupe-url'), exec)
+  const addSource = mounted.tools.get('scout_add_source')
+  await addSource.execute({
+    caseId: 'dupe-url', sourceId: 'a', sourceType: 'other', title: 'A',
+    url: 'https://example.com/x', evidenceLevel: 'E2',
+  }, exec)
+  await assert.rejects(
+    () => addSource.execute({
+      caseId: 'dupe-url', sourceId: 'b', sourceType: 'public_database', title: 'B',
+      url: 'https://example.com/x?utm_source=somewhere', evidenceLevel: 'E2',
+    }, exec),
+    /URL already registered as a/,
+  )
+})
+
+test('import rejects invalid claim enums', () => {
+  const files = exportCaseFiles(createCase({ caseId: 'import-claim-enum', companyName: 'Example Co', roleTitle: 'HR Head' }))
+  const claims = JSON.parse(files['claims.json'])
+  claims.push({
+    claimId: 'bad', text: 'Bad claim', status: 'not-a-status', evidenceLevel: 'E2',
+    dimension: 'risk', impact: 'material', sourceIds: [], confidenceNote: 'x', nextAction: 'y',
+  })
+  assert.throws(
+    () => importCaseFromFiles({ ...files, 'claims.json': JSON.stringify(claims) }),
+    /Invalid claim status/,
+  )
+})