dsh-scout 0.9.2 → 0.9.4

package/dist/model.js

@@ -47,6 +47,7 @@ export function isDecisionReasonCode(value) {
 export const EVENT_TYPES = [
     'case_started',
     'source_added',
+    'source_updated',
     'claim_added',
     'identity_verified',
     'claim_verified',
@@ -68,6 +69,45 @@ const JOB_PLATFORM_HOST_HINTS = [
     'nowcoder.com',
     'jobs.feishu.cn',
 ];
+/** Product/app-store listings are first-party company statements, not media. */
+const APP_STORE_HOST_HINTS = [
+    'apps.apple.com',
+    'play.google.com',
+    'appgallery.huawei.com',
+];
+/** Public business-registry aggregators: independent data, never E3. */
+const PUBLIC_DATABASE_HOST_HINTS = [
+    'qixin.com',
+    'qcc.com',
+    'tianyancha.com',
+    'qichamao.com',
+    'likuso.com',
+    'mingluji.com',
+    '11467.com',
+    '58.com',
+    'shuidi.cn',
+    'innohere.com',
+    'patentguru.com',
+    'aiqicha.baidu.com',
+];
+/** Query parameters that identify a campaign, not the document; dropped when deduping URLs. */
+const TRACKING_QUERY_PARAMETERS = [
+    'hmsr',
+    'hmpl',
+    'hmcu',
+    'hmkw',
+    'hmci',
+    'spm',
+    'from',
+    'source',
+    'ref',
+    'share_token',
+    'scene',
+    'clicktime',
+    'enterid',
+    'suid',
+    'share_source',
+];
 /** Default trusted authority host suffixes used by the E3 evidence policy. */
 export const DEFAULT_AUTHORITY_HOST_SUFFIXES = [
     'gov',
@@ -93,6 +133,28 @@ const REGISTRY_HOST_SUFFIXES = [
     'szse.cn',
     'neeq.com.cn',
 ];
+/** The five identity fields a caller asserts when verifying the subject. */
+export const IDENTITY_FIELDS = [
+    'legalEntity',
+    'registrationNumber',
+    'registeredRegion',
+    'legalRepresentative',
+    'brandRelationship',
+];
+/**
+ * Identity confidence tiers.
+ *
+ * - `verified`: an E3 registry/regulator/official-filing source backs the
+ *   registration number itself (the strongest claim a due-diligence tool can make).
+ * - `corroborated`: no E3 registration evidence, but at least two independent
+ *   sources cover every identity field consistently (typically 工商 aggregators).
+ *   This is a *decision-useful* tier, never presented as official verification.
+ * - `needs_verification`: anything weaker.
+ */
+export const IDENTITY_STATUSES = ['verified', 'corroborated', 'needs_verification'];
+export function isIdentityStatus(value) {
+    return typeof value === 'string' && IDENTITY_STATUSES.includes(value);
+}
 /**
  * Resolve the render language: an explicit option wins, then the case language,
  * then the `zh-CN` default. Unknown values always fall back to `zh-CN`.
@@ -160,15 +222,23 @@ export function inferSourceType(url, explicit, authoritySuffixes = DEFAULT_AUTHO
     if (url) {
         try {
             const hostname = new URL(url).hostname.toLowerCase().replace(/\.$/, '');
+            const matches = (hint) => hostname === hint || hostname.endsWith(`.${hint}`);
             // Trusted authority origins (official registry/regulator) take priority.
             if (isTrustedAuthorityUrl(url, authoritySuffixes)) {
                 const isRegistry = REGISTRY_HOST_SUFFIXES.some(suffix => hostname === suffix || hostname.endsWith(`.${suffix}`));
                 return { type: isRegistry ? 'company_registry' : 'regulator', inferred: true };
             }
+            // First-party product listings.
+            if (APP_STORE_HOST_HINTS.some(matches)) {
+                return { type: 'company_official', inferred: true };
+            }
             // Exact host or subdomain match for known job platforms (no substring false positives).
-            if (JOB_PLATFORM_HOST_HINTS.some(hint => hostname === hint || hostname.endsWith(`.${hint}`))) {
+            if (JOB_PLATFORM_HOST_HINTS.some(matches)) {
                 return { type: 'job_posting', inferred: true };
             }
+            if (PUBLIC_DATABASE_HOST_HINTS.some(matches)) {
+                return { type: 'public_database', inferred: true };
+            }
         }
         catch {
             // fall through to 'other'
@@ -190,7 +260,9 @@ export function inferEvidenceLevel(url, type, explicit, authoritySuffixes = DEFA
 }
 /**
  * Normalize a source URL for deduplication: trim, lowercase the host, drop a
- * trailing slash and any fragment. Empty or unparsable URLs return `undefined`.
+ * trailing slash, the fragment, and known campaign/tracking query parameters.
+ * Query parameters that can select the document itself (e.g. `?id=42`) are kept.
+ * Empty or unparsable URLs return `undefined`.
  */
 export function normalizeSourceUrl(value) {
     if (typeof value !== 'string')
@@ -210,7 +282,17 @@ export function normalizeSourceUrl(value) {
         return undefined;
     const path = parsed.pathname.replace(/\/+$/, '');
     const port = parsed.port ? `:${parsed.port}` : '';
-    return `${parsed.protocol.toLowerCase()}//${hostname}${port}${path}${parsed.search}`;
+    const search = new URLSearchParams();
+    const sorted = [...parsed.searchParams.entries()]
+        .filter(([key]) => {
+        const normalized = key.toLowerCase();
+        return !normalized.startsWith('utm_') && !TRACKING_QUERY_PARAMETERS.includes(normalized);
+    })
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    for (const [key, entry] of sorted)
+        search.append(key, entry);
+    const query = search.toString();
+    return `${parsed.protocol.toLowerCase()}//${hostname}${port}${path}${query ? `?${query}` : ''}`;
 }
 /** Find a source by normalized URL (trim + trailing-slash + host case insensitive). */
 export function findSourceByUrl(scoutCase, url) {
@@ -275,6 +357,32 @@ export function verifyClaim(scoutCase, input) {
     claims[claimIndex] = verified;
     return { ...scoutCase, claims };
 }
+/** Source host, used to decide whether two sources are independent (not mirrors). */
+function sourceHost(source) {
+    if (!source.url)
+        return '';
+    try {
+        return new URL(source.url).hostname.toLowerCase();
+    }
+    catch {
+        return '';
+    }
+}
+/** An E3 registry/regulator/official-filing source over HTTPS. */
+function isAuthoritativeIdentitySource(source, authoritySuffixes) {
+    return source.evidenceLevel === 'E3'
+        && IDENTITY_SOURCE_TYPES.has(source.type)
+        && isTrustedAuthorityUrl(source.url, authoritySuffixes);
+}
+/**
+ * Verify the legal subject.
+ *
+ * Reaching `verified` requires an E3 registry/regulator/official-filing source
+ * that backs the registration number — a page that merely mentions the company
+ * does not count. Without that, two independent sources covering every identity
+ * field yield `corroborated`: decision-useful and honestly labelled, never
+ * presented as official verification.
+ */
 export function verifyIdentity(scoutCase, input, authoritySuffixes = DEFAULT_AUTHORITY_HOST_SUFFIXES) {
     const requiredValues = [
         input.legalEntity,
@@ -295,11 +403,54 @@ export function verifyIdentity(scoutCase, input, authoritySuffixes = DEFAULT_AUT
             throw new Error(`Unknown source: ${sourceId}`);
         return source;
     });
-    const hasAuthoritativeSource = sources.some(source => source.evidenceLevel === 'E3'
-        && IDENTITY_SOURCE_TYPES.has(source.type)
-        && isTrustedAuthorityUrl(source.url, authoritySuffixes));
-    if (!hasAuthoritativeSource) {
-        throw new Error('Company identity verification requires a linked E3 registry, regulator, or official filing source');
+    const sourceById = new Map(sources.map(source => [source.sourceId, source]));
+    const authoritative = sources.filter(source => isAuthoritativeIdentitySource(source, authoritySuffixes));
+    let identityStatus;
+    let identityEvidence;
+    if (input.fieldSources && Object.keys(input.fieldSources).length > 0) {
+        const evidence = {};
+        for (const field of IDENTITY_FIELDS) {
+            const ids = (input.fieldSources[field] ?? []).map(value => value.trim()).filter(Boolean);
+            for (const id of ids) {
+                if (!sourceById.has(id)) {
+                    throw new Error(`Unknown source for identity field ${field}: ${id} (all field sources must also appear in sourceIds)`);
+                }
+            }
+            if (ids.length)
+                evidence[field] = [...new Set(ids)];
+        }
+        const missing = IDENTITY_FIELDS.filter(field => !evidence[field]?.length);
+        if (missing.length) {
+            throw new Error(`Identity evidence is missing for: ${missing.join(', ')}`);
+        }
+        const registrationSources = evidence.registrationNumber.map(id => sourceById.get(id));
+        const registrationAuthoritative = registrationSources.some(source => isAuthoritativeIdentitySource(source, authoritySuffixes));
+        const used = [...new Set(IDENTITY_FIELDS.flatMap(field => evidence[field]))];
+        const distinctHosts = new Set(used.map(id => sourceHost(sourceById.get(id))).filter(Boolean));
+        if (registrationAuthoritative) {
+            identityStatus = 'verified';
+        }
+        else if (used.length >= 2 && distinctHosts.size >= 2) {
+            identityStatus = 'corroborated';
+        }
+        else {
+            throw new Error('Company identity verification requires an E3 registry/regulator/official-filing source for the '
+                + 'registration number, or at least two independent sources covering every identity field');
+        }
+        identityEvidence = evidence;
+    }
+    else if (authoritative.length > 0) {
+        identityStatus = 'verified';
+    }
+    else {
+        const distinctHosts = new Set(sources.map(sourceHost).filter(Boolean));
+        if (sources.length >= 2 && distinctHosts.size >= 2) {
+            identityStatus = 'corroborated';
+        }
+        else {
+            throw new Error('Company identity verification requires a linked E3 registry, regulator, or official filing source '
+                + '(or at least two independent sources for a corroborated identity)');
+        }
     }
     return {
         ...scoutCase,
@@ -311,12 +462,20 @@ export function verifyIdentity(scoutCase, input, authoritySuffixes = DEFAULT_AUT
             legalRepresentative: input.legalRepresentative,
             brandRelationship: input.brandRelationship,
             identitySourceIds: [...input.sourceIds],
-            identityStatus: 'verified',
+            identityStatus,
+            ...(identityEvidence ? { identityEvidence } : {}),
         },
     };
 }
 const REQUIRED_DIMENSIONS = ['role_existence', 'reporting_line', 'mandate'];
-/** Recompute the whole decision basis from the subject and claims (pure). */
+/**
+ * Recompute the whole decision basis from the subject and claims (pure).
+ *
+ * Identity is blocking at every tier below `verified`: a corroborated identity
+ * is decision-useful but is never silently upgraded to official verification.
+ * PROCEED additionally requires every non-informational claim to be verified
+ * and the three required role dimensions to be verified.
+ */
 function assessDecision(scoutCase) {
     const blockingContradiction = scoutCase.claims.some(claim => claim.impact === 'blocking' && claim.status === 'contradicted');
     const identityUnverified = scoutCase.subject.identityStatus !== 'verified';
@@ -350,7 +509,11 @@ export function decideCase(scoutCase, opts) {
     const decisionReason = reasonCode === 'proceed'
         ? t.decisionReasons.proceed
         : reasonCode === 'identity'
-            ? t.decisionReasons.identity
+            ? (scoutCase.subject.identityStatus === 'corroborated'
+                ? (scoutCase.claims.some(claim => claim.impact !== 'informational' && claim.status !== 'verified')
+                    ? t.decisionReasons.identityCorroborated
+                    : t.decisionReasons.identityCorroboratedClear)
+                : t.decisionReasons.identity)
             : reasonCode === 'unresolved'
                 ? (blockingContradiction ? t.decisionReasons.blockingContradiction : t.decisionReasons.unresolved)
                 : formatScoutString(t.decisionReasons.missingDimension, { dimension: missingRequiredDimension ?? '' });
@@ -389,138 +552,454 @@ function dedupeQuestions(questions) {
 }
 /**
  * Derive a deduplicated, prioritized interview question list from the case.
- * Order: pending next actions, missing required dimensions, untouched
- * dimensions, then the case's own curated questions. The curated questions
- * reserve their full quota, so an uninvestigated case cannot crowd them out of
- * the 12-item cap.
+ *
+ * Only two sources feed the list now:
+ * - explicit `claim.interviewQuestion` values (what the model actually decided
+ *   is worth asking), ordered by claim impact;
+ * - one dimension-default question for missing required dimensions, dimensions
+ *   with open claims, and untouched dimensions.
+ *
+ * `claim.nextAction` is deliberately excluded — it is a research instruction
+ * ("verify this claim"), not something a candidate can ask in an interview.
+ * The case's curated questions reserve their full quota and are always kept.
  */
 export function generateInterviewQuestions(scoutCase, opts) {
     const t = scoutStrings(reportLanguage(opts?.language, scoutCase.language));
-    const nextActions = byImpact(scoutCase.claims.filter(claim => claim.impact !== 'informational' && claim.status !== 'verified'))
-        .map(claim => claim.nextAction.trim())
-        .filter((action, index, all) => action && all.indexOf(action) === index);
+    const askable = byImpact(scoutCase.claims.filter(claim => claim.impact !== 'informational' && claim.status !== 'verified' && claim.interviewQuestion?.trim()))
+        .map(claim => claim.interviewQuestion.trim());
     const missingDimensions = REQUIRED_DIMENSIONS.filter(dimension => !scoutCase.claims.some(claim => claim.dimension === dimension && claim.status === 'verified'));
-    const untouchedDimensions = computeCoverage(scoutCase)
-        .filter(item => item.untouched)
-        .map(item => item.dimension);
+    const coverage = computeCoverage(scoutCase);
+    const untouchedDimensions = coverage.filter(item => item.untouched).map(item => item.dimension);
+    const openDimensions = coverage
+        .filter(item => !item.untouched && item.open > 0)
+        .map(item => item.dimension)
+        .filter(dimension => !missingDimensions.includes(dimension));
     const head = dedupeQuestions([
-        ...nextActions,
+        ...askable,
         ...missingDimensions.map(dimension => t.questions[dimension]),
+        ...openDimensions.map(dimension => t.questions[dimension]),
         ...untouchedDimensions.map(dimension => t.questions[dimension]),
     ]);
     const curated = scoutCase.interviewQuestions;
     const headBudget = Math.max(0, INTERVIEW_QUESTION_LIMIT - curated.length);
     return dedupeQuestions([...head.slice(0, headBudget), ...curated]).slice(0, INTERVIEW_QUESTION_LIMIT);
 }
+/** Trim a long string for list/table use. */
+const clipText = (text, limit) => text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+/**
+ * Short human source label derived from the source title.
+ * The report body never shows internal source ids; ids stay in the appendices.
+ */
+function shortSourceLabel(source) {
+    const cleaned = source.title.replace(/（[^）]*）|\([^)]*\)/g, ' ').trim();
+    const colon = cleaned.split(/[：:]/);
+    if (colon.length > 1 && colon[0].trim())
+        return clipText(colon[0].trim(), 16);
+    const dash = cleaned.split(' - ');
+    const candidate = dash.length > 1 ? dash[dash.length - 1].trim() : cleaned;
+    return clipText(candidate || source.title, 16);
+}
+/**
+ * Stage-based evidence report (0.9.4 readability rework).
+ *
+ * The body speaks the reader's language: no E-codes, no source ids, no internal
+ * status enums, and no item rendered five times. Sections follow the decision
+ * stages (verdict -> subject -> confirmed -> open -> risks -> questions -> gap),
+ * with a technical audit trail in the appendices.
+ */
 export function renderReport(scoutCase, opts) {
     const t = scoutStrings(reportLanguage(opts?.language, scoutCase.language));
-    const sourceLine = (source) => {
-        const url = source.url ? ` — ${source.url}` : '';
-        return `- ${source.sourceId}: ${source.title} [${source.type} / ${source.evidenceLevel}]${url}`;
-    };
-    const sources = scoutCase.sources.length
-        ? scoutCase.sources.map(sourceLine).join('\n')
-        : t.empty.noSources;
-    const claimLine = (claim) => {
-        const sourceIds = claim.sourceIds.length ? claim.sourceIds.join(', ') : t.claim.noSourceIds;
-        const history = claim.history?.length
-            ? formatScoutString(t.claim.history, { count: claim.history.length })
-            : '';
-        return formatScoutString(t.claim.line, {
-            status: claim.status,
-            evidenceLevel: claim.evidenceLevel,
-            impact: claim.impact,
-            text: claim.text,
-            dimension: claim.dimension,
-            sourceIds,
-            confidenceNote: claim.confidenceNote,
-            nextAction: claim.nextAction,
-            history,
+    const r = t.report;
+    const zh = t.language === 'zh-CN';
+    const metaSep = zh ? ' ｜ ' : ' | ';
+    const labelValue = (label, value) => `${label}${zh ? '：' : ': '}${value}`;
+    const table = (headers, rows) => [
+        `| ${headers.join(' | ')} |`,
+        `|${headers.map(() => '---').join('|')}|`,
+        ...rows.map(cells => `| ${cells.map(cell => cell.replace(/\|/g, '/')).join(' | ')} |`),
+    ];
+    const sourceById = new Map(scoutCase.sources.map(source => [source.sourceId, source]));
+    const sourcesLabel = (ids) => {
+        if (!ids.length)
+            return t.claim.noSourceIds;
+        const labels = ids.map(id => {
+            const source = sourceById.get(id);
+            return source ? shortSourceLabel(source) : id;
         });
+        return labels.join(t.coverage.separator);
     };
-    const claims = scoutCase.claims.length
-        ? scoutCase.claims.map(claimLine).join('\n')
-        : t.empty.noClaims;
-    const supports = byImpact(scoutCase.claims.filter(claim => claim.status === 'verified')).slice(0, 3);
-    const risks = byImpact(scoutCase.claims.filter(claim => claim.impact !== 'informational' && claim.status !== 'verified')).slice(0, 3);
-    const roleHypotheses = byImpact(scoutCase.claims.filter(claim => ['role_existence', 'reporting_line', 'mandate'].includes(claim.dimension))).slice(0, 3);
-    const checklist = byImpact(scoutCase.claims.filter(claim => claim.impact !== 'informational' && claim.status !== 'verified'));
-    const checklistLine = (claim) => formatScoutString(t.claim.checklistLine, {
-        impact: claim.impact,
-        claimId: claim.claimId,
-        text: claim.text,
-        nextAction: claim.nextAction,
-    });
-    const checklistBlock = checklist.length
-        ? checklist.map(checklistLine).join('\n')
-        : t.empty.noChecklistItems;
-    const statusCounts = scoutCase.claims.reduce((counts, claim) => {
-        counts[claim.status] = (counts[claim.status] ?? 0) + 1;
-        return counts;
-    }, {});
-    const summary = Object.entries(statusCounts)
-        .map(([status, count]) => `${count} ${status}`)
-        .join(' / ');
-    const coverage = computeCoverage(scoutCase);
-    const coverageLines = coverage.map(item => formatScoutString(t.coverage.entry, {
-        dimension: item.dimension,
-        label: t.dimensions[item.dimension],
-        verified: item.verified,
-        open: item.open,
-        untouched: item.untouched ? t.coverage.yes : t.coverage.no,
-    }));
-    const untouchedDimensions = coverage.filter(item => item.untouched).map(item => item.dimension);
-    const untouchedLine = formatScoutString(t.coverage.untouchedLine, {
-        count: untouchedDimensions.length,
-        dimensions: untouchedDimensions.length
-            ? untouchedDimensions.join(t.coverage.separator)
-            : t.coverage.none,
-    });
-    return [
-        `# ${scoutCase.title}`,
-        '',
-        formatScoutString(t.header.decision, { decision: scoutCase.decision }),
-        formatScoutString(t.header.reason, { reason: scoutCase.decisionReason }),
-        formatScoutString(t.header.objective, { objective: scoutCase.decisionObjective }),
-        ...(summary ? [formatScoutString(t.header.evidenceSummary, { summary })] : []),
-        '',
-        t.headings.coverage,
-        '',
-        ...coverageLines,
-        '',
-        untouchedLine,
-        '',
-        t.headings.supportingEvidence,
-        '',
-        supports.length ? supports.map(claimLine).join('\n') : t.empty.noSupportingEvidence,
-        '',
-        t.headings.unresolvedRisks,
-        '',
-        risks.length ? risks.map(claimLine).join('\n') : t.empty.noUnresolvedRisks,
-        '',
-        t.headings.roleHypotheses,
-        '',
-        roleHypotheses.length ? roleHypotheses.map(claimLine).join('\n') : t.empty.noRoleHypotheses,
-        '',
-        t.headings.verificationChecklist,
-        '',
-        checklistBlock,
-        '',
-        t.headings.claimLedger,
-        '',
-        claims,
-        '',
-        t.headings.sources,
-        '',
-        sources,
-        '',
-        t.headings.interviewQuestions,
-        '',
-        scoutCase.interviewQuestions.map(question => `- ${question}`).join('\n'),
-        '',
-        t.reportDisclaimer,
-        '',
-    ].join('\n');
+    const latestCaptured = (ids) => {
+        const dates = ids
+            .map(id => sourceById.get(id)?.capturedAt)
+            .filter((value) => typeof value === 'string' && value.length >= 10)
+            .map(value => value.slice(0, 10))
+            .sort();
+        return dates.length ? dates[dates.length - 1] : '';
+    };
+    const capturedText = (ids) => {
+        const date = latestCaptured(ids);
+        return date ? formatScoutString(r.captured, { date }) : '';
+    };
+    const statusText = (claim) => t.statuses[claim.status];
+    const levelText = (level) => r.levelLabels[level];
+    const impactText = (impact) => t.impacts[impact];
+    const dimensionText = (dimension) => t.dimensions[dimension];
+    const claims = scoutCase.claims;
+    const verified = claims.filter(claim => claim.status === 'verified');
+    const openClaims = claims.filter(claim => claim.status !== 'verified');
+    const materialOpen = openClaims.filter(claim => claim.impact !== 'informational');
+    const requiredDimensions = ['role_existence', 'reporting_line', 'mandate'];
+    const requiredOpen = openClaims.filter(claim => requiredDimensions.includes(claim.dimension));
+    const fundingOpen = openClaims.find(claim => claim.dimension === 'financing_and_commercialization');
+    const riskOpen = openClaims.find(claim => claim.dimension === 'risk');
+    const subject = scoutCase.subject;
+    const entityName = subject.name;
+    const openCount = materialOpen.length;
+    const decisionSentence = scoutCase.decision === 'STOP'
+        ? r.decisionSentences.stop
+        : scoutCase.decision === 'PROCEED'
+            ? r.decisionSentences.proceed
+            : scoutCase.decisionReasonCode === 'identity'
+                ? (subject.identityStatus === 'corroborated'
+                    ? formatScoutString(r.decisionSentences.corroborated, { open: openCount })
+                    : r.decisionSentences.identity)
+                : (openCount
+                    ? formatScoutString(r.decisionSentences.unresolved, { open: openCount })
+                    : (subject.identityStatus !== 'verified' ? r.decisionSentences.identity : r.decisionSentences.proceed));
+    // 30-second verdict facts.
+    const businessClaim = verified.find(claim => claim.dimension === 'product_and_technology')
+        ?? claims.find(claim => claim.dimension === 'product_and_technology');
+    const fundingClaims = claims.filter(claim => claim.dimension === 'financing_and_commercialization');
+    const entityFact = subject.possibleLegalEntity
+        ? formatScoutString(r.quick.entity, {
+            entity: subject.possibleLegalEntity,
+            registrationNumber: subject.registrationNumber ?? '—',
+            region: subject.registeredRegion ?? '—',
+            representative: subject.legalRepresentative ?? '—',
+        })
+        : formatScoutString(r.quick.entityUnverified, { entity: entityName });
+    const businessFact = businessClaim
+        ? formatScoutString(r.quick.business, { text: clipText(businessClaim.text.replace(/。$/, ''), 80) })
+        : r.quick.businessUnknown;
+    const capitalFact = fundingClaims.length
+        ? formatScoutString(r.quick.capital, {
+            text: clipText(fundingClaims[0].text.replace(/。$/, ''), 80),
+            suffix: fundingClaims.length > 1
+                ? formatScoutString(r.quick.capitalSuffix, { count: fundingClaims.length - 1 })
+                : '',
+        })
+        : r.quick.capitalUnknown;
+    // Top confirmations: identity -> role -> funding -> reputation.
+    const confirmations = [];
+    if (subject.identityStatus !== 'verified')
+        confirmations.push(r.quick.confirmIdentity);
+    if (requiredOpen.length)
+        confirmations.push(r.quick.confirmRole);
+    if (fundingOpen?.interviewQuestion)
+        confirmations.push(clipText(fundingOpen.interviewQuestion, 44));
+    if (riskOpen)
+        confirmations.push(r.quick.confirmRisk);
+    const topConfirmations = confirmations.slice(0, 3);
+    const lines = [];
+    lines.push(`# ${entityName}`);
+    lines.push('');
+    const metaParts = [
+        labelValue(r.meta.role, scoutCase.role.title),
+        labelValue(r.meta.location, scoutCase.role.location ?? r.meta.unknownLocation),
+        labelValue(r.meta.decision, `${t.decisions[scoutCase.decision]}${zh ? '（' : ' ('}${scoutCase.decision}${zh ? '）' : ')'}`),
+    ];
+    const evidenceDate = scoutCase.sources.map(source => source.capturedAt).filter(Boolean).map(value => String(value).slice(0, 10)).sort().at(-1) ?? '';
+    if (evidenceDate)
+        metaParts.splice(2, 0, labelValue(r.meta.evidenceAsOf, evidenceDate));
+    lines.push(`> ${metaParts.join(metaSep)}`);
+    lines.push(`> ${labelValue(r.meta.objective, scoutCase.decisionObjective)}`);
+    lines.push(r.readingGuide);
+    lines.push(r.confidenceLegend);
+    lines.push('');
+    // S0 verdict.
+    lines.push(r.quick.heading);
+    lines.push('');
+    lines.push(`**${t.decisions[scoutCase.decision]}**：${decisionSentence}`.replace('：', zh ? '：' : ': '));
+    lines.push('');
+    lines.push(`- ${entityFact}`);
+    lines.push(`- ${businessFact}`);
+    lines.push(`- ${capitalFact}`);
+    lines.push('');
+    if (topConfirmations.length) {
+        lines.push(r.quick.confirmHeading);
+        lines.push('');
+        topConfirmations.forEach((item, index) => lines.push(`${index + 1}. ${item}`));
+        lines.push('');
+    }
+    // S1 identity.
+    lines.push(r.sections.identity);
+    lines.push('');
+    const tierText = subject.identityStatus === 'verified'
+        ? r.tier.verified
+        : subject.identityStatus === 'corroborated'
+            ? r.tier.corroborated
+            : r.tier.unverified;
+    const identityRows = [
+        [t.identity.fieldLabels.legalEntity, subject.possibleLegalEntity ?? t.identity.unknown],
+        [t.identity.fieldLabels.registrationNumber, subject.registrationNumber ?? t.identity.unknown],
+        [t.identity.fieldLabels.registeredRegion, subject.registeredRegion ?? t.identity.unknown],
+        [t.identity.fieldLabels.legalRepresentative, subject.legalRepresentative ?? t.identity.unknown],
+        [t.identity.fieldLabels.brandRelationship, subject.brandRelationship ?? t.identity.unknown],
+        [r.labels.tier, tierText],
+    ];
+    lines.push(...table([r.tableHeaders.item, r.tableHeaders.value], identityRows));
+    lines.push('');
+    lines.push(`**${r.labels.means}**：${subject.identityStatus === 'verified' ? r.tier.meansVerified : r.tier.meansOther}`
+        .replace('：', zh ? '：' : ': '));
+    lines.push('');
+    // S2 confirmed facts by theme.
+    const themeDefs = [
+        { title: r.themes.business, dimensions: ['product_and_technology', 'market_and_competition'] },
+        { title: r.themes.capital, dimensions: ['financing_and_commercialization'] },
+        { title: r.themes.organization, dimensions: ['organization_and_hr', 'company_and_founder'] },
+    ];
+    lines.push(r.sections.confirmed);
+    lines.push('');
+    let confirmedPrinted = 0;
+    for (const theme of themeDefs) {
+        const group = verified.filter(claim => theme.dimensions.includes(claim.dimension));
+        if (!group.length)
+            continue;
+        confirmedPrinted += group.length;
+        lines.push(`### ${theme.title}`);
+        lines.push('');
+        for (const claim of group) {
+            lines.push(formatScoutString(r.confirmedItem, {
+                text: claim.text,
+                status: statusText(claim),
+                level: levelText(claim.evidenceLevel),
+                sources: sourcesLabel(claim.sourceIds),
+                captured: capturedText(claim.sourceIds),
+            }));
+        }
+        lines.push('');
+    }
+    if (!confirmedPrinted) {
+        lines.push(r.empty.noVerified);
+        lines.push('');
+    }
+    // S3 leads and open items.
+    lines.push(r.sections.open);
+    lines.push('');
+    const interviewItems = openClaims.filter(claim => claim.interviewQuestion?.trim() && claim.dimension !== 'risk');
+    const externalItems = openClaims.filter(claim => !claim.interviewQuestion?.trim() && claim.dimension !== 'risk' && claim.dimension !== 'identity');
+    const conflictItems = claims.filter(claim => claim.status === 'contradicted');
+    let openPrinted = 0;
+    if (interviewItems.length) {
+        openPrinted += interviewItems.length;
+        lines.push(r.openSubheads.interview);
+        lines.push('');
+        for (const claim of interviewItems) {
+            lines.push(`- ${clipText(claim.text, 120)}`);
+            lines.push(`  - ${formatScoutString(r.openInterviewLine, {
+                status: statusText(claim),
+                level: levelText(claim.evidenceLevel),
+                ask: r.labels.ask,
+                question: claim.interviewQuestion.trim(),
+            })}`);
+        }
+        lines.push('');
+    }
+    if (externalItems.length) {
+        openPrinted += externalItems.length;
+        lines.push(r.openSubheads.external);
+        lines.push('');
+        for (const claim of externalItems) {
+            lines.push(`- ${clipText(claim.text, 120)}`);
+            lines.push(`  - ${formatScoutString(r.openExternalLine, {
+                status: statusText(claim),
+                level: levelText(claim.evidenceLevel),
+                next: r.labels.nextStep,
+                action: claim.nextAction,
+            })}`);
+        }
+        lines.push('');
+    }
+    if (conflictItems.length) {
+        openPrinted += conflictItems.length;
+        lines.push(r.openSubheads.conflict);
+        lines.push('');
+        for (const claim of conflictItems)
+            lines.push(`- ${clipText(claim.text, 140)}`);
+        lines.push('');
+    }
+    if (!openPrinted) {
+        lines.push(r.empty.noOpen);
+        lines.push('');
+    }
+    // S4 risks grouped by severity.
+    lines.push(r.sections.risk);
+    lines.push('');
+    const riskClaims = claims.filter(claim => claim.dimension === 'risk');
+    let riskPrinted = 0;
+    for (const impact of ['blocking', 'material', 'informational']) {
+        const group = riskClaims.filter(claim => claim.impact === impact);
+        if (!group.length)
+            continue;
+        riskPrinted += group.length;
+        lines.push(`**${impactText(impact)}**`);
+        lines.push('');
+        for (const claim of group) {
+            lines.push(formatScoutString(r.riskLine, {
+                text: claim.text,
+                status: statusText(claim),
+                level: levelText(claim.evidenceLevel),
+                advice: r.labels.advice,
+                action: claim.nextAction,
+            }));
+        }
+        lines.push('');
+    }
+    if (!riskPrinted) {
+        lines.push(r.empty.noRisks);
+        lines.push('');
+    }
+    // S5 interview questions grouped by theme.
+    lines.push(r.sections.interview);
+    lines.push('');
+    const questions = generateInterviewQuestions(scoutCase, { language: t.language });
+    const questionGroups = [
+        { title: r.questionThemes.role, keywords: r.questionKeywords.role },
+        { title: r.questionThemes.capital, keywords: r.questionKeywords.capital },
+        { title: r.questionThemes.product, keywords: r.questionKeywords.product },
+        { title: r.questionThemes.process, keywords: r.questionKeywords.process },
+    ].map(group => ({ ...group, regex: new RegExp(group.keywords.join('|'), 'i'), matched: [] }));
+    const generalQuestions = [];
+    for (const question of questions) {
+        const group = questionGroups.find(item => item.regex.test(question));
+        if (group)
+            group.matched.push(question);
+        else
+            generalQuestions.push(question);
+    }
+    let questionPrinted = 0;
+    for (const group of questionGroups) {
+        if (!group.matched.length)
+            continue;
+        questionPrinted += group.matched.length;
+        lines.push(`### ${group.title}`);
+        lines.push('');
+        for (const question of group.matched)
+            lines.push(`- ${question}`);
+        lines.push('');
+    }
+    if (generalQuestions.length) {
+        questionPrinted += generalQuestions.length;
+        lines.push(`### ${r.questionThemes.general}`);
+        lines.push('');
+        for (const question of generalQuestions)
+            lines.push(`- ${question}`);
+        lines.push('');
+    }
+    if (!questionPrinted) {
+        lines.push(r.empty.noQuestions);
+        lines.push('');
+    }
+    // S6 what stands between here and the next step.
+    lines.push(r.sections.gap);
+    lines.push('');
+    lines.push(formatScoutString(r.gapLine.why, { decision: t.decisions[scoutCase.decision], sentence: decisionSentence }));
+    const toProceed = [];
+    if (subject.identityStatus !== 'verified')
+        toProceed.push(r.gapLine.identityItem);
+    for (const claim of requiredOpen) {
+        toProceed.push(`${dimensionText(claim.dimension)}${zh ? '：' : ': '}${clipText(claim.interviewQuestion ?? claim.text, 56)}`);
+    }
+    for (const claim of materialOpen.filter(item => !requiredOpen.includes(item) && item.dimension !== 'risk')) {
+        toProceed.push(`${dimensionText(claim.dimension)}${zh ? '：' : ': '}${clipText(claim.nextAction, 56)}`);
+    }
+    if (toProceed.length) {
+        lines.push(r.gapLine.toProceed);
+        for (const item of toProceed)
+            lines.push(`  - ${item}`);
+    }
+    if (topConfirmations.length) {
+        lines.push(r.gapLine.minActions);
+        topConfirmations.forEach((item, index) => lines.push(`  ${index + 1}. ${item}`));
+    }
+    lines.push('');
+    // Appendices: the technical audit trail.
+    lines.push(r.sections.appendixSources);
+    lines.push('');
+    if (scoutCase.sources.length) {
+        lines.push(...table([r.tableHeaders.id, r.tableHeaders.source, r.tableHeaders.type, r.tableHeaders.level, r.tableHeaders.capturedAt], scoutCase.sources.map(source => [
+            source.sourceId,
+            clipText(source.title, 42),
+            r.sourceTypes[source.type],
+            r.levelLabels[source.evidenceLevel],
+            source.capturedAt?.slice(0, 10) ?? '—',
+        ])));
+        for (const source of scoutCase.sources) {
+            if (source.url)
+                lines.push(`- ${source.sourceId}: ${source.url}`);
+        }
+        if (scoutCase.subject.identityEvidence) {
+            const provenance = IDENTITY_FIELDS
+                .map(field => {
+                const ids = scoutCase.subject.identityEvidence?.[field];
+                return ids?.length ? `${t.identity.fieldLabels[field]}=${ids.join(', ')}` : '';
+            })
+                .filter(Boolean)
+                .join(zh ? '；' : '; ');
+            if (provenance)
+                lines.push(`- ${labelValue(r.labels.identityEvidence, provenance)}`);
+        }
+    }
+    else {
+        lines.push(t.empty.noSources);
+    }
+    lines.push('');
+    lines.push(r.sections.appendixLedger);
+    lines.push('');
+    if (claims.length) {
+        lines.push(...table([r.tableHeaders.summary, r.tableHeaders.stage, r.tableHeaders.impact, r.tableHeaders.source, r.tableHeaders.next], claims.map(claim => [
+            clipText(claim.text, 42),
+            `${statusText(claim)} · ${levelText(claim.evidenceLevel)}`,
+            impactText(claim.impact),
+            claim.sourceIds.join(', ') || '—',
+            clipText(claim.nextAction, 26),
+        ])));
+    }
+    else {
+        lines.push(t.empty.noClaims);
+    }
+    lines.push('');
+    lines.push(r.sections.appendixCoverage);
+    lines.push('');
+    for (const dimension of CLAIM_DIMENSIONS) {
+        const group = claims.filter(claim => claim.dimension === dimension);
+        const verifiedCount = group.filter(claim => claim.status === 'verified').length;
+        const openCountForDimension = group.length - verifiedCount;
+        const state = !group.length
+            ? r.coverage.untouched
+            : verifiedCount
+                ? (openCountForDimension
+                    ? formatScoutString(r.coverage.withOpen, { verified: verifiedCount, open: openCountForDimension })
+                    : formatScoutString(r.coverage.verified, { verified: verifiedCount }))
+                : formatScoutString(r.coverage.openOnly, { open: openCountForDimension });
+        lines.push(`- ${dimensionText(dimension)}${zh ? '：' : ': '}${state}`);
+    }
+    lines.push('');
+    lines.push(r.sections.appendixGlossary);
+    lines.push('');
+    const glossaryRows = ['E3', 'E2', 'E1', 'E0'].map(level => [
+        level,
+        r.levelLabels[level],
+        r.levelMeanings[level],
+    ]);
+    for (const status of ['verified', 'reported', 'inferred', 'contradicted', 'unknown', 'needs_verification']) {
+        glossaryRows.push([status, t.statuses[status], r.statusMeanings[status] ?? '']);
+    }
+    lines.push(...table([r.tableHeaders.code, r.tableHeaders.label, r.tableHeaders.meaning], glossaryRows));
+    lines.push('');
+    lines.push(t.reportDisclaimer);
+    lines.push('');
+    return lines.join('\n');
 }
 export function appendEvent(scoutCase, event) {
     const events = scoutCase.events ?? [];
@@ -596,9 +1075,37 @@ export function importCaseFromFiles(files) {
     if (!sources.every(item => item && typeof item.sourceId === 'string' && typeof item.title === 'string')) {
         throw new Error('Invalid source entry in sources.json');
     }
+    for (const [index, source] of sources.entries()) {
+        if (!SOURCE_TYPES.includes(source.type)) {
+            throw new Error(`Invalid source type at sources[${index}]: ${String(source.type)}`);
+        }
+        if (!EVIDENCE_LEVELS.includes(source.evidenceLevel)) {
+            throw new Error(`Invalid evidence level at sources[${index}]: ${String(source.evidenceLevel)}`);
+        }
+    }
     if (!claims.every(item => item && typeof item.claimId === 'string' && typeof item.text === 'string' && typeof item.nextAction === 'string')) {
         throw new Error('Invalid claim entry in claims.json');
     }
+    for (const [index, claim] of claims.entries()) {
+        if (!CLAIM_STATUSES.includes(claim.status)) {
+            throw new Error(`Invalid claim status at claims[${index}]: ${String(claim.status)}`);
+        }
+        if (!CLAIM_DIMENSIONS.includes(claim.dimension)) {
+            throw new Error(`Invalid claim dimension at claims[${index}]: ${String(claim.dimension)}`);
+        }
+        if (!CLAIM_IMPACTS.includes(claim.impact)) {
+            throw new Error(`Invalid claim impact at claims[${index}]: ${String(claim.impact)}`);
+        }
+        if (!EVIDENCE_LEVELS.includes(claim.evidenceLevel)) {
+            throw new Error(`Invalid claim evidence level at claims[${index}]: ${String(claim.evidenceLevel)}`);
+        }
+        if (!Array.isArray(claim.sourceIds) || !claim.sourceIds.every(id => typeof id === 'string')) {
+            throw new Error(`Invalid claim sourceIds at claims[${index}]`);
+        }
+        if (claim.interviewQuestion !== undefined && typeof claim.interviewQuestion !== 'string') {
+            throw new Error(`Invalid claim interviewQuestion at claims[${index}]`);
+        }
+    }
     const events = files['events.jsonl']?.trim()
         ? files['events.jsonl'].trim().split('\n').map(line => JSON.parse(line))
         : [];
@@ -607,13 +1114,22 @@ export function importCaseFromFiles(files) {
     const decisionReasonCode = isDecisionReasonCode(base.decisionReasonCode)
         ? base.decisionReasonCode
         : undefined;
+    const subject = base.subject;
     return {
         schemaVersion: base.schemaVersion,
         caseId: base.caseId,
         title: base.title,
         language: typeof base.language === 'string' && base.language ? base.language : 'zh-CN',
         decisionObjective: base.decisionObjective,
-        subject: base.subject,
+        subject: {
+            ...subject,
+            identityStatus: isIdentityStatus(subject?.identityStatus)
+                ? subject.identityStatus
+                : 'needs_verification',
+            identitySourceIds: Array.isArray(subject?.identitySourceIds)
+                ? subject.identitySourceIds.filter((id) => typeof id === 'string')
+                : [],
+        },
         role: base.role,
         decision: base.decision,
         decisionReason: base.decisionReason,
@@ -636,11 +1152,14 @@ export function renderComparison(cases, opts) {
         counts[claim.status] = (counts[claim.status] ?? 0) + 1;
         return counts;
     }, {});
+    const identityLabel = (scoutCase) => scoutCase.subject.identityStatus === 'verified'
+        ? t.comparison.identityVerified
+        : scoutCase.subject.identityStatus === 'corroborated'
+            ? t.comparison.identityCorroborated
+            : t.comparison.identityUnverified;
     const summaryLine = (scoutCase) => {
         const counts = countByStatus(scoutCase);
-        const identity = scoutCase.subject.identityStatus === 'verified'
-            ? t.comparison.identityVerified
-            : t.comparison.identityUnverified;
+        const identity = identityLabel(scoutCase);
         const countsText = Object.entries(counts)
             .map(([status, count]) => `${count} ${t.statuses[status] ?? status}`)
             .join(' / ');
@@ -661,9 +1180,11 @@ export function renderComparison(cases, opts) {
         ...cases.map(scoutCase => formatScoutString(t.comparison.tableRow, {
             title: scoutCase.title,
             decision: scoutCase.decision,
-            identity: scoutCase.subject.identityStatus === 'verified'
-                ? t.comparison.verifiedMark
-                : t.comparison.unverifiedMark,
+            identity: scoutCase.subject.identityStatus === 'needs_verification'
+                ? t.comparison.unverifiedMark
+                : scoutCase.subject.identityStatus === 'corroborated'
+                    ? `⚠️ ${t.comparison.identityCorroborated}`
+                    : t.comparison.verifiedMark,
             claimCount: scoutCase.claims.length,
         })),
     ];