dsh-scout 0.9.2 → 0.9.4

package/dist/index.js

@@ -1,9 +1,26 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import z from '@deepseek-ai/schemastery';
-import { addClaim, addSource, appendEvent, CLAIM_DIMENSIONS, CLAIM_IMPACTS, CLAIM_STATUSES, computeCoverage, createCase, decideCase, DEFAULT_AUTHORITY_HOST_SUFFIXES, EVIDENCE_LEVELS, EXPORT_FILE_NAMES, exportCaseFiles, findSourceByUrl, generateInterviewQuestions, importCaseFromFiles, inferEvidenceLevel, inferSourceType, renderComparison, renderReport, SOURCE_TYPES, verifyClaim, verifyIdentity, } from './model.js';
+import { addClaim, addSource, appendEvent, CLAIM_DIMENSIONS, CLAIM_IMPACTS, CLAIM_STATUSES, computeCoverage, createCase, decideCase, DEFAULT_AUTHORITY_HOST_SUFFIXES, EVIDENCE_LEVELS, EXPORT_FILE_NAMES, exportCaseFiles, findSourceByUrl, generateInterviewQuestions, IDENTITY_FIELDS, importCaseFromFiles, inferEvidenceLevel, inferSourceType, isTrustedAuthorityUrl, renderComparison, renderReport, SOURCE_TYPES, verifyClaim, verifyIdentity, } from './model.js';
 import { formatScoutString, isScoutLanguage, normalizeScoutLanguage, scoutStrings, } from './i18n.js';
 export const name = 'dsh-scout';
 export const inject = ['tools'];
+/**
+ * The version this source tree ships, stated as a literal.
+ *
+ * It is deliberately never read back from `package.json`. A release checklist
+ * anchor only works when the version is asserted in two independent places: the
+ * assertion compares this literal against the manifest, so a bump that updates
+ * one and forgets the other fails the suite instead of shipping silently.
+ * `tests/acceptance.test.mjs` pins this constant, `package.json` and the
+ * `/scout status` output to the same string.
+ *
+ * Where this reaches a user: `runScoutCommand` prints it in `/scout status`.
+ * It cannot be printed at load time — a plugin's log output is not visible in
+ * any DSH surface (cordis only buffers it in memory), and a plugin that failed
+ * to load never runs at all, so "is it loaded, and which version?" is answered
+ * by the settings plugin list instead.
+ */
+export const PLUGIN_VERSION = '0.9.4';
 export const Config = z.object({
     scoutDir: z.string().default('dsh-scout'),
     autoPersist: z.boolean().default(false),
@@ -11,7 +28,16 @@ export const Config = z.object({
     language: z.union([z.const('zh-CN'), z.const('en')]).default('zh-CN'),
 });
 const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/**
+ * A confinement refusal is the one export failure whose cause is not the
+ * caller's input. Say what to change instead of echoing the sandbox mode text.
+ */
+const WRITE_DENIED_HINT = ' — the confined filesystem rejected this write: keep scoutDir/targetDir under an absolute writable path'
+    + ' (session workspace or platform temp) and use a plugin build that forwards the per-call sandbox policy';
+const withWriteHint = (message) => /FS_SANDBOX_DENIED|file access denied under/.test(message) ? `${message}${WRITE_DENIED_HINT}` : message;
 const IMPACT_RANK = { blocking: 0, material: 1, informational: 2 };
+const EVIDENCE_RANK = { E0: 0, E1: 1, E2: 2, E3: 3 };
+const IDENTITY_SOURCE_TYPE_SET = new Set(['company_registry', 'regulator', 'official_filing']);
 /** Up to three smallest next actions for open blocking/material claims. */
 const deriveNextActions = (scoutCase) => [...scoutCase.claims]
     .filter(claim => claim.impact !== 'informational' && claim.status !== 'verified')
@@ -20,25 +46,6 @@ const deriveNextActions = (scoutCase) => [...scoutCase.claims]
     .filter((action, index, all) => Boolean(action) && all.indexOf(action) === index)
     .slice(0, 3);
 const capIds = (ids, limit = 20) => ids.length > limit ? [...ids.slice(0, limit), `+${ids.length - limit} more`] : ids;
-const buildEnvelope = (scoutCase, changed, extras = {}) => {
-    const verified = scoutCase.claims.filter(claim => claim.status === 'verified').length;
-    return {
-        ok: true,
-        caseId: scoutCase.caseId,
-        decision: scoutCase.decision,
-        identity: scoutCase.subject.identityStatus,
-        counts: {
-            sources: scoutCase.sources.length,
-            claims: scoutCase.claims.length,
-            verified,
-            open: scoutCase.claims.length - verified,
-        },
-        changed: { kind: changed.kind, ids: capIds(changed.ids) },
-        nextActions: deriveNextActions(scoutCase),
-        ...(extras.persist ? { persist: extras.persist } : {}),
-        ...(extras.errors?.length ? { errors: extras.errors } : {}),
-    };
-};
 /** Model-facing render budget for one mutation summary, in UTF-8 bytes. */
 const MAX_RENDER_BYTES = 1024;
 /** Marks a clipped render. Its own byte cost is paid out of the same budget. */
@@ -72,10 +79,27 @@ const clampUtf8 = (text, limit) => {
 const clipField = (text, limit) => text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
 const formatEnvelope = (value) => {
     const { counts, changed } = value;
+    const sourceIds = changed.ids.filter(id => id.startsWith('src-'));
+    const claimIds = changed.ids.filter(id => id.startsWith('claim-'));
+    const otherIds = changed.ids.filter(id => !id.startsWith('src-') && !id.startsWith('claim-'));
+    let changedLine;
+    if (sourceIds.length && claimIds.length) {
+        const listed = [...sourceIds, ...claimIds].slice(0, 6).join(', ');
+        changedLine = `changed: ${changed.kind} (+${sourceIds.length} sources, +${claimIds.length} claims: ${clipField(listed, 160)})`;
+    }
+    else {
+        changedLine = `changed: ${changed.kind}${changed.ids.length ? ` (${clipField(changed.ids.join(', '), 200)})` : ''}`;
+    }
     const lines = [
         `[${clipField(value.caseId, 80)}] ${value.decision} · identity ${value.identity} · sources ${counts.sources} / claims ${counts.claims} (verified ${counts.verified}, open ${counts.open})`,
-        `changed: ${changed.kind}${changed.ids.length ? ` (${clipField(changed.ids.join(', '), 200)})` : ''}`,
+        changedLine,
     ];
+    if (changed.labels?.length) {
+        lines.push(`new: ${changed.labels.map(label => clipField(label, 80)).join(' · ')}`);
+    }
+    if (otherIds.length && (sourceIds.length || claimIds.length)) {
+        lines.push(`other: ${clipField(otherIds.join(', '), 120)}`);
+    }
     if (value.nextActions.length) {
         lines.push(`next: ${value.nextActions.map(action => clipField(action, 140)).join(' | ')}`);
     }
@@ -110,7 +134,7 @@ const mutationSchema = () => ({
         },
         identity: {
             type: 'string',
-            enum: ['verified', 'needs_verification'],
+            enum: ['verified', 'corroborated', 'needs_verification'],
             required: true,
         },
         counts: {
@@ -134,6 +158,7 @@ const mutationSchema = () => ({
                     enum: [
                         'case_started',
                         'source_added',
+                        'source_updated',
                         'sources_added',
                         'claim_added',
                         'claims_added',
@@ -145,6 +170,7 @@ const mutationSchema = () => ({
                     required: true,
                 },
                 ids: { type: 'array', items: { type: 'string' }, required: true },
+                labels: { type: 'array', items: { type: 'string' } },
             },
         },
         nextActions: { type: 'array', items: { type: 'string' }, required: true },
@@ -233,7 +259,106 @@ export function apply(ctx, config = {}) {
     // Resolved per call so a later-mounted (or replaced) provider is honored.
     const fsService = () => ctx.get('fs');
     const webService = () => ctx.get('web');
+    const sandboxPolicyService = () => ctx.get('sandboxPolicy');
     const execCwd = (exec) => exec?.agent?.session?.header?.cwd;
+    /**
+     * Resolve the caller session's sandbox policy for one filesystem write.
+     *
+     * A confined `fs` backend needs this as writeText's fifth argument; without
+     * it the write is checked against the deployment-default workspace root
+     * instead of the session's workspace, which denies every workspace export in
+     * the desktop app. Deployments without a sandbox policy (plain `fs-local`)
+     * simply pass `undefined` and behave as before.
+     */
+    const writePolicyFor = (exec) => {
+        const service = sandboxPolicyService();
+        if (!service)
+            return undefined;
+        try {
+            const session = exec?.agent?.session;
+            return service.resolve(session ? { session } : {});
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const REQUIRED_DIMENSIONS_FOR_NEXT = ['role_existence', 'reporting_line', 'mandate'];
+    /** Parse the optional identity field→source-id provenance map. */
+    const parseIdentityFieldSources = (raw) => {
+        if (typeof raw !== 'string' || !raw.trim())
+            return undefined;
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            throw new Error(`Invalid fieldSources JSON: ${messageOf(error)}`);
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('fieldSources must be a JSON object mapping identity fields to source ids');
+        }
+        const record = parsed;
+        const result = {};
+        for (const field of IDENTITY_FIELDS) {
+            const value = record[field];
+            if (value === undefined || value === null)
+                continue;
+            const values = Array.isArray(value)
+                ? value.filter((item) => typeof item === 'string')
+                : typeof value === 'string'
+                    ? value.split(',')
+                    : [];
+            const ids = values.map(item => item.trim()).filter(Boolean);
+            if (ids.length)
+                result[field] = ids;
+        }
+        return Object.keys(result).length ? result : undefined;
+    };
+    /**
+     * Next actions for the compact summary: claim-derived actions first, then a
+     * state-derived fallback so a brand-new or source-only case still tells the
+     * caller what to do next instead of printing no `next:` line at all.
+     */
+    const nextActionsFor = (scoutCase) => {
+        const fromClaims = deriveNextActions(scoutCase);
+        if (fromClaims.length)
+            return fromClaims;
+        if (scoutCase.subject.identityStatus === 'needs_verification') {
+            return [scoutCase.sources.length ? strings.nextActions.verifyIdentity : strings.nextActions.collectSources];
+        }
+        const missing = REQUIRED_DIMENSIONS_FOR_NEXT.find(dimension => !scoutCase.claims.some(claim => claim.dimension === dimension && claim.status === 'verified'));
+        if (missing) {
+            return [formatScoutString(strings.nextActions.missingDimension, {
+                    dimension: strings.dimensions[missing],
+                })];
+        }
+        return scoutCase.claims.some(claim => claim.impact !== 'informational' && claim.status !== 'verified')
+            ? []
+            : [strings.nextActions.conclude];
+    };
+    const buildEnvelope = (scoutCase, changed, extras = {}) => {
+        const verified = scoutCase.claims.filter(claim => claim.status === 'verified').length;
+        return {
+            ok: true,
+            caseId: scoutCase.caseId,
+            decision: scoutCase.decision,
+            identity: scoutCase.subject.identityStatus,
+            counts: {
+                sources: scoutCase.sources.length,
+                claims: scoutCase.claims.length,
+                verified,
+                open: scoutCase.claims.length - verified,
+            },
+            changed: {
+                kind: changed.kind,
+                ids: capIds(changed.ids),
+                ...(changed.labels?.length ? { labels: changed.labels.slice(0, 3) } : {}),
+            },
+            nextActions: nextActionsFor(scoutCase),
+            ...(extras.persist ? { persist: extras.persist } : {}),
+            ...(extras.errors?.length ? { errors: extras.errors } : {}),
+        };
+    };
     const recordEvent = (scoutCase, type, detail) => {
         const events = scoutCase.events ?? [];
         let n = events.length + 1;
@@ -257,6 +382,49 @@ export function apply(ctx, config = {}) {
         evidenceLevel: source.evidenceLevel,
         ingested: true,
     });
+    /**
+     * Upgrade an already-registered source when the caller now states stronger
+     * metadata. Re-registering the same URL used to silently drop the explicit
+     * sourceType/evidenceLevel, which made "start with E2 aggregators, later get
+     * the E3 official page" impossible. Only ever moves metadata upward unless an
+     * explicit different type is asserted; an E3 upgrade still has to satisfy the
+     * authority policy, so this cannot be used to bypass it.
+     */
+    const upgradeExistingSource = (scoutCase, existing, input) => {
+        const next = { ...existing };
+        let updated = false;
+        if (input.explicitLevel && EVIDENCE_RANK[input.evidenceLevel] > EVIDENCE_RANK[existing.evidenceLevel]) {
+            next.evidenceLevel = input.evidenceLevel;
+            updated = true;
+        }
+        if (input.explicitType && input.type !== existing.type) {
+            next.type = input.type;
+            updated = true;
+        }
+        if (input.explicitTitle && input.title && input.title !== existing.title) {
+            next.title = input.title;
+            updated = true;
+        }
+        if (!updated)
+            return { scoutCase, source: existing, updated: false };
+        if (next.evidenceLevel === 'E3'
+            && (!IDENTITY_SOURCE_TYPE_SET.has(next.type) || !isTrustedAuthorityUrl(next.url, authoritySuffixes))) {
+            throw new Error('E3 sources require a supported registry, regulator, or official filing HTTPS origin');
+        }
+        const withSource = {
+            ...scoutCase,
+            sources: scoutCase.sources.map(item => (item.sourceId === existing.sourceId ? next : item)),
+        };
+        return {
+            scoutCase: recordEvent(withSource, 'source_updated', {
+                sourceId: existing.sourceId,
+                from: { type: existing.type, evidenceLevel: existing.evidenceLevel, title: existing.title },
+                to: { type: next.type, evidenceLevel: next.evidenceLevel, title: next.title },
+            }),
+            source: next,
+            updated: true,
+        };
+    };
     /* -------------------------------------------------------------- *
      * Durable export
      *
@@ -278,7 +446,7 @@ export function apply(ctx, config = {}) {
      * re-asserted after every payload file landed, so an interrupted export can
      * never leave a stale `complete: true` beside mixed-generation files.
      */
-    const persistFiles = async (scoutCase, targetDir, fs, cwd, signal) => {
+    const persistFiles = async (scoutCase, targetDir, fs, cwd, signal, sandboxPolicy = undefined) => {
         try {
             const files = exportCaseFiles(scoutCase, { language });
             const marker = (complete) => `${JSON.stringify({
@@ -293,7 +461,7 @@ export function apply(ctx, config = {}) {
                 const target = await fs.resolve(`${targetDir}/${fileName}`, { cwd, signal });
                 if (typeof target?.displayPath === 'string')
                     absoluteDir = directoryOf(target.displayPath);
-                await fs.writeText(target, content, undefined, signal);
+                await fs.writeText(target, content, undefined, signal, sandboxPolicy);
             };
             await write(EXPORT_MARKER_FILE, marker(false));
             for (const fileName of EXPORT_FILE_NAMES) {
@@ -303,7 +471,7 @@ export function apply(ctx, config = {}) {
             return { persisted: true, targetDir: absoluteDir ?? targetDir };
         }
         catch (error) {
-            return { persisted: false, targetDir, error: messageOf(error) };
+            return { persisted: false, targetDir, error: withWriteHint(messageOf(error)) };
         }
     };
     /**
@@ -311,9 +479,9 @@ export function apply(ctx, config = {}) {
      * the `case_exported` event that the written `events.jsonl` also has; on
      * failure the event is dropped and the error is surfaced to the caller.
      */
-    const exportCase = async (scoutCase, targetDir, fs, cwd, signal, auto) => {
+    const exportCase = async (scoutCase, targetDir, fs, cwd, signal, auto, sandboxPolicy = undefined) => {
         const withEvent = recordEvent(scoutCase, 'case_exported', { targetDir, auto });
-        const persist = await persistFiles(withEvent, targetDir, fs, cwd, signal);
+        const persist = await persistFiles(withEvent, targetDir, fs, cwd, signal, sandboxPolicy);
         return { scoutCase: persist.persisted ? withEvent : scoutCase, persist };
     };
     const maybePersist = async (scoutCase, exec) => {
@@ -330,7 +498,7 @@ export function apply(ctx, config = {}) {
                 },
             };
         }
-        return exportCase(scoutCase, caseExportDir(scoutCase.caseId), fs, execCwd(exec), exec?.signal, true);
+        return exportCase(scoutCase, caseExportDir(scoutCase.caseId), fs, execCwd(exec), exec?.signal, true, writePolicyFor(exec));
     };
     /* -------------------------------------------------------------- *
      * Case lookup with lazy rehydration
@@ -409,26 +577,53 @@ export function apply(ctx, config = {}) {
             name: 'scout_start',
             description: 'Start a company and job due-diligence case. The initial decision is VERIFY until identity evidence is confirmed. Returns a compact status summary; use scout_report for the full report.',
             parameters: {
-                caseId: { type: 'string', required: true, description: 'Stable case identifier.' },
-                companyName: { type: 'string', required: true, description: 'Company or brand name to investigate.' },
+                caseId: { type: 'string', required: true, description: 'Stable case identifier (1-64 chars: letters, digits, dot, underscore, hyphen).' },
+                companyName: { type: 'string', required: true, description: 'Company or brand name to investigate. Prefer the full legal name when known - it removes same-name ambiguity.' },
                 roleTitle: { type: 'string', required: true, description: 'Role title to evaluate.' },
                 location: { type: 'string', required: true, description: 'Job location, or an empty string if unknown.' },
+                overwrite: { type: 'boolean', description: 'Allow starting a case whose completed export already exists on disk (default false refuses, to protect data).' },
             },
             output: mutationOutput(),
             async execute(args, exec) {
-                const key = caseKey(args.caseId, exec.agent?.id);
+                const caseId = args.caseId.trim();
+                if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(caseId)) {
+                    throw new Error('Invalid caseId: use 1-64 characters from [A-Za-z0-9._-], starting with a letter or digit');
+                }
+                if (!args.companyName.trim())
+                    throw new Error('companyName must not be blank');
+                if (!args.roleTitle.trim())
+                    throw new Error('roleTitle must not be blank');
+                const key = caseKey(caseId, exec.agent?.id);
                 if (cases.has(key))
-                    throw new Error(`Case already exists: ${args.caseId}`);
+                    throw new Error(`Case already exists: ${caseId}`);
+                if (!args.overwrite) {
+                    const fs = fsService();
+                    if (fs) {
+                        const sourceDir = caseExportDir(caseId);
+                        let exists = false;
+                        try {
+                            exists = await readCompletionMarker(sourceDir, fs, execCwd(exec), exec.signal);
+                        }
+                        catch {
+                            exists = false;
+                        }
+                        if (exists) {
+                            throw new Error(`A completed export already exists at ${sourceDir}. Use scout_import to restore it, pick another caseId, `
+                                + 'or pass overwrite:true to replace it');
+                        }
+                    }
+                }
                 let nextCase = recordEvent(createCase({
-                    caseId: args.caseId,
-                    companyName: args.companyName,
-                    roleTitle: args.roleTitle,
-                    location: args.location || undefined,
+                    caseId,
+                    companyName: args.companyName.trim(),
+                    roleTitle: args.roleTitle.trim(),
+                    location: args.location?.trim() || undefined,
                     language,
                 }), 'case_started', {
-                    companyName: args.companyName,
-                    roleTitle: args.roleTitle,
-                    location: args.location || null,
+                    companyName: args.companyName.trim(),
+                    roleTitle: args.roleTitle.trim(),
+                    location: args.location?.trim() || null,
+                    overwrite: args.overwrite === true,
                 });
                 const persisted = await maybePersist(nextCase, exec);
                 nextCase = persisted.scoutCase;
@@ -450,11 +645,13 @@ export function apply(ctx, config = {}) {
                 sourceIds: { type: 'string', required: true, description: 'Comma-separated source identifiers; empty when there is no source.' },
                 confidenceNote: { type: 'string', required: true, description: 'Why the current evidence supports this status and level.' },
                 nextAction: { type: 'string', required: true, description: 'Smallest next action to verify or use the claim.' },
+                interviewQuestion: { type: 'string', description: 'Optional interview question this claim implies. Only these (plus curated questions) feed the interview question list; nextAction never does.' },
             },
             output: mutationOutput(),
             async execute(args, exec) {
                 const key = caseKey(args.caseId, exec.agent?.id);
                 const scoutCase = await requireCase(key, exec);
+                const interviewQuestion = typeof args.interviewQuestion === 'string' ? args.interviewQuestion.trim() : '';
                 let nextCase = recordEvent(decide(addClaim(scoutCase, {
                     claimId: args.claimId,
                     text: args.text,
@@ -465,6 +662,7 @@ export function apply(ctx, config = {}) {
                     sourceIds: args.sourceIds ? args.sourceIds.split(',').map(value => value.trim()).filter(Boolean) : [],
                     confidenceNote: args.confidenceNote,
                     nextAction: args.nextAction,
+                    ...(interviewQuestion ? { interviewQuestion } : {}),
                 })), 'claim_added', {
                     claimId: args.claimId,
                     status: args.status,
@@ -480,7 +678,7 @@ export function apply(ctx, config = {}) {
         }));
         yield ctx.tools.register(defineTool({
             name: 'scout_ingest',
-            description: 'Batch-register collected research results as sources, optionally drafting claims from each item. itemsJson is a JSON array of { url, title?, sourceType?, evidenceLevel?, claim? }; claim is { text, dimension, impact?, status?, evidenceLevel? } with status defaulting to reported, impact to material, and evidence level to the source level. Source type and evidence level are inferred from the URL when omitted (official registry/regulator origins map to E3, job platforms to job_posting/E2, user-provided to E1, unknown to other/E2). A URL already registered for the case is reused instead of duplicated. Individual invalid items or rejected claims are reported in errors without aborting the batch; a failed claim does not undo its already-registered source.',
+            description: 'Batch-register collected research results as sources, optionally drafting claims from each item. itemsJson is a JSON array of { url, title?, sourceType?, evidenceLevel?, claim? }; claim is { text, dimension, impact?, status?, evidenceLevel?, interviewQuestion?, nextAction?, confidenceNote? } with status defaulting to reported, impact to material, evidence level to the source level, and nextAction/confidenceNote defaulting to the ingest placeholder when omitted. Source type and evidence level are inferred from the URL when omitted (official registry/regulator origins map to E3, app stores to company_official, job platforms to job_posting, Chinese registry aggregators to public_database; unknown to other). A URL already registered for the case is reused; when this item states a stronger evidenceLevel (or a different explicit sourceType/title) the existing source is upgraded and a source_updated event is recorded. Re-ingesting the same claim text (same dimension/impact) is a no-op instead of a duplicate. Individual invalid items or rejected claims are reported in errors without aborting the batch.',
             parameters: {
                 caseId: { type: 'string', required: true, description: 'Existing case identifier.' },
                 itemsJson: { type: 'string', required: true, description: 'JSON array of collected source items.' },
@@ -500,6 +698,8 @@ export function apply(ctx, config = {}) {
                     throw new Error(`Invalid itemsJson: ${messageOf(error)}`);
                 }
                 const added = [];
+                const updatedIds = [];
+                const sourceLabels = [];
                 const failures = [];
                 let nextId = (scoutCase.sources.length ?? 0) + 1;
                 let nextClaimId = (scoutCase.claims.length ?? 0) + 1;
@@ -537,7 +737,19 @@ export function apply(ctx, config = {}) {
                         const existing = findSourceByUrl(scoutCase, url);
                         let source;
                         if (existing) {
-                            source = existing;
+                            const title = typeof item.title === 'string' && item.title.trim() ? item.title.trim() : '';
+                            const upgraded = upgradeExistingSource(scoutCase, existing, {
+                                type: typeGuess.type,
+                                evidenceLevel: levelGuess.evidenceLevel,
+                                title,
+                                explicitType: item.sourceType !== undefined && item.sourceType !== null,
+                                explicitLevel: item.evidenceLevel !== undefined && item.evidenceLevel !== null,
+                                explicitTitle: Boolean(title),
+                            });
+                            scoutCase = upgraded.scoutCase;
+                            source = upgraded.source;
+                            if (upgraded.updated)
+                                updatedIds.push(source.sourceId);
                         }
                         else {
                             let sourceId = `src-${nextId}`;
@@ -546,16 +758,18 @@ export function apply(ctx, config = {}) {
                                 sourceId = `src-${nextId}`;
                             }
                             nextId += 1;
+                            const title = typeof item.title === 'string' && item.title.trim() ? item.title.trim() : url;
                             source = {
                                 sourceId,
                                 type: typeGuess.type,
-                                title: typeof item.title === 'string' && item.title.trim() ? item.title.trim() : url,
+                                title,
                                 url,
                                 capturedAt: new Date().toISOString(),
                                 evidenceLevel: levelGuess.evidenceLevel,
                                 status: 'captured',
                             };
                             scoutCase = registerSource(scoutCase, source);
+                            sourceLabels.push(title);
                         }
                         added.push(source.sourceId);
                         const rawClaim = item.claim;
@@ -596,37 +810,56 @@ export function apply(ctx, config = {}) {
                                     failures.push({ url, error: `claim rejected: ${claimIssues.join('; ')}` });
                                 }
                                 else {
-                                    let claimId = `claim-${nextClaimId}`;
-                                    while (scoutCase.claims.some(candidate => candidate.claimId === claimId)) {
-                                        nextClaimId += 1;
-                                        claimId = `claim-${nextClaimId}`;
+                                    const impactValue = impact ?? 'material';
+                                    const interviewQuestion = typeof claimDraft.interviewQuestion === 'string' && claimDraft.interviewQuestion.trim()
+                                        ? claimDraft.interviewQuestion.trim()
+                                        : undefined;
+                                    const draftNextAction = typeof claimDraft.nextAction === 'string' && claimDraft.nextAction.trim()
+                                        ? claimDraft.nextAction.trim()
+                                        : undefined;
+                                    const draftConfidenceNote = typeof claimDraft.confidenceNote === 'string' && claimDraft.confidenceNote.trim()
+                                        ? claimDraft.confidenceNote.trim()
+                                        : undefined;
+                                    const duplicate = scoutCase.claims.find(candidate => candidate.text.trim() === text
+                                        && candidate.dimension === dimension
+                                        && candidate.impact === impactValue);
+                                    if (duplicate) {
+                                        // Re-running the same batch must not double the ledger.
                                     }
-                                    nextClaimId += 1;
-                                    try {
-                                        scoutCase = recordEvent(addClaim(scoutCase, {
-                                            claimId,
-                                            text,
-                                            status: status ?? 'reported',
-                                            evidenceLevel: claimLevel ?? source.evidenceLevel,
-                                            dimension: dimension,
-                                            impact: impact ?? 'material',
-                                            sourceIds: [source.sourceId],
-                                            confidenceNote: formatScoutString(strings.ingest.autoConfidenceNote, { sourceId: source.sourceId }),
-                                            nextAction: strings.ingest.autoNextAction,
-                                        }), 'claim_added', {
-                                            claimId,
-                                            status: status ?? 'reported',
-                                            evidenceLevel: claimLevel ?? source.evidenceLevel,
-                                            dimension: dimension,
-                                            impact: impact ?? 'material',
-                                            text,
-                                            sourceIds: [source.sourceId],
-                                            ingested: true,
-                                        });
-                                        added.push(claimId);
-                                    }
-                                    catch (error) {
-                                        failures.push({ url, error: `claim rejected: ${messageOf(error)}` });
+                                    else {
+                                        let claimId = `claim-${nextClaimId}`;
+                                        while (scoutCase.claims.some(candidate => candidate.claimId === claimId)) {
+                                            nextClaimId += 1;
+                                            claimId = `claim-${nextClaimId}`;
+                                        }
+                                        nextClaimId += 1;
+                                        try {
+                                            scoutCase = recordEvent(addClaim(scoutCase, {
+                                                claimId,
+                                                text,
+                                                status: status ?? 'reported',
+                                                evidenceLevel: claimLevel ?? source.evidenceLevel,
+                                                dimension: dimension,
+                                                impact: impactValue,
+                                                sourceIds: [source.sourceId],
+                                                confidenceNote: draftConfidenceNote ?? formatScoutString(strings.ingest.autoConfidenceNote, { sourceId: source.sourceId }),
+                                                nextAction: draftNextAction ?? strings.ingest.autoNextAction,
+                                                ...(interviewQuestion ? { interviewQuestion } : {}),
+                                            }), 'claim_added', {
+                                                claimId,
+                                                status: status ?? 'reported',
+                                                evidenceLevel: claimLevel ?? source.evidenceLevel,
+                                                dimension: dimension,
+                                                impact: impactValue,
+                                                text,
+                                                sourceIds: [source.sourceId],
+                                                ingested: true,
+                                            });
+                                            added.push(claimId);
+                                        }
+                                        catch (error) {
+                                            failures.push({ url, error: `claim rejected: ${messageOf(error)}` });
+                                        }
                                     }
                                 }
                             }
@@ -640,7 +873,11 @@ export function apply(ctx, config = {}) {
                 const persisted = await maybePersist(scoutCase, exec);
                 scoutCase = persisted.scoutCase;
                 cases.set(key, scoutCase);
-                return buildEnvelope(scoutCase, { kind: 'sources_added', ids: added }, { persist: persisted.persist, errors: failures });
+                return buildEnvelope(scoutCase, {
+                    kind: updatedIds.length && !added.some(id => id.startsWith('claim-')) ? 'source_updated' : 'sources_added',
+                    ids: added,
+                    ...(sourceLabels.length ? { labels: sourceLabels } : {}),
+                }, { persist: persisted.persist, errors: failures });
             },
         }));
         yield ctx.tools.register(defineTool({
@@ -662,11 +899,20 @@ export function apply(ctx, config = {}) {
                 const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? Math.min(parsedLimit, 10) : 5;
                 const result = await web.search({ query: args.query, maxResults: limit }, exec.signal);
                 const added = [];
+                const labels = [];
                 const failures = [];
                 const items = Array.isArray(result.sources) ? result.sources : [];
                 if (!Array.isArray(result.sources)) {
                     failures.push({ url: '', error: 'search provider returned a non-array sources field' });
                 }
+                const hostOf = (value) => {
+                    try {
+                        return new URL(value).hostname;
+                    }
+                    catch {
+                        return '';
+                    }
+                };
                 let nextId = (scoutCase.sources.length ?? 0) + 1;
                 items.forEach((item, index) => {
                     if (!item || typeof item !== 'object') {
@@ -692,16 +938,18 @@ export function apply(ctx, config = {}) {
                             sourceId = `src-${nextId}`;
                         }
                         nextId += 1;
+                        const title = typeof item.title === 'string' && item.title.trim() ? item.title.trim() : url;
                         scoutCase = registerSource(scoutCase, {
                             sourceId,
                             type: typeGuess.type,
-                            title: typeof item.title === 'string' && item.title.trim() ? item.title.trim() : url,
+                            title,
                             url,
                             capturedAt: new Date().toISOString(),
                             evidenceLevel: levelGuess.evidenceLevel,
                             status: 'captured',
                         });
                         added.push(sourceId);
+                        labels.push(`${title} · ${hostOf(url)}`);
                     }
                     catch (error) {
                         failures.push({ url, error: messageOf(error) });
@@ -711,7 +959,7 @@ export function apply(ctx, config = {}) {
                 const persisted = await maybePersist(scoutCase, exec);
                 scoutCase = persisted.scoutCase;
                 cases.set(key, scoutCase);
-                return buildEnvelope(scoutCase, { kind: 'sources_added', ids: added }, { persist: persisted.persist, errors: failures });
+                return buildEnvelope(scoutCase, { kind: 'sources_added', ids: added, ...(labels.length ? { labels } : {}) }, { persist: persisted.persist, errors: failures });
             },
         }));
         yield ctx.tools.register(defineTool({
@@ -841,7 +1089,7 @@ export function apply(ctx, config = {}) {
                 const key = caseKey(args.caseId, exec.agent?.id);
                 const scoutCase = await requireCase(key, exec);
                 const targetDir = args.targetDir || caseExportDir(scoutCase.caseId);
-                const exported = await exportCase(scoutCase, targetDir, fs, execCwd(exec), exec.signal, false);
+                const exported = await exportCase(scoutCase, targetDir, fs, execCwd(exec), exec.signal, false, writePolicyFor(exec));
                 cases.set(key, exported.scoutCase);
                 return {
                     caseId: scoutCase.caseId,
@@ -925,6 +1173,11 @@ export function apply(ctx, config = {}) {
             async execute(args, exec) {
                 const key = caseKey(args.caseId, exec.agent?.id);
                 const scoutCase = await requireCase(key, exec);
+                const duplicate = args.url ? findSourceByUrl(scoutCase, args.url) : undefined;
+                if (duplicate && duplicate.sourceId !== args.sourceId) {
+                    throw new Error(`URL already registered as ${duplicate.sourceId}. Use scout_ingest to upgrade its metadata, `
+                        + 'or attach claims to the existing source id instead of creating a duplicate');
+                }
                 const source = {
                     sourceId: args.sourceId,
                     type: args.sourceType,
@@ -941,12 +1194,16 @@ export function apply(ctx, config = {}) {
                 const persisted = await maybePersist(nextCase, exec);
                 nextCase = persisted.scoutCase;
                 cases.set(key, nextCase);
-                return buildEnvelope(nextCase, { kind: 'source_added', ids: [args.sourceId] }, { persist: persisted.persist });
+                return buildEnvelope(nextCase, {
+                    kind: 'source_added',
+                    ids: [args.sourceId],
+                    labels: [args.title],
+                }, { persist: persisted.persist });
             },
         }));
         yield ctx.tools.register(defineTool({
             name: 'scout_verify_identity',
-            description: 'Confirm the legal company identity using a previously registered E3 source.',
+            description: 'Confirm the legal company identity from registered sources. With E3 registry evidence for the registration number the tier is `verified`; with two independent sources covering every field it is `corroborated` (decision-useful, never presented as official verification). Use fieldSources to record which source supports which field.',
             parameters: {
                 caseId: { type: 'string', required: true, description: 'Existing case identifier.' },
                 legalEntity: { type: 'string', required: true, description: 'Verified legal entity name.' },
@@ -954,22 +1211,28 @@ export function apply(ctx, config = {}) {
                 registeredRegion: { type: 'string', required: true, description: 'Verified registration region.' },
                 legalRepresentative: { type: 'string', required: true, description: 'Verified legal representative.' },
                 brandRelationship: { type: 'string', required: true, description: 'How the investigated brand relates to the legal entity.' },
-                sourceIds: { type: 'string', required: true, description: 'Comma-separated identity sources including a linked authoritative E3 source.' },
+                sourceIds: { type: 'string', required: true, description: 'Comma-separated identity sources (E3 authoritative source for `verified`, two independent sources for `corroborated`).' },
+                fieldSources: { type: 'string', description: 'Optional JSON per-field provenance, e.g. {"legalEntity":"src-1,src-3","registrationNumber":"src-1","registeredRegion":"src-3","legalRepresentative":"src-1","brandRelationship":"src-2"}. When present every field must be covered.' },
             },
             output: mutationOutput(),
             async execute(args, exec) {
                 const key = caseKey(args.caseId, exec.agent?.id);
                 const scoutCase = await requireCase(key, exec);
-                let nextCase = recordEvent(decide(verifyIdentity(scoutCase, {
+                const fieldSources = parseIdentityFieldSources(args.fieldSources);
+                const verifiedCase = verifyIdentity(scoutCase, {
                     legalEntity: args.legalEntity,
                     registrationNumber: args.registrationNumber,
                     registeredRegion: args.registeredRegion,
                     legalRepresentative: args.legalRepresentative,
                     brandRelationship: args.brandRelationship,
                     sourceIds: args.sourceIds.split(',').map(value => value.trim()).filter(Boolean),
-                }, authoritySuffixes)), 'identity_verified', {
+                    ...(fieldSources ? { fieldSources } : {}),
+                }, authoritySuffixes);
+                let nextCase = recordEvent(decide(verifiedCase), 'identity_verified', {
                     legalEntity: args.legalEntity,
                     registrationNumber: args.registrationNumber,
+                    identityStatus: verifiedCase.subject.identityStatus,
+                    ...(fieldSources ? { fieldSources } : {}),
                 });
                 const persisted = await maybePersist(nextCase, exec);
                 nextCase = persisted.scoutCase;
@@ -1016,7 +1279,7 @@ export function apply(ctx, config = {}) {
      * -------------------------------------------------------------- */
     const runScoutCommand = async (invocation) => {
         const raw = typeof invocation?.rawInput === 'string' ? invocation.rawInput.trim() : '';
-        const [action = 'help', caseId = ''] = raw.split(/\s+/).filter(Boolean);
+        const [action = 'help', caseId = '', commandTargetDir = ''] = raw.split(/\s+/).filter(Boolean);
         if (action === 'help' || !caseId) {
             return {
                 kind: 'success',
@@ -1024,9 +1287,14 @@ export function apply(ctx, config = {}) {
             };
         }
         const key = caseKey(caseId, invocation?.agent?.id);
-        const scoutCase = cases.get(key);
-        if (!scoutCase) {
-            return { kind: 'error', text: `Unknown case: ${caseId}. Use scout_start or scout_import first.` };
+        let scoutCase;
+        try {
+            // Same state machine as the tools: a cold process rehydrates from disk
+            // instead of answering "Unknown case" for a case that plainly exists.
+            scoutCase = await requireCase(key, invocation);
+        }
+        catch (error) {
+            return { kind: 'error', text: messageOf(error) };
         }
         if (action === 'status') {
             const verified = scoutCase.claims.filter(claim => claim.status === 'verified').length;
@@ -1034,7 +1302,11 @@ export function apply(ctx, config = {}) {
                 kind: 'success',
                 text: `[${scoutCase.caseId}] ${scoutCase.decision} · identity ${scoutCase.subject.identityStatus}`
                     + ` · sources ${scoutCase.sources.length} / claims ${scoutCase.claims.length}`
-                    + ` (verified ${verified}, open ${scoutCase.claims.length - verified})`,
+                    + ` (verified ${verified}, open ${scoutCase.claims.length - verified})`
+                    // Trailing, so the case facts stay the leading, greppable part of the
+                    // line. This is the one surface that can state the version: reaching
+                    // this branch already proves the plugin loaded.
+                    + ` · dsh-scout ${PLUGIN_VERSION}`,
             };
         }
         if (action === 'questions') {
@@ -1047,8 +1319,8 @@ export function apply(ctx, config = {}) {
             const fs = fsService();
             if (!fs)
                 return { kind: 'error', text: 'Filesystem service is unavailable in this host' };
-            const targetDir = caseExportDir(scoutCase.caseId);
-            const exported = await exportCase(scoutCase, targetDir, fs, invocation?.agent?.session?.header?.cwd, invocation?.signal, false);
+            const targetDir = commandTargetDir || caseExportDir(scoutCase.caseId);
+            const exported = await exportCase(scoutCase, targetDir, fs, invocation?.agent?.session?.header?.cwd, invocation?.signal, false, writePolicyFor(invocation));
             cases.set(key, exported.scoutCase);
             return exported.persist.persisted
                 ? { kind: 'success', text: `exported to ${exported.persist.targetDir}` }