@slicedearth/whoisleuth-cli 2.3.0 → 2.5.1

package/packages/cases/case-response-outcomes.mjs

@@ -0,0 +1,338 @@
+// Independent observed effects, linked closures and lifecycle summaries.
+import { MAX_CASE_CLOSURES, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_RATIONALE_LENGTH, } from "../contracts/case-portability.mjs";
+import { latestObservationCohort, } from "../evidence/latest-observations.mjs";
+import { readCaseRecheckAnswerContext } from "./case-recheck-model.mjs";
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
+import { CASE_CLOSURE_REASONS, CASE_OBSERVED_EFFECT_SOURCE_CLASSES, CASE_OBSERVED_EFFECT_STATES, } from "./case-response-records.mjs";
+import { COMPLETENESS, SAFE_ID_RE, boundedCounter, compareCodeUnits, freshId, iso, lifecycleLimitations, limitations, optionalIso, record, safeId, text, } from "./case-response-values.mjs";
+const OBSERVED_EFFECT_STATES = new Set(CASE_OBSERVED_EFFECT_STATES);
+const OBSERVED_EFFECT_SOURCE_CLASSES = new Set(CASE_OBSERVED_EFFECT_SOURCE_CLASSES);
+const CLOSURE_REASONS = new Set(CASE_CLOSURE_REASONS);
+function normalizeObservedEffectReview(raw, fallback, validPinIds, validSightingIds, options = {}) {
+    const item = record(raw);
+    if (typeof item.state !== 'string' || !OBSERVED_EFFECT_STATES.has(item.state))
+        return null;
+    if (typeof item.sourceClass !== 'string' || !OBSERVED_EFFECT_SOURCE_CLASSES.has(item.sourceClass))
+        return null;
+    const source = text(item.source, MAX_RESPONSE_LABEL_LENGTH);
+    const observedAt = optionalIso(item.observedAt, options);
+    if (!source || !observedAt)
+        return null;
+    const createdAt = iso(item.createdAt, observedAt || fallback, options);
+    const recheck = readCaseRecheckAnswerContext(item.recheck, options.sourceVersion);
+    if (recheck && item.state === 'not_reproduced' && (item.completeness !== 'complete' || recheck.conditionsMatch !== 'comparable')) {
+        throw new TypeError('A question cannot be marked not reproduced from incomplete evidence or unconfirmed comparison conditions.');
+    }
+    const evidencePinId = typeof item.evidencePinId === 'string'
+        && SAFE_ID_RE.test(item.evidencePinId)
+        && (!validPinIds || validPinIds.has(item.evidencePinId))
+        ? item.evidencePinId
+        : null;
+    const sightingId = typeof item.sightingId === 'string'
+        && SAFE_ID_RE.test(item.sightingId)
+        && (!validSightingIds || validSightingIds.has(item.sightingId))
+        ? item.sightingId
+        : null;
+    const linkLimitations = [
+        ...(item.evidencePinId != null && !evidencePinId ? ['A malformed or dangling evidence-pin reference was omitted from this independent review.'] : []),
+        ...(item.sightingId != null && !sightingId ? ['A malformed or dangling sighting reference was omitted from this independent review.'] : []),
+    ];
+    return {
+        id: safeId(item.id, 'effect-review', { state: item.state, source, observedAt, createdAt }),
+        state: item.state,
+        observedAt,
+        sourceClass: item.sourceClass,
+        source,
+        completeness: typeof item.completeness === 'string' && COMPLETENESS.has(item.completeness)
+            ? item.completeness
+            : 'unknown',
+        limitations: limitations([...linkLimitations, ...limitations(item.limitations)]),
+        evidencePinId,
+        sightingId,
+        followUpAt: optionalIso(item.followUpAt, options),
+        ...(recheck ? { recheck } : {}),
+        createdAt,
+    };
+}
+export function normalizeCaseObservedEffectHistory(raw, fallback, validPinIds, validSightingIds, options = {}) {
+    const root = record(raw);
+    const source = Array.isArray(raw) ? raw : Array.isArray(root.reviews) ? root.reviews : [];
+    const byId = new Map();
+    let invalid = 0;
+    let duplicateConflict = 0;
+    for (const item of source.slice(0, MAX_CASE_OBSERVED_EFFECT_REVIEWS * 4)) {
+        const normalized = normalizeObservedEffectReview(item, fallback, validPinIds, validSightingIds, options);
+        if (!normalized) {
+            invalid += 1;
+            continue;
+        }
+        const existing = byId.get(normalized.id);
+        if (!existing)
+            byId.set(normalized.id, normalized);
+        else if (JSON.stringify(normalized) !== JSON.stringify(existing)) {
+            duplicateConflict += 1;
+            if (JSON.stringify(normalized) < JSON.stringify(existing))
+                byId.set(normalized.id, normalized);
+        }
+    }
+    const all = [...byId.values()].sort((left, right) => Date.parse(left.observedAt) - Date.parse(right.observedAt) || compareCodeUnits(left.id, right.id));
+    invalid += Math.max(0, source.length - MAX_CASE_OBSERVED_EFFECT_REVIEWS * 4);
+    const omitted = boundedCounter(root.omitted)
+        + invalid
+        + duplicateConflict
+        + Math.max(0, all.length - MAX_CASE_OBSERVED_EFFECT_REVIEWS);
+    const preV13HistoryUnavailable = options.sourceVersion != null && options.sourceVersion <= 12
+        ? true
+        : root.preV13HistoryUnavailable === true;
+    const retainedLimitations = limitations(root.limitations).filter((item) => !/^\d+ earlier observed-effect reviews? omitted by bounded retention\.$/u.test(item));
+    return {
+        reviews: all.slice(-MAX_CASE_OBSERVED_EFFECT_REVIEWS),
+        omitted,
+        preV13HistoryUnavailable,
+        limitations: lifecycleLimitations([
+            ...(omitted ? [`${omitted} earlier observed-effect review${omitted === 1 ? '' : 's'} omitted by bounded retention.`] : []),
+            ...(invalid ? [`${invalid} malformed or unlinked observed-effect review${invalid === 1 ? '' : 's'} omitted during normalisation.`] : []),
+            ...(duplicateConflict ? [`${duplicateConflict} conflicting observed-effect review identit${duplicateConflict === 1 ? 'y was' : 'ies were'} reconciled deterministically.`] : []),
+            ...(preV13HistoryUnavailable ? ['Migrated from a pre-v13 Case; earlier independent observed-effect review history is unavailable.'] : []),
+            'Observed-effect reviews are independent point-in-time records; provider workflow events do not create or replace them.',
+            ...retainedLimitations,
+        ]),
+    };
+}
+export function appendCaseObservedEffectReview(current, raw, now, validPinIds, validSightingIds) {
+    const item = record(raw);
+    const created = normalizeObservedEffectReview({ ...item, id: freshId('effect-review'), createdAt: now }, now, validPinIds, validSightingIds);
+    if (!created)
+        throw new Error('An independent observed-effect review requires a valid state, time, source class, and source.');
+    return normalizeCaseObservedEffectHistory({
+        reviews: [...current.reviews, created],
+        omitted: current.omitted,
+        preV13HistoryUnavailable: current.preV13HistoryUnavailable,
+        limitations: current.limitations,
+    }, now, validPinIds, validSightingIds);
+}
+export function mergeCaseObservedEffectHistories(local, imported, fallback, validPinIds, validSightingIds) {
+    return normalizeCaseObservedEffectHistory({
+        reviews: [...local.reviews, ...imported.reviews],
+        omitted: Math.max(local.omitted, imported.omitted),
+        preV13HistoryUnavailable: local.preV13HistoryUnavailable || imported.preV13HistoryUnavailable,
+        limitations: [...local.limitations, ...imported.limitations],
+    }, fallback, validPinIds, validSightingIds);
+}
+function normalizeClosure(raw, fallback, validReviewIds, validActionIds, options = {}, linkContext = {}) {
+    const item = record(raw);
+    if (typeof item.reason !== 'string' || !CLOSURE_REASONS.has(item.reason))
+        return null;
+    const reason = item.reason;
+    const summary = text(item.summary, MAX_RESPONSE_RATIONALE_LENGTH);
+    if (!summary)
+        return null;
+    const createdAt = iso(item.createdAt, fallback, options);
+    const observedEffectReviewId = typeof item.observedEffectReviewId === 'string'
+        && SAFE_ID_RE.test(item.observedEffectReviewId)
+        && (!validReviewIds || validReviewIds.has(item.observedEffectReviewId))
+        ? item.observedEffectReviewId
+        : null;
+    const actionId = typeof item.actionId === 'string'
+        && SAFE_ID_RE.test(item.actionId)
+        && (!validActionIds || validActionIds.has(item.actionId))
+        ? item.actionId
+        : null;
+    const linkedReview = observedEffectReviewId ? linkContext.reviewEvidence?.get(observedEffectReviewId) : undefined;
+    const reviewPredatesClosure = linkedReview !== undefined
+        && Date.parse(linkedReview.observedAt) <= Date.parse(createdAt)
+        && Date.parse(linkedReview.createdAt) <= Date.parse(createdAt);
+    if (linkContext.reviewEvidence && reason === 'independently_not_reproduced'
+        && (!reviewPredatesClosure || linkedReview?.state !== 'not_reproduced'))
+        return null;
+    if (linkContext.reviewEvidence && reason === 'infrastructure_changed'
+        && (!reviewPredatesClosure || linkedReview?.state !== 'changed'))
+        return null;
+    const linkedProviderEvents = actionId ? linkContext.providerResolutionEvents?.get(actionId) ?? [] : [];
+    if (linkContext.providerResolutionEvents && reason === 'provider_reported_resolution_not_independently_checked'
+        && !linkedProviderEvents.some((event) => Date.parse(event.occurredAt) <= Date.parse(createdAt)))
+        return null;
+    const linkLimitations = [
+        ...(item.observedEffectReviewId != null && !observedEffectReviewId ? ['A malformed or dangling observed-effect review reference was omitted from this closure.'] : []),
+        ...(item.actionId != null && !actionId ? ['A malformed or dangling response-action reference was omitted from this closure.'] : []),
+    ];
+    return {
+        id: safeId(item.id, 'case-closure', { reason: item.reason, summary, createdAt }),
+        reason,
+        summary,
+        observedEffectReviewId,
+        actionId,
+        limitations: limitations([...linkLimitations, ...limitations(item.limitations)]),
+        createdAt,
+    };
+}
+export function buildCaseClosureLinkContext(observedEffects, actions) {
+    return {
+        reviewEvidence: new Map(observedEffects.reviews.map((review) => [review.id, {
+                state: review.state,
+                observedAt: review.observedAt,
+                createdAt: review.createdAt,
+            }])),
+        providerResolutionEvents: new Map(actions.map((action) => [action.id, action.history
+                .filter((event) => event.applied && event.providerOutcome === 'provider_reports_resolved')
+                .map((event) => ({ eventId: event.id, occurredAt: event.occurredAt }))])),
+    };
+}
+export function normalizeCaseClosureHistory(raw, fallback, validReviewIds, validActionIds, options = {}, linkContext = {}) {
+    const root = record(raw);
+    const source = Array.isArray(raw) ? raw : Array.isArray(root.records) ? root.records : [];
+    const byId = new Map();
+    let invalid = 0;
+    let duplicateConflict = 0;
+    for (const item of source.slice(0, MAX_CASE_CLOSURES * 4)) {
+        const normalized = normalizeClosure(item, fallback, validReviewIds, validActionIds, options, linkContext);
+        if (!normalized) {
+            invalid += 1;
+            continue;
+        }
+        const existing = byId.get(normalized.id);
+        if (!existing)
+            byId.set(normalized.id, normalized);
+        else if (JSON.stringify(normalized) !== JSON.stringify(existing)) {
+            duplicateConflict += 1;
+            if (JSON.stringify(normalized) < JSON.stringify(existing))
+                byId.set(normalized.id, normalized);
+        }
+    }
+    const all = [...byId.values()].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt) || compareCodeUnits(left.id, right.id));
+    invalid += Math.max(0, source.length - MAX_CASE_CLOSURES * 4);
+    const omitted = boundedCounter(root.omitted)
+        + invalid
+        + duplicateConflict
+        + Math.max(0, all.length - MAX_CASE_CLOSURES);
+    const preV13HistoryUnavailable = options.sourceVersion != null && options.sourceVersion <= 12
+        ? true
+        : root.preV13HistoryUnavailable === true;
+    const retainedLimitations = limitations(root.limitations).filter((item) => !/^\d+ earlier closure records? omitted by bounded retention\.$/u.test(item));
+    return {
+        records: all.slice(-MAX_CASE_CLOSURES),
+        omitted,
+        preV13HistoryUnavailable,
+        limitations: lifecycleLimitations([
+            ...(omitted ? [`${omitted} earlier closure record${omitted === 1 ? '' : 's'} omitted by bounded retention.`] : []),
+            ...(invalid ? [`${invalid} malformed, unsupported, or unlinked closure record${invalid === 1 ? '' : 's'} omitted during normalisation.`] : []),
+            ...(duplicateConflict ? [`${duplicateConflict} conflicting closure record identit${duplicateConflict === 1 ? 'y was' : 'ies were'} reconciled deterministically.`] : []),
+            ...(preV13HistoryUnavailable ? ['Migrated from a pre-v13 Case; earlier deliberate closure history is unavailable.'] : []),
+            'Closure records are deliberate analyst actions and do not establish absence, safety, provider performance, or legal sufficiency.',
+            ...retainedLimitations,
+        ]),
+    };
+}
+/** New-write policy only. Historical normalisation must not re-adjudicate a closure. */
+export function caseClosureReviewBlocker(reason, review, now) {
+    if (reason !== 'independently_not_reproduced' && reason !== 'infrastructure_changed')
+        return null;
+    const expected = reason === 'independently_not_reproduced' ? 'not_reproduced' : 'changed';
+    const invalidLink = reason === 'independently_not_reproduced'
+        ? 'This closure reason requires a linked independent not-reproduced review.'
+        : 'This closure reason requires a linked independent changed review.';
+    if (!review || review.state !== expected)
+        return invalidLink;
+    const observedAt = normalizeExplicitIsoTimestamp(review.observedAt);
+    const createdAt = normalizeExplicitIsoTimestamp(review.createdAt);
+    const closedAt = normalizeExplicitIsoTimestamp(now);
+    if (!observedAt || !createdAt || !closedAt
+        || Date.parse(observedAt) > Date.parse(closedAt)
+        || Date.parse(createdAt) > Date.parse(closedAt))
+        return invalidLink;
+    if (reason === 'independently_not_reproduced') {
+        if (review.completeness !== 'complete')
+            return 'Independent non-reproduction closure requires a complete observation. Keep this limited review and collect or record a complete recheck.';
+        if (review.recheck && review.recheck.conditionsMatch !== 'comparable')
+            return 'Independent non-reproduction closure requires comparable recheck conditions.';
+    }
+    return null;
+}
+export function appendCaseClosure(current, raw, now, observedEffects, actions) {
+    const item = record(raw);
+    const reason = typeof item.reason === 'string' && CLOSURE_REASONS.has(item.reason)
+        ? item.reason
+        : null;
+    const review = typeof item.observedEffectReviewId === 'string'
+        ? observedEffects.reviews.find((candidate) => candidate.id === item.observedEffectReviewId) ?? null
+        : null;
+    const action = typeof item.actionId === 'string'
+        ? actions.find((candidate) => candidate.id === item.actionId) ?? null
+        : null;
+    const reviewBlocker = caseClosureReviewBlocker(reason, review, now);
+    if (reviewBlocker)
+        throw new Error(reviewBlocker);
+    if (reason === 'provider_reported_resolution_not_independently_checked'
+        && (action?.providerOutcome !== 'provider_reports_resolved'
+            || !action.history.some((event) => event.applied
+                && event.providerOutcome === 'provider_reports_resolved'
+                && Date.parse(event.occurredAt) <= Date.parse(now)))) {
+        throw new Error('This closure reason requires a linked typed provider-reported-resolution outcome.');
+    }
+    const linkContext = buildCaseClosureLinkContext(observedEffects, actions);
+    const created = normalizeClosure({ ...item, id: freshId('case-closure'), createdAt: now }, now, new Set(observedEffects.reviews.map((candidate) => candidate.id)), new Set(actions.map((candidate) => candidate.id)), {}, linkContext);
+    if (!created || !reason)
+        throw new Error('A deliberate closure requires a typed reason and summary.');
+    return normalizeCaseClosureHistory({
+        records: [...current.records, created],
+        omitted: current.omitted,
+        preV13HistoryUnavailable: current.preV13HistoryUnavailable,
+        limitations: current.limitations,
+    }, now, new Set(observedEffects.reviews.map((candidate) => candidate.id)), new Set(actions.map((candidate) => candidate.id)), {}, linkContext);
+}
+export function mergeCaseClosureHistories(local, imported, fallback, validReviewIds, validActionIds, linkContext = {}) {
+    return normalizeCaseClosureHistory({
+        records: [...local.records, ...imported.records],
+        omitted: Math.max(local.omitted, imported.omitted),
+        preV13HistoryUnavailable: local.preV13HistoryUnavailable || imported.preV13HistoryUnavailable,
+        limitations: [...local.limitations, ...imported.limitations],
+    }, fallback, validReviewIds, validActionIds, {}, linkContext);
+}
+export function buildCaseResponseLifecycleSummary(input) {
+    const providerEvents = (input.actions ?? []).flatMap((action) => action.history
+        .filter((event) => event.providerOutcome)
+        .map((event) => ({ action, event })));
+    const providerCohort = latestObservationCohort(providerEvents, ({ event }) => event.occurredAt);
+    const providerEventsAtLatestTime = providerCohort.latest;
+    const latestProvider = providerEventsAtLatestTime.length === 1 && !providerCohort.undated.length && providerEventsAtLatestTime[0].event.applied
+        ? providerEventsAtLatestTime[0]
+        : null;
+    const providerOutcomeState = providerEvents.length === 0
+        ? 'missing'
+        : latestProvider ? 'available' : 'ambiguous';
+    const reviews = input.observedEffects?.reviews ?? [];
+    const observedCohort = latestObservationCohort(reviews, (review) => review.observedAt);
+    const latestObserved = observedCohort.latest.length === 1 && !observedCohort.undated.length
+        ? observedCohort.latest[0]
+        : null;
+    const changedReviews = reviews.filter((review) => review.state === 'changed');
+    const changedCohort = latestObservationCohort(changedReviews, (review) => review.observedAt);
+    const latestObservedChangeAt = changedCohort.latest.length === 1 && !changedCohort.undated.length
+        ? changedCohort.observedAt
+        : null;
+    const observedChangeState = changedReviews.length === 0
+        ? 'missing'
+        : latestObservedChangeAt ? 'available' : 'ambiguous';
+    const latestClosure = [...(input.closures?.records ?? [])]
+        .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt) || compareCodeUnits(right.id, left.id))[0] ?? null;
+    return {
+        providerOutcomeState,
+        latestProviderOutcome: latestProvider ? {
+            actionId: latestProvider.action.id,
+            eventId: latestProvider.event.id,
+            outcome: latestProvider.event.providerOutcome,
+            occurredAt: latestProvider.event.occurredAt,
+            reference: latestProvider.event.reference,
+        } : null,
+        observedChangeState,
+        latestObservedEffect: latestObserved ? {
+            reviewId: latestObserved.id,
+            state: latestObserved.state,
+            observedAt: latestObserved.observedAt,
+            sourceClass: latestObserved.sourceClass,
+            source: latestObserved.source,
+        } : null,
+        latestObservedChangeAt,
+        latestClosure,
+    };
+}

package/packages/cases/case-response-packet-render.mjs

@@ -0,0 +1,157 @@
+import { RESPONSE_AUTHORISATION_CONFIRMATION_IDS, responseContactLabel as contactLabel } from "./case-response-packet-vocabulary.mjs";
+import { escapeCaseMarkdownInline as escapeMarkdown } from "./case-markdown.mjs";
+/** Render only the projected packet, never the source Case or private inputs. */
+export function renderCaseResponsePacket(packet) {
+    const { profile, case: caseRecord, incident: { category, affectedParty, abusiveUrls, observedHarm, observedAt }, generatedAt: normalizedGeneratedAt, recipientRoute, escalationHistory, escalationHistoryOmitted, escalationHistoryLimitations, authorisation, readiness, selectedEvidence, artefactReferences, responseLifecycle, preflight, provenance: { limitations, evidencePinCount, decisionCount, assertionCount, observationAge: age }, integrity: { digestSha256 }, } = packet;
+    const lines = [
+        `# ${escapeMarkdown(profile.label)} packet`,
+        '',
+        `**Domain:** ${escapeMarkdown(caseRecord.domain)}`,
+        `**Category:** ${escapeMarkdown(category)}`,
+        `**Affected party:** ${escapeMarkdown(affectedParty)}`,
+        `**Observed at (UTC):** ${observedAt}`,
+        `**Generated at (UTC):** ${normalizedGeneratedAt}`,
+        `**Audience:** ${escapeMarkdown(profile.audience)}`,
+        `**Suggested subject:** ${escapeMarkdown(profile.subject)}`,
+        '',
+        '## Observed harm',
+        '',
+        escapeMarkdown(observedHarm),
+        '',
+        '## Exact abusive URLs',
+        '',
+        ...abusiveUrls.map((url) => `- ${escapeMarkdown(url)}`),
+        '',
+        '## Selected response route',
+        '',
+        ...(recipientRoute
+            ? [
+                `### ${contactLabel(recipientRoute.kind)}`,
+                '',
+                `- Case action: ${escapeMarkdown(recipientRoute.actionId)}`,
+                `- Contact: ${escapeMarkdown(recipientRoute.contact)}`,
+                `- Source: ${escapeMarkdown(recipientRoute.source)}`,
+                `- Route observed: ${recipientRoute.observedAt ?? 'Not provided'} (${recipientRoute.freshness})`,
+                `- Route review after: ${recipientRoute.reviewAfter ?? 'Not provided'}`,
+                `- Limitations: ${recipientRoute.limitations.length ? recipientRoute.limitations.map(escapeMarkdown).join('; ') : 'None recorded'}`,
+                '',
+            ]
+            : ['No profile-appropriate response route was bound to this packet.', '']),
+        '## Selected action lineage',
+        '',
+        ...(escalationHistory.length
+            ? escalationHistory.flatMap((action) => [
+                `- ${escapeMarkdown(action.type.replaceAll('_', ' '))} to ${escapeMarkdown(action.recipient)} · ${escapeMarkdown(action.state.replaceAll('_', ' '))} · updated ${action.updatedAt}`,
+                `  - Route observed: ${action.routeObservedAt ?? 'Not provided'}`,
+                ...(action.reference ? [`  - Reference: ${escapeMarkdown(action.reference)}`] : []),
+                ...(action.providerOutcome ? [`  - Typed provider outcome: ${escapeMarkdown(action.providerOutcome.replaceAll('_', ' '))}`] : []),
+                ...(action.outcomeDetail ? [`  - Outcome detail: ${escapeMarkdown(action.outcomeDetail)}`] : []),
+                ...(action.originActionId ? [`  - Originating action: ${escapeMarkdown(action.originActionId)}`] : []),
+                ...(action.amendment ? [`  - Amendment of submitted packet SHA-256: ${action.amendment.packetDigestSha256}`, `  - Prepared request events: ${action.amendment.requestEventIds.map(escapeMarkdown).join(', ')}`] : []),
+                ...action.transitions.flatMap((event) => [
+                    `  - ${event.occurredAt}: ${escapeMarkdown(event.previousState ?? 'none')} → ${escapeMarkdown(event.nextState)} · ${escapeMarkdown(event.sourceClass)} · ${escapeMarkdown(event.provenance)}${event.providerOutcome ? ` · ${escapeMarkdown(event.providerOutcome.replaceAll('_', ' '))}` : ''}${event.applied ? '' : ' · retained conflict'}`,
+                    ...(event.reference ? [`    - Reference: ${escapeMarkdown(event.reference)}`] : []),
+                    ...(event.evidencePinId ? [`    - Evidence pin: ${escapeMarkdown(event.evidencePinId)}`] : []),
+                    ...(event.evidenceRequest ? [
+                        `    - Requested evidence (${event.evidenceRequest.state}): ${escapeMarkdown(event.evidenceRequest.summary)}`,
+                        `    - Original packet SHA-256: ${event.evidenceRequest.packetDigestSha256}; deadline: ${event.evidenceRequest.dueAt ?? 'not provided'}`,
+                        `    - Prepared pins: ${event.evidenceRequest.evidencePinIds.map(escapeMarkdown).join(', ') || 'none'}${event.evidenceRequest.rationale ? `; ${escapeMarkdown(event.evidenceRequest.rationale)}` : ''}`,
+                    ] : []),
+                    ...(event.originActionId ? [`    - Originating action: ${escapeMarkdown(event.originActionId)}`] : []),
+                    ...event.limitations.map((limitation) => `    - Limitation: ${escapeMarkdown(limitation)}`),
+                ]),
+                ...(action.historyOmitted ? [`  - ${action.historyOmitted} earlier transition event${action.historyOmitted === 1 ? '' : 's'} omitted by bound.`] : []),
+                ...action.historyLimitations.map((limitation) => `  - History limitation: ${escapeMarkdown(limitation)}`),
+            ])
+            : ['No Case action was selected.']),
+        ...(escalationHistoryOmitted ? [`- Unrelated Case actions excluded from packet: ${escalationHistoryOmitted}`] : []),
+        ...escalationHistoryLimitations.map((limitation) => `- Packet history limitation: ${escapeMarkdown(limitation)}`),
+        '',
+        '## Readiness and authorisation',
+        '',
+        `- Packet state: ${authorisation.status}`,
+        `- Reviewed-input SHA-256: ${authorisation.reviewedInputDigestSha256}`,
+        `- Supplied review digest matches: ${authorisation.digestMatches ? 'yes' : 'no'}`,
+        ...RESPONSE_AUTHORISATION_CONFIRMATION_IDS.map((id) => `- Confirmation ${id}: ${authorisation.confirmations[id] ? 'yes' : 'no'}`),
+        ...readiness.rows.flatMap((row) => [
+            `- ${escapeMarkdown(row.label)} [${row.state}]: ${escapeMarkdown(row.detail)}`,
+            ...row.limitations.map((limitation) => `  - Limitation: ${escapeMarkdown(limitation)}`),
+        ]),
+        ...authorisation.limitations.map((limitation) => `- ${escapeMarkdown(limitation)}`),
+        '',
+        '## Selected evidence and integrity references',
+        '',
+        ...(selectedEvidence.length ? selectedEvidence.map((item) => `- ${escapeMarkdown(item.id)} · ${escapeMarkdown(item.label)} · ${escapeMarkdown(item.source)}${item.observationHostname ? ` · ${escapeMarkdown(item.observationHostname)}` : ''}${item.webObservationMode ? ' · selected URL' : ''} · ${item.observedAt ?? 'Observation time unavailable'} · ${escapeMarkdown(item.completeness)}`) : ['- No evidence pin was explicitly selected.']),
+        ...artefactReferences.map((item) => `- ${escapeMarkdown(item.id)} · ${escapeMarkdown(item.label)} · SHA-256 ${item.digestSha256} · captured ${item.capturedAt}`),
+        '',
+        '## Provider outcome and independent effect',
+        '',
+        responseLifecycle.latestProviderOutcome
+            ? `- Provider outcome time: ${responseLifecycle.latestProviderOutcome.occurredAt} (${escapeMarkdown(responseLifecycle.latestProviderOutcome.outcome.replaceAll('_', ' '))})`
+            : `- Provider outcome time: Withheld because the typed event state is ${responseLifecycle.providerOutcomeState}.`,
+        responseLifecycle.latestObservedChangeAt
+            ? `- Independently observed change time: ${responseLifecycle.latestObservedChangeAt}`
+            : `- Independently observed change time: Withheld because the independent change state is ${responseLifecycle.observedChangeState}.`,
+        ...(responseLifecycle.latestObservedEffect ? [`- Latest independent review: ${escapeMarkdown(responseLifecycle.latestObservedEffect.state.replaceAll('_', ' '))} · ${responseLifecycle.latestObservedEffect.observedAt} · ${escapeMarkdown(responseLifecycle.latestObservedEffect.source)}`] : []),
+        ...responseLifecycle.limitations.map((limitation) => `- ${escapeMarkdown(limitation)}`),
+        '',
+        '## Review and provenance',
+        '',
+        `- Preflight: ${preflight.status.replaceAll('_', ' ')} (${preflight.counts.pass} pass, ${preflight.counts.caution} caution, ${preflight.counts.block} block)`,
+        ...preflight.checks.map((check) => `- ${escapeMarkdown(check.label)} [${check.state}]: ${escapeMarkdown(check.detail)}`),
+        ...limitations.map((limitation) => `- ${escapeMarkdown(limitation)}`),
+        `- Case evidence pins: ${evidencePinCount}`,
+        `- Case decision records: ${decisionCount}`,
+        `- Case structured assertions: ${assertionCount}`,
+        `- Observation-age band at export: ${age.band.replaceAll('_', ' ')}`,
+        `- Canonical packet SHA-256: ${digestSha256}`,
+        '- Digest scope: canonical sorted JSON packet excluding the integrity object',
+        '',
+        '## Audience profile',
+        '',
+        ...profile.checklist.map((item) => `- Checklist: ${escapeMarkdown(item)}`),
+        ...profile.includedEvidence.map((item) => `- Included: ${escapeMarkdown(item)}`),
+        ...profile.excludedEvidence.map((item) => `- Excluded: ${escapeMarkdown(item)}`),
+        ...profile.redactions.map((item) => `- Redaction to confirm: ${escapeMarkdown(item)}`),
+        ...profile.attachments.map((item) => `- Attachment expectation: ${escapeMarkdown(item)}`),
+        ...profile.followUpFields.map((item) => `- Follow-up field: ${escapeMarkdown(item)}`),
+    ];
+    const markdown = `${lines.join('\n').trim()}\n`;
+    const email = [
+        `Subject: ${profile.subject}`,
+        '',
+        'Hello,',
+        '',
+        `I am reporting observed ${category} activity involving ${caseRecord.domain}.`,
+        `Affected party: ${affectedParty}`,
+        `Observed at (UTC): ${observedAt}`,
+        '',
+        'Observed harm:',
+        observedHarm,
+        '',
+        'Exact URLs:',
+        ...abusiveUrls.map((url) => `- ${url}`),
+        '',
+        'Selected evidence:',
+        ...(selectedEvidence.length
+            ? selectedEvidence.map((item) => `- ${item.label} — ${item.source}${item.observationHostname ? ` for ${item.observationHostname}` : ''}${item.webObservationMode ? ' · selected URL' : ''}, observed ${item.observedAt ?? 'time unavailable'} (${item.completeness})`)
+            : ['- No Case evidence pin was selected.']),
+        '',
+        `Reviewed packet SHA-256: ${digestSha256}`,
+        'Attach the reviewed packet (and any separately reviewed evidence files) through the recipient’s approved submission channel; this message does not embed or transmit attachments.',
+        '',
+        ...(responseLifecycle.latestProviderOutcome
+            ? [`Provider outcome time: ${responseLifecycle.latestProviderOutcome.occurredAt} (${responseLifecycle.latestProviderOutcome.outcome.replaceAll('_', ' ')})`]
+            : []),
+        ...(responseLifecycle.latestObservedChangeAt
+            ? [`Independently observed change time: ${responseLifecycle.latestObservedChangeAt}`]
+            : []),
+        '',
+        'Please review this report under the applicable abuse and acceptable-use policies.',
+        '',
+        authorisation.status === 'authorised'
+            ? 'This locally prepared packet is bound to explicit review confirmations. It was not submitted automatically and does not promise any provider outcome.'
+            : 'This is an unauthorised local draft with cautions. It was not submitted automatically and does not promise any provider outcome.',
+    ].join('\n');
+    return { markdown, email: `${email}\n` };
+}

package/packages/cases/case-response-packet-types.mjs

@@ -0,0 +1 @@
+export {};

package/packages/cases/case-response-packet-vocabulary.mjs

@@ -0,0 +1,48 @@
+// Response packet vocabulary shared by construction and independent validation.
+export const RESPONSE_CONTACT_KINDS = [
+    'registrar',
+    'registry',
+    'network_hosting',
+    'security_txt',
+    'application_platform',
+];
+export const RESPONSE_PACKET_PROFILE_IDS = [
+    'registrar',
+    'registry',
+    'network_hosting',
+    'security_contact',
+    'application_platform',
+    'browser_blocklist',
+    'internal_soc',
+];
+export const RESPONSE_READINESS_STATES = ['complete', 'partial', 'stale', 'unavailable', 'not_provided'];
+export const RESPONSE_READINESS_ROW_IDS = [
+    'observed_behaviour',
+    'exact_url',
+    'observation_time',
+    'capture_provenance',
+    'infrastructure_responsibility',
+    'recipient_route',
+    'authority_review',
+    'selected_evidence',
+    'contradictions',
+    'source_limitations',
+];
+export const RESPONSE_AUTHORISATION_CONFIRMATION_IDS = [
+    'selectedEvidence',
+    'recipientScope',
+    'privacyRedactions',
+    'analystAuthority',
+    'evidenceFreshness',
+];
+export function responseContactLabel(value) {
+    if (value === 'network_hosting')
+        return 'Observed endpoint network registration';
+    if (value === 'security_txt')
+        return 'security.txt';
+    if (value === 'application_platform')
+        return 'Application platform';
+    if (value === 'manual')
+        return 'Manual submission';
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}