@aiwg/cli 2026.7.21 → 2026.7.23

package/dist/src/config/aiwg-config.js

@@ -15,6 +15,7 @@ import { normalizeNamedCaptures } from '../artifacts/index-builder.js';
 import { getProviderDefinition, PROVIDER_IDS, resolveProviderPathValue, } from '../providers/provider-definitions.js';
 import { validateAuthorization, } from '../policy/authorization.js';
 import { projectAiwgPath, resolveProjectAiwgDir } from './project-artifacts.js';
+import { defaultThreatAssessmentConfig, validateThreatAssessmentConfig, } from '../security/threat-assessment-config.js';
 const CONFIG_FILENAME = 'aiwg.config';
 /**
  * Operations that a workspace may authorize for one member repository.
@@ -633,6 +634,9 @@ export function emptyConfig(providers = ['claude']) {
         providers,
         installed: {},
         scripts: {},
+        security: {
+            threatAssessment: defaultThreatAssessmentConfig(),
+        },
         delivery: {
             mode: 'pr-required',
             default_branch: 'main',
@@ -711,12 +715,20 @@ export async function readAiwgConfig(projectDir) {
     if (authorizationErrors.length > 0) {
         throw new Error(`Invalid .aiwg/aiwg.config:\n${authorizationErrors.map(item => item.message).join('\n')}`);
     }
+    const threatAssessmentErrors = validateThreatAssessmentConfig(parsed.security?.threatAssessment);
+    if (threatAssessmentErrors.length > 0) {
+        throw new Error(`Invalid .aiwg/aiwg.config:\n${threatAssessmentErrors.join('\n')}`);
+    }
     return parsed;
 }
 /**
  * Write aiwg.config, creating the resolved AIWG artifact directory if needed.
  */
 export async function writeAiwgConfig(projectDir, config) {
+    const threatAssessmentErrors = validateThreatAssessmentConfig(config.security?.threatAssessment);
+    if (threatAssessmentErrors.length > 0) {
+        throw new Error(`Invalid .aiwg/aiwg.config:\n${threatAssessmentErrors.join('\n')}`);
+    }
     const dir = resolveProjectAiwgDir(projectDir);
     await mkdir(dir, { recursive: true });
     const filePath = join(dir, CONFIG_FILENAME);

package/dist/src/config/cli.js

@@ -152,6 +152,7 @@ const ENUM_RULES = {
     'remotes.tracker_actor.via': ['tea', 'gh', 'mcp', 'api'],
     'remotes.transport.protocol': ['ssh', 'https'],
     'repo_maintainer.tiers.local': ['collaborator', 'maintainer', 'admin'],
+    'security.threatAssessment.mode': ['off', 'audit', 'enforce'],
 };
 const BOOLEAN_FIELDS = new Set([
     'delivery.delete_branch_on_merge',
@@ -214,15 +215,17 @@ async function projectConfigSet(key, raw, args) {
     }
     // Coerce booleans for known boolean fields
     let value = raw;
-    if (/^externalLinks\.[^.]+$/.test(key)) {
+    if (/^externalLinks\.[^.]+$/.test(key) || key === 'security.threatAssessment') {
         try {
             value = JSON.parse(raw);
         }
         catch {
             throw new AiwgError({
                 code: 'ERR_INVALID_VALUE',
-                message: `${key} must be a JSON object containing label and url`,
-                hint: `Try: aiwg config set --project ${key} '{"label":"Project docs","url":"https://example.com/docs"}'`,
+                message: `${key} must be a valid JSON object`,
+                hint: key === 'security.threatAssessment'
+                    ? `Try: aiwg config set --project ${key} '{"schemaVersion":"1","mode":"audit","defaultProfile":"balanced"}'`
+                    : `Try: aiwg config set --project ${key} '{"label":"Project docs","url":"https://example.com/docs"}'`,
                 exitCode: EXIT_CODES.USAGE,
             });
         }
@@ -285,6 +288,16 @@ async function projectConfigSet(key, raw, args) {
             exitCode: EXIT_CODES.USAGE,
         });
     }
+    const { validateThreatAssessmentConfig } = await import('../security/threat-assessment-config.js');
+    const threatErrors = validateThreatAssessmentConfig(cfg.security?.threatAssessment);
+    if (threatErrors.length > 0) {
+        throw new AiwgError({
+            code: 'ERR_INVALID_VALUE',
+            message: `Invalid threat-assessment configuration: ${threatErrors.join('; ')}`,
+            hint: 'Use a built-in profile or correct the referenced profile, rule pack, threshold, or regex.',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    }
     await writeAiwgConfig(projectDir, cfg);
     console.log(`Set --project ${key} = ${raw}`);
 }

package/dist/src/security/threat-assessment-config.js

@@ -0,0 +1,296 @@
+export const THREAT_ASSESSMENT_MODES = ['off', 'audit', 'enforce'];
+export const THREAT_ASSESSMENT_SEVERITIES = [
+    'informational',
+    'low',
+    'moderate',
+    'high',
+    'critical',
+];
+export const THREAT_ASSESSMENT_SURFACES = [
+    'issue-title',
+    'issue-body',
+    'issue-comment',
+    'pull-request-title',
+    'pull-request-body',
+    'pull-request-diff-summary',
+    'review-comment',
+    'release-note',
+    'handoff',
+    'outbound-maintainer-comment',
+];
+const BUILTIN_PROFILES = new Set(['trusted', 'audit', 'balanced', 'strict', 'high-assurance']);
+const BUILTIN_RULE_PACKS = new Set([
+    'aiwg:all',
+    'aiwg:prompt-injection',
+    'aiwg:supply-chain',
+    'aiwg:credential-protection',
+]);
+const BUILTIN_RULE_IDS = new Set([
+    'instruction-override',
+    'sensitive-file-target',
+    'third-party-execution',
+    'floating-version',
+    'credential-or-env-probing',
+    'pressure-without-evidence',
+    'unverifiable-authority-claim',
+    'security-framing-conflict',
+]);
+function objectValue(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === 'string');
+}
+function validateStatement(statement, where, errors) {
+    if (!objectValue(statement)) {
+        errors.push(`${where}: must be an object`);
+        return;
+    }
+    if (typeof statement.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(statement.id)) {
+        errors.push(`${where}.id: must be a kebab-case identifier`);
+    }
+    if (!['suppress', 'set-severity'].includes(String(statement.effect))) {
+        errors.push(`${where}.effect: must be suppress or set-severity`);
+    }
+    if (typeof statement.reason !== 'string' || !statement.reason.trim()) {
+        errors.push(`${where}.reason: must be a non-empty string`);
+    }
+    if (statement.signals !== undefined && !stringArray(statement.signals)) {
+        errors.push(`${where}.signals: must be an array of strings`);
+    }
+    if (statement.severity !== undefined
+        && !THREAT_ASSESSMENT_SEVERITIES.includes(statement.severity)) {
+        errors.push(`${where}.severity: unknown severity`);
+    }
+    if (statement.when !== undefined && !objectValue(statement.when)) {
+        errors.push(`${where}.when: must be an object`);
+    }
+    if (statement.riskAcceptance !== undefined) {
+        if (!objectValue(statement.riskAcceptance)
+            || typeof statement.riskAcceptance.acceptedBy !== 'string'
+            || typeof statement.riskAcceptance.rationale !== 'string') {
+            errors.push(`${where}.riskAcceptance: requires acceptedBy and rationale`);
+        }
+    }
+    if (statement.effect === 'suppress') {
+        if (!stringArray(statement.signals) || statement.signals.length === 0) {
+            errors.push(`${where}.signals: suppress statements must name at least one signal`);
+        }
+        const when = objectValue(statement.when) ? statement.when : undefined;
+        if (!when || !Object.values(when).some(value => Array.isArray(value) && value.length > 0)) {
+            errors.push(`${where}.when: suppress statements require at least one narrow condition`);
+        }
+        if (!objectValue(statement.riskAcceptance)
+            || typeof statement.riskAcceptance.acceptedBy !== 'string'
+            || typeof statement.riskAcceptance.rationale !== 'string') {
+            errors.push(`${where}.riskAcceptance: suppress statements require acceptedBy and rationale`);
+        }
+    }
+    if (statement.effect === 'set-severity'
+        && !THREAT_ASSESSMENT_SEVERITIES.includes(statement.severity)) {
+        errors.push(`${where}.severity: set-severity requires a known severity`);
+    }
+}
+/**
+ * Fail-closed validation for project threat-assessment policy. The evaluator
+ * performs the same checks at runtime; config loading validates first so a
+ * malformed policy never degrades into the default or off mode.
+ */
+export function validateThreatAssessmentConfig(value) {
+    const errors = [];
+    if (value === undefined || value === null)
+        return errors;
+    if (!objectValue(value))
+        return ['security.threatAssessment: must be an object'];
+    if (value.schemaVersion !== undefined && value.schemaVersion !== '1') {
+        errors.push("security.threatAssessment.schemaVersion: must be '1'");
+    }
+    if (value.mode !== undefined
+        && !THREAT_ASSESSMENT_MODES.includes(value.mode)) {
+        errors.push('security.threatAssessment.mode: must be off, audit, or enforce');
+    }
+    if (value.defaultProfile !== undefined && typeof value.defaultProfile !== 'string') {
+        errors.push('security.threatAssessment.defaultProfile: must be a string');
+    }
+    if (value.surfaces !== undefined) {
+        if (!objectValue(value.surfaces))
+            errors.push('security.threatAssessment.surfaces: must be an object');
+        else {
+            for (const [surface, entry] of Object.entries(value.surfaces)) {
+                const where = `security.threatAssessment.surfaces.${surface}`;
+                if (!THREAT_ASSESSMENT_SURFACES.includes(surface)) {
+                    errors.push(`${where}: unknown surface`);
+                }
+                if (!objectValue(entry)) {
+                    errors.push(`${where}: must be an object`);
+                    continue;
+                }
+                if (entry.mode !== undefined
+                    && !THREAT_ASSESSMENT_MODES.includes(entry.mode)) {
+                    errors.push(`${where}.mode: must be off, audit, or enforce`);
+                }
+                if (entry.profile !== undefined && typeof entry.profile !== 'string') {
+                    errors.push(`${where}.profile: must be a string`);
+                }
+            }
+        }
+    }
+    const rulePacks = objectValue(value.rulePacks) ? value.rulePacks : {};
+    if (value.rulePacks !== undefined && !objectValue(value.rulePacks)) {
+        errors.push('security.threatAssessment.rulePacks: must be an object');
+    }
+    for (const [name, pack] of Object.entries(rulePacks)) {
+        const where = `security.threatAssessment.rulePacks.${name}`;
+        if (name.startsWith('aiwg:'))
+            errors.push(`${where}: cannot shadow a built-in rule pack`);
+        if (!objectValue(pack) || !Array.isArray(pack.rules)) {
+            errors.push(`${where}.rules: must be an array`);
+            continue;
+        }
+        if (typeof pack.version !== 'string' || !pack.version.trim()) {
+            errors.push(`${where}.version: must be a non-empty string`);
+        }
+        const ids = new Set();
+        pack.rules.forEach((rule, index) => {
+            const ruleWhere = `${where}.rules[${index}]`;
+            if (!objectValue(rule)) {
+                errors.push(`${ruleWhere}: must be an object`);
+                return;
+            }
+            if (typeof rule.id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(rule.id)) {
+                errors.push(`${ruleWhere}.id: must be a kebab-case identifier`);
+            }
+            else if (BUILTIN_RULE_IDS.has(rule.id)) {
+                errors.push(`${ruleWhere}.id: cannot shadow built-in rule '${rule.id}'`);
+            }
+            else if (ids.has(rule.id)) {
+                errors.push(`${ruleWhere}.id: duplicate '${rule.id}'`);
+            }
+            else
+                ids.add(rule.id);
+            if (!THREAT_ASSESSMENT_SEVERITIES.includes(rule.severity)) {
+                errors.push(`${ruleWhere}.severity: unknown severity`);
+            }
+            for (const dimension of ['likelihood', 'impact']) {
+                const dimensionValue = rule[dimension];
+                if (dimensionValue !== undefined
+                    && (!Number.isInteger(dimensionValue) || Number(dimensionValue) < 1 || Number(dimensionValue) > 5)) {
+                    errors.push(`${ruleWhere}.${dimension}: must be an integer from 1 to 5`);
+                }
+            }
+            if (!stringArray(rule.patterns) || rule.patterns.length === 0) {
+                errors.push(`${ruleWhere}.patterns: must be a non-empty array of strings`);
+            }
+            else {
+                rule.patterns.forEach((pattern, patternIndex) => {
+                    const patternWhere = `${ruleWhere}.patterns[${patternIndex}]`;
+                    if (!pattern || pattern.length > 500) {
+                        errors.push(`${patternWhere}: must be 1-500 characters`);
+                        return;
+                    }
+                    try {
+                        new RegExp(pattern, 'imu');
+                    }
+                    catch (error) {
+                        errors.push(`${patternWhere}: invalid regular expression (${error.message})`);
+                    }
+                    if (/\\[1-9]/.test(pattern) || /\(\?<([=!])/.test(pattern)
+                        || /\([^)]*[+*][^)]*\)[+*{]/.test(pattern) || /(?:\.\*){2,}/.test(pattern)) {
+                        errors.push(`${patternWhere}: unsafe regex construct (backreference, lookbehind, or nested unbounded quantifier)`);
+                    }
+                });
+            }
+        });
+    }
+    const profiles = objectValue(value.profiles) ? value.profiles : {};
+    if (value.profiles !== undefined && !objectValue(value.profiles)) {
+        errors.push('security.threatAssessment.profiles: must be an object');
+    }
+    const visit = (name, stack) => {
+        if (stack.includes(name)) {
+            errors.push(`security.threatAssessment.profiles.${name}.extends: cyclic inheritance (${[...stack, name].join(' -> ')})`);
+            return;
+        }
+        const profile = profiles[name];
+        if (!objectValue(profile))
+            return;
+        const parents = profile.extends ?? [];
+        if (!stringArray(parents)) {
+            errors.push(`security.threatAssessment.profiles.${name}.extends: must be an array of strings`);
+            return;
+        }
+        for (const rawParent of parents) {
+            const parent = rawParent.replace(/^aiwg:/, '');
+            if (!BUILTIN_PROFILES.has(parent) && !(parent in profiles)) {
+                errors.push(`security.threatAssessment.profiles.${name}.extends: unknown profile '${rawParent}'`);
+            }
+            else if (parent in profiles)
+                visit(parent, [...stack, name]);
+        }
+    };
+    for (const [name, profile] of Object.entries(profiles)) {
+        const where = `security.threatAssessment.profiles.${name}`;
+        if (BUILTIN_PROFILES.has(name) || name.startsWith('aiwg:')) {
+            errors.push(`${where}: cannot shadow a built-in profile`);
+        }
+        if (!objectValue(profile)) {
+            errors.push(`${where}: must be an object`);
+            continue;
+        }
+        if (profile.mode !== undefined
+            && !THREAT_ASSESSMENT_MODES.includes(profile.mode)) {
+            errors.push(`${where}.mode: must be off, audit, or enforce`);
+        }
+        if (profile.version !== undefined && (typeof profile.version !== 'string' || !profile.version.trim())) {
+            errors.push(`${where}.version: must be a non-empty string`);
+        }
+        if (profile.ruleSets !== undefined && !stringArray(profile.ruleSets)) {
+            errors.push(`${where}.ruleSets: must be an array of strings`);
+        }
+        else {
+            for (const pack of (profile.ruleSets ?? [])) {
+                if (!BUILTIN_RULE_PACKS.has(pack) && !(pack in rulePacks)) {
+                    errors.push(`${where}.ruleSets: unavailable rule pack '${pack}'`);
+                }
+            }
+        }
+        if (profile.thresholds !== undefined) {
+            if (!objectValue(profile.thresholds))
+                errors.push(`${where}.thresholds: must be an object`);
+            else {
+                for (const [action, severity] of Object.entries(profile.thresholds)) {
+                    if (!['flag', 'requireAuthorization', 'reject'].includes(action)
+                        || !THREAT_ASSESSMENT_SEVERITIES.includes(severity)) {
+                        errors.push(`${where}.thresholds.${action}: unknown threshold or severity`);
+                    }
+                }
+            }
+        }
+        if (profile.statements !== undefined) {
+            if (!Array.isArray(profile.statements))
+                errors.push(`${where}.statements: must be an array`);
+            else
+                profile.statements.forEach((statement, index) => validateStatement(statement, `${where}.statements[${index}]`, errors));
+        }
+        visit(name, []);
+    }
+    if (value.statements !== undefined) {
+        if (!Array.isArray(value.statements))
+            errors.push('security.threatAssessment.statements: must be an array');
+        else
+            value.statements.forEach((statement, index) => validateStatement(statement, `security.threatAssessment.statements[${index}]`, errors));
+    }
+    const defaultProfile = typeof value.defaultProfile === 'string' ? value.defaultProfile : 'balanced';
+    if (!BUILTIN_PROFILES.has(defaultProfile) && !(defaultProfile in profiles)) {
+        errors.push(`security.threatAssessment.defaultProfile: unknown profile '${defaultProfile}'`);
+    }
+    return Array.from(new Set(errors));
+}
+export function defaultThreatAssessmentConfig() {
+    return {
+        schemaVersion: '1',
+        mode: 'enforce',
+        defaultProfile: 'balanced',
+    };
+}
+//# sourceMappingURL=threat-assessment-config.js.map

package/dist/src/sessions/adapters/claude.js

@@ -16,6 +16,10 @@ const ClaudeRecordSchema = z.object({
     timestamp: z.string().datetime({ offset: true }).optional(),
     cwd: z.string().optional(),
     gitBranch: z.string().optional(),
+    parentSessionId: z.string().min(1).optional(),
+    isSidechain: z.boolean().optional(),
+    agentId: z.string().min(1).optional(),
+    slug: z.string().min(1).optional(),
     version: z.string().optional(),
     schemaVersion: z.string().optional(),
     message: z.object({
@@ -138,13 +142,11 @@ function normalizeTranscript(records, locator) {
             throw new SessionContractError('MALFORMED_SOURCE', 'Claude transcript record is malformed');
         }
         const value = parsed.data;
-        const nativeSessionId = value.sessionId ?? value.session_id ?? filenameSessionId;
-        if ((value.sessionId || value.session_id) && nativeSessionId !== filenameSessionId) {
-            throw new SessionContractError('SCHEMA_DRIFT', 'Claude transcript session identity differs from its documented filename identity');
-        }
+        const embeddedSessionId = value.sessionId ?? value.session_id;
+        const nativeSessionId = embeddedSessionId ?? filenameSessionId;
         const blocks = messageBlocks(value);
         if (blocks.length === 0) {
-            output.push(providerRecord(value, record, nativeSessionId, {
+            output.push(providerRecord(value, record, nativeSessionId, filenameSessionId, {
                 kind: `claude.${value.type}`,
                 text: '',
                 opaque: true,
@@ -153,7 +155,7 @@ function normalizeTranscript(records, locator) {
             continue;
         }
         for (const [blockIndex, block] of blocks.entries()) {
-            output.push(providerRecord(value, record, nativeSessionId, {
+            output.push(providerRecord(value, record, nativeSessionId, filenameSessionId, {
                 kind: block.kind,
                 text: block.text,
                 blockIndex,
@@ -184,11 +186,24 @@ function normalizeHooks(records) {
             participant: 'claude',
             model: hook.model,
             occurredAt: hook.timestamp,
+            activityBoundary: hook.hook_event_name === 'SessionEnd'
+                ? 'end'
+                : hook.source === 'resume'
+                    ? 'resume'
+                    : hook.source === 'compact'
+                        ? 'continuation'
+                        : undefined,
+            activityBoundaryBasis: hook.hook_event_name === 'SessionEnd' || hook.source
+                ? `claude-hook:${hook.hook_event_name}:${hook.source ?? 'none'}`
+                : undefined,
+            activityBoundaryConfidence: hook.hook_event_name === 'SessionEnd' || hook.source
+                ? 'high'
+                : undefined,
             text: '',
             rawReference: { locatorClass: 'claude-hook-jsonl', offset: record.byteOffset },
             extensions: {
                 hookEventName: hook.hook_event_name,
-                lifecycle: hook.hook_event_name === 'SessionEnd' ? 'complete' : 'active',
+                ...(hook.hook_event_name === 'SessionEnd' ? { lifecycle: 'complete' } : {}),
                 startSource: hook.source,
                 model: hook.model,
                 reason: hook.reason,
@@ -201,7 +216,7 @@ function normalizeHooks(records) {
     }
     return { records: output, complete };
 }
-function providerRecord(value, record, nativeSessionId, block) {
+function providerRecord(value, record, nativeSessionId, sourceArtifactSessionId, block) {
     const nativeBase = value.uuid ?? value.message?.id;
     const nativeEventId = block.blockNativeId
         ?? (nativeBase ? `${nativeBase}:${block.blockIndex ?? 0}` : undefined);
@@ -221,6 +236,18 @@ function providerRecord(value, record, nativeSessionId, block) {
             productVersion: value.version,
             workspace: { cwdClass: value.cwd ? '<workspace>' : undefined, gitBranch: value.gitBranch },
             provenance: { acquisition: 'claude-transcript', schema: CLAUDE_TRANSCRIPT_SCHEMA_VERSION },
+            transcriptFamily: {
+                sourceArtifactSessionId,
+                nativeSessionId,
+                identityRelation: nativeSessionId === sourceArtifactSessionId ? 'self' : 'related',
+                parentUuid: value.parentUuid,
+                parentSessionId: value.parentSessionId,
+                gitBranch: value.gitBranch,
+                continuation: record.sequence > 0 && value.parentUuid !== null,
+                subagent: value.isSidechain === true || Boolean(value.agentId),
+                agentId: value.agentId,
+                agentSlug: value.slug,
+            },
             opaque: block.opaque,
             unknownFields: {
                 ...unknownFields(value, TRANSCRIPT_KEYS),
@@ -348,7 +375,8 @@ function unknownFields(value, known) {
 }
 const TRANSCRIPT_KEYS = new Set([
     'type', 'subtype', 'uuid', 'parentUuid', 'sessionId', 'session_id',
-    'timestamp', 'cwd', 'gitBranch', 'version', 'schemaVersion', 'message',
+    'timestamp', 'cwd', 'gitBranch', 'parentSessionId', 'isSidechain',
+    'agentId', 'slug', 'version', 'schemaVersion', 'message',
 ]);
 const HOOK_KEYS = new Set([
     'session_id', 'transcript_path', 'cwd', 'hook_event_name', 'permission_mode',

package/dist/src/sessions/adapters/codex.js

@@ -83,7 +83,8 @@ export class CodexSessionAdapter {
         let mode = isAppServerLocator(source.locator)
             ? 'app-server' : null;
         let schemaVersion = null;
-        let nativeSessionId = rolloutIdFromFilename(source.locator);
+        const sourceArtifactSessionId = rolloutIdFromFilename(source.locator);
+        let nativeSessionId = sourceArtifactSessionId;
         const identities = new Map();
         let outputIndex = 0;
         let sawRecord = false;
@@ -118,15 +119,12 @@ export class CodexSessionAdapter {
                     if (!declaredId) {
                         throw new SessionContractError('MALFORMED_SOURCE', 'Codex session metadata is missing its id');
                     }
-                    if (nativeSessionId && nativeSessionId !== declaredId) {
-                        throw new SessionContractError('SCHEMA_DRIFT', 'Codex rollout session identity differs from its filename identity');
-                    }
                     nativeSessionId = declaredId;
                 }
                 if (!nativeSessionId) {
                     throw new SessionContractError('MALFORMED_SOURCE', 'Codex rollout has no session identity before content records');
                 }
-                normalized = [rolloutRecord(nativeSessionId, parsed.data, payload, line)];
+                normalized = [rolloutRecord(nativeSessionId, parsed.data, payload, line, sourceArtifactSessionId)];
             }
             for (const record of normalized) {
                 if (outputIndex++ >= start)
@@ -188,6 +186,15 @@ function normalizeAppServer(input) {
                 sequence: line.sequence * 1_000,
                 kind: event === 'compacted' ? 'summary' : 'codex.lifecycle',
                 role: 'system',
+                activityBoundary: event === 'unarchived'
+                    ? 'resume'
+                    : event === 'compacted'
+                        ? 'continuation'
+                        : event === 'archived' || event === 'deleted'
+                            ? 'end'
+                            : undefined,
+                activityBoundaryBasis: `codex-app-server:${event}`,
+                activityBoundaryConfidence: event === 'status-changed' ? 'medium' : 'high',
                 text: '',
                 rawReference: { locatorClass: 'codex-app-server-jsonl', offset: line.byteOffset },
                 extensions: {
@@ -201,7 +208,8 @@ function normalizeAppServer(input) {
     return { records, complete: complete && !sawActive };
 }
 function normalizeRollout(input, locator) {
-    let nativeSessionId = rolloutIdFromFilename(locator);
+    const sourceArtifactSessionId = rolloutIdFromFilename(locator);
+    let nativeSessionId = sourceArtifactSessionId;
     const records = [];
     for (const line of input) {
         const parsed = RolloutEnvelopeSchema.safeParse(line.value);
@@ -215,15 +223,12 @@ function normalizeRollout(input, locator) {
             if (!declaredId) {
                 throw new SessionContractError('MALFORMED_SOURCE', 'Codex session metadata is missing its id');
             }
-            if (nativeSessionId && nativeSessionId !== declaredId) {
-                throw new SessionContractError('SCHEMA_DRIFT', 'Codex rollout session identity differs from its filename identity');
-            }
             nativeSessionId = declaredId;
         }
         if (!nativeSessionId) {
             throw new SessionContractError('MALFORMED_SOURCE', 'Codex rollout has no session identity before content records');
         }
-        records.push(rolloutRecord(nativeSessionId, envelope, payload, line));
+        records.push(rolloutRecord(nativeSessionId, envelope, payload, line, sourceArtifactSessionId));
     }
     return { records, complete: false };
 }
@@ -281,7 +286,7 @@ function threadItem(thread, turn, item, line, turnIndex, itemIndex) {
         },
     };
 }
-function rolloutRecord(nativeSessionId, envelope, payload, line) {
+function rolloutRecord(nativeSessionId, envelope, payload, line, sourceArtifactSessionId) {
     const nativeId = stringValue(payload.id)
         ?? stringValue(payload.call_id)
         ?? `${envelope.type}:${line.sequence}`;
@@ -298,6 +303,21 @@ function rolloutRecord(nativeSessionId, envelope, payload, line) {
         toolCallId: stringValue(payload.call_id),
         model: stringValue(payload.model),
         occurredAt: envelope.timestamp,
+        activityBoundary: envelope.type === 'compacted'
+            ? 'continuation'
+            : envelope.type === 'event_msg'
+                && stringValue(payload.type) === 'task_complete'
+                ? 'end'
+                : undefined,
+        activityBoundaryBasis: envelope.type === 'compacted'
+            ? 'codex-rollout:compacted'
+            : envelope.type === 'event_msg' && stringValue(payload.type) === 'task_complete'
+                ? 'codex-rollout:task-complete'
+                : undefined,
+        activityBoundaryConfidence: envelope.type === 'compacted'
+            || (envelope.type === 'event_msg' && stringValue(payload.type) === 'task_complete')
+            ? 'high'
+            : undefined,
         text: rolloutText(payload),
         rawReference: { locatorClass: 'codex-rollout-jsonl', offset: line.byteOffset },
         extensions: {
@@ -310,6 +330,13 @@ function rolloutRecord(nativeSessionId, envelope, payload, line) {
                 : undefined,
             productVersion: stringValue(payload.cli_version),
             provenance: { acquisition: 'codex-rollout', durableReplay: true },
+            transcriptFamily: {
+                sourceArtifactSessionId,
+                nativeSessionId,
+                identityRelation: !sourceArtifactSessionId || sourceArtifactSessionId === nativeSessionId
+                    ? 'self'
+                    : 'related',
+            },
             opaque: !KNOWN_ROLLOUT_TYPES.has(envelope.type),
             unknownFields: unknownFields(payload, ROLLOUT_KEYS),
         },