@aiwg/cli 2026.7.20 → 2026.7.23

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

@@ -0,0 +1,385 @@
+import { opendir } from 'node:fs/promises';
+import { basename, extname, resolve } from 'node:path';
+import { z } from 'zod';
+import { SessionContractError, assertSupportedSchemaMajor, sha256, } from '../contracts.js';
+import { redactSourceLocator } from '../discovery.js';
+import { readBoundedJsonLines, streamBoundedJsonLines, } from '../readers.js';
+export const CLAUDE_ADAPTER_VERSION = '1.0.0';
+export const CLAUDE_TRANSCRIPT_SCHEMA_VERSION = '1.0.0';
+const ClaudeRecordSchema = z.object({
+    type: z.string().min(1),
+    subtype: z.string().optional(),
+    uuid: z.string().min(1).optional(),
+    parentUuid: z.string().min(1).nullable().optional(),
+    sessionId: z.string().min(1).optional(),
+    session_id: z.string().min(1).optional(),
+    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({
+        id: z.string().min(1).optional(),
+        role: z.string().min(1).optional(),
+        content: z.union([z.string(), z.array(z.unknown())]).optional(),
+    }).passthrough().optional(),
+}).passthrough();
+const ClaudeHookSchema = z.object({
+    session_id: z.string().min(1),
+    transcript_path: z.string().min(1),
+    cwd: z.string().min(1),
+    hook_event_name: z.string().min(1),
+    permission_mode: z.string().optional(),
+    source: z.enum(['startup', 'resume', 'clear', 'compact']).optional(),
+    model: z.string().optional(),
+    reason: z.string().optional(),
+    schemaVersion: z.string().optional(),
+    timestamp: z.string().datetime({ offset: true }).optional(),
+}).passthrough();
+export class ClaudeSessionAdapter {
+    limits;
+    discoveryLimits;
+    provider = 'claude';
+    adapterVersion = CLAUDE_ADAPTER_VERSION;
+    disposition = 'implemented';
+    supportedOperations = ['discover', 'inspect', 'stream'];
+    acquisitionModes = ['jsonl', 'hook'];
+    constructor(limits, discoveryLimits = { maxDepth: 8, maxFiles: 10_000 }) {
+        this.limits = limits;
+        this.discoveryLimits = discoveryLimits;
+    }
+    async *discover(scope) {
+        if (scope.allowedRoots.length === 0) {
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'Claude discovery requires an explicitly authorized projects or hook root');
+        }
+        let emitted = 0;
+        for (const root of [...scope.allowedRoots].sort()) {
+            for await (const locator of discoverJsonl(resolve(root), this.discoveryLimits.maxDepth)) {
+                emitted += 1;
+                if (emitted > this.discoveryLimits.maxFiles) {
+                    throw new SessionContractError('RESOURCE_LIMIT_EXCEEDED', 'Claude source discovery exceeded the authorized file limit');
+                }
+                yield {
+                    provider: 'claude',
+                    locator,
+                    locatorClass: isHookLocator(locator) ? 'claude-hook-jsonl' : 'claude-transcript-jsonl',
+                };
+            }
+        }
+    }
+    async inspect(source) {
+        const parsed = await this.readSource(source);
+        return {
+            sourceSchemaVersion: parsed.schemaVersion,
+            consistency: parsed.consistency,
+            operationalState: 'available',
+        };
+    }
+    async *stream(source, cursor) {
+        const start = parseRecordCursor(cursor?.value);
+        const input = await streamBoundedJsonLines({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, { consistency: 'provisional', limits: this.limits });
+        const hookSource = isHookLocator(source.locator);
+        let outputIndex = 0;
+        let sawRecord = false;
+        let schemaVersion = null;
+        for await (const line of input) {
+            sawRecord = true;
+            const value = line.value;
+            const currentSchema = typeof value.schemaVersion === 'string'
+                ? value.schemaVersion : CLAUDE_TRANSCRIPT_SCHEMA_VERSION;
+            if (schemaVersion && currentSchema !== schemaVersion) {
+                throw new SessionContractError('SCHEMA_DRIFT', 'Claude source declares mixed schema versions');
+            }
+            schemaVersion = currentSchema;
+            assertSupportedSchemaMajor(schemaVersion);
+            const normalized = hookSource || isHookRecord(line.value)
+                ? normalizeHooks([line]).records
+                : normalizeTranscript([line], source.locator).records;
+            for (const record of normalized) {
+                if (outputIndex++ >= start)
+                    yield record;
+            }
+        }
+        if (!sawRecord && !input.incompleteTail) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Claude JSONL source is empty');
+        }
+    }
+    async readSource(source) {
+        const result = await readBoundedJsonLines({
+            selectedPath: source.locator,
+            allowedRoots: source.authorizedScope.allowedRoots,
+        }, { consistency: 'provisional', limits: this.limits });
+        if (result.records.length === 0 && !result.incompleteTail) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Claude JSONL source is empty');
+        }
+        const hookSource = isHookLocator(source.locator)
+            || result.records.some((record) => isHookRecord(record.value));
+        const normalized = hookSource
+            ? normalizeHooks(result.records)
+            : normalizeTranscript(result.records, source.locator);
+        const schemaVersion = declaredSchemaVersion(result.records);
+        assertSupportedSchemaMajor(schemaVersion);
+        return {
+            records: normalized.records,
+            schemaVersion,
+            consistency: normalized.complete ? 'complete' : 'provisional',
+        };
+    }
+}
+function normalizeTranscript(records, locator) {
+    const filenameSessionId = basename(locator, extname(locator));
+    const output = [];
+    for (const record of records) {
+        const parsed = ClaudeRecordSchema.safeParse(record.value);
+        if (!parsed.success) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Claude transcript record is malformed');
+        }
+        const value = parsed.data;
+        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, filenameSessionId, {
+                kind: `claude.${value.type}`,
+                text: '',
+                opaque: true,
+                unknownFields: unknownFields(value, TRANSCRIPT_KEYS),
+            }));
+            continue;
+        }
+        for (const [blockIndex, block] of blocks.entries()) {
+            output.push(providerRecord(value, record, nativeSessionId, filenameSessionId, {
+                kind: block.kind,
+                text: block.text,
+                blockIndex,
+                blockNativeId: block.nativeId,
+                opaque: block.opaque,
+                unknownFields: block.unknownFields,
+            }));
+        }
+    }
+    return { records: output, complete: false };
+}
+function normalizeHooks(records) {
+    const output = [];
+    let complete = false;
+    for (const record of records) {
+        const parsed = ClaudeHookSchema.safeParse(record.value);
+        if (!parsed.success) {
+            throw new SessionContractError('MALFORMED_SOURCE', 'Claude lifecycle hook record is malformed');
+        }
+        const hook = parsed.data;
+        complete ||= hook.hook_event_name === 'SessionEnd';
+        output.push({
+            nativeSessionId: hook.session_id,
+            nativeEventId: hookNativeId(hook, record.sequence),
+            sequence: record.sequence,
+            kind: 'lifecycle-hook',
+            role: 'system',
+            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,
+                ...(hook.hook_event_name === 'SessionEnd' ? { lifecycle: 'complete' } : {}),
+                startSource: hook.source,
+                model: hook.model,
+                reason: hook.reason,
+                permissionMode: hook.permission_mode,
+                workspace: { cwdClass: '<workspace>', transcript: redactSourceLocator(hook.transcript_path) },
+                provenance: { acquisition: 'claude-hook', schema: CLAUDE_TRANSCRIPT_SCHEMA_VERSION },
+                unknownFields: unknownFields(hook, HOOK_KEYS),
+            },
+        });
+    }
+    return { records: output, complete };
+}
+function providerRecord(value, record, nativeSessionId, sourceArtifactSessionId, block) {
+    const nativeBase = value.uuid ?? value.message?.id;
+    const nativeEventId = block.blockNativeId
+        ?? (nativeBase ? `${nativeBase}:${block.blockIndex ?? 0}` : undefined);
+    return {
+        nativeSessionId,
+        nativeEventId,
+        sequence: record.sequence * 1_000 + (block.blockIndex ?? 0),
+        kind: block.kind,
+        role: value.message?.role,
+        occurredAt: value.timestamp,
+        text: block.text,
+        rawReference: { locatorClass: 'claude-transcript-jsonl', offset: record.byteOffset },
+        extensions: {
+            transcriptType: value.type,
+            transcriptSubtype: value.subtype,
+            parentUuid: value.parentUuid,
+            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),
+                ...block.unknownFields,
+            },
+        },
+    };
+}
+function messageBlocks(value) {
+    const content = value.message?.content;
+    if (typeof content === 'string') {
+        return [{ kind: 'message', text: content, opaque: false, unknownFields: {} }];
+    }
+    if (!Array.isArray(content))
+        return [];
+    return content.map((input) => {
+        if (!input || typeof input !== 'object' || Array.isArray(input)) {
+            return { kind: 'claude.unknown-block', text: '', opaque: true, unknownFields: { value: input } };
+        }
+        const block = input;
+        const type = typeof block.type === 'string' ? block.type : 'unknown';
+        if (type === 'text' && typeof block.text === 'string') {
+            return {
+                kind: 'message', text: block.text, opaque: false,
+                unknownFields: unknownFields(block, new Set(['type', 'text'])),
+            };
+        }
+        if (type === 'tool_use') {
+            return {
+                kind: 'tool-call',
+                text: typeof block.name === 'string' ? block.name : '',
+                nativeId: typeof block.id === 'string' ? block.id : undefined,
+                opaque: false,
+                unknownFields: unknownFields(block, new Set(['type', 'id', 'name', 'input'])),
+            };
+        }
+        if (type === 'tool_result') {
+            return {
+                kind: 'tool-result',
+                text: extractToolResultText(block.content),
+                nativeId: typeof block.tool_use_id === 'string' ? block.tool_use_id : undefined,
+                opaque: false,
+                unknownFields: unknownFields(block, new Set(['type', 'tool_use_id', 'content', 'is_error'])),
+            };
+        }
+        return {
+            kind: `claude.${type}`,
+            text: '',
+            opaque: true,
+            unknownFields: { ...block },
+        };
+    });
+}
+function extractToolResultText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!Array.isArray(value))
+        return '';
+    return value
+        .filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        .map((item) => typeof item.text === 'string' ? item.text : '')
+        .filter(Boolean)
+        .join('\n');
+}
+async function* discoverJsonl(root, maxDepth) {
+    const pending = [{ path: root, depth: 0 }];
+    while (pending.length > 0) {
+        const current = pending.shift();
+        let directory;
+        try {
+            directory = await opendir(current.path);
+        }
+        catch {
+            throw new SessionContractError('SOURCE_NOT_AUTHORIZED', 'authorized Claude source root is inaccessible');
+        }
+        const childDirectories = [];
+        const files = [];
+        for await (const entry of directory) {
+            const path = resolve(current.path, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory() && current.depth < maxDepth)
+                childDirectories.push(path);
+            else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+                files.push(path);
+        }
+        for (const file of files.sort())
+            yield file;
+        for (const path of childDirectories.sort())
+            pending.push({ path, depth: current.depth + 1 });
+    }
+}
+function declaredSchemaVersion(records) {
+    const declared = records
+        .map((record) => {
+        if (!record.value || typeof record.value !== 'object' || Array.isArray(record.value))
+            return undefined;
+        return record.value.schemaVersion;
+    })
+        .find((value) => typeof value === 'string');
+    return declared ?? CLAUDE_TRANSCRIPT_SCHEMA_VERSION;
+}
+function parseRecordCursor(value) {
+    if (value === undefined || value === '')
+        return 0;
+    if (!/^\d+$/.test(value))
+        throw new SessionContractError('SCHEMA_DRIFT', 'Claude record cursor is invalid');
+    return Number(value);
+}
+function hookNativeId(hook, sequence) {
+    return sha256([
+        hook.session_id, hook.hook_event_name, hook.source ?? '',
+        hook.timestamp ?? '', hook.reason ?? '', sequence,
+    ].join('\0'));
+}
+function isHookLocator(locator) {
+    return /\.hooks?\.jsonl$/i.test(locator);
+}
+function isHookRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+        && typeof value.hook_event_name === 'string';
+}
+function unknownFields(value, known) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !known.has(key)));
+}
+const TRANSCRIPT_KEYS = new Set([
+    'type', 'subtype', 'uuid', 'parentUuid', 'sessionId', 'session_id',
+    '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',
+    'source', 'model', 'reason', 'schemaVersion', 'timestamp',
+]);
+//# sourceMappingURL=claude.js.map