@aiwg/cli 2026.8.26 → 2026.8.28

package/dist/src/governance/redaction.js

@@ -0,0 +1,324 @@
+import { createHmac } from 'node:crypto';
+import { Transform } from 'node:stream';
+import { TextDecoder } from 'node:util';
+export class RedactionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'RedactionError';
+    }
+}
+const DEFAULT_LIMITS = {
+    maxInputBytes: 8 * 1024 * 1024,
+    maxDepth: 32,
+    maxNodes: 100_000,
+    maxObjectKeys: 10_000,
+    maxArrayItems: 100_000,
+};
+const BUILTIN_SENSITIVE_KEY = /(?:^|[_-])(?:authorization|auth[_-]?header|cookie|set[_-]?cookie|credential|password|passwd|secret|token|api[_-]?key|private[_-]?key|connection[_-]?string|client[_-]?secret)(?:$|[_-])/i;
+const BUILTIN_PATTERNS = [
+    {
+        id: 'private-key',
+        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/g,
+    },
+    {
+        id: 'authorization-header',
+        pattern: /(\bAuthorization\s*:\s*)([^\r\n]+)/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'cookie-header',
+        pattern: /(\b(?:Cookie|Set-Cookie)\s*:\s*)([^\r\n]+)/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'url-query-secret',
+        pattern: /([?&](?:access[_-]?token|refresh[_-]?token|api[_-]?key|token|secret|password|passwd|signature|sig)=)([^&#\s]+)/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'sensitive-assignment',
+        pattern: /((?:^|[\s,{])["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|client[_-]?secret|credential)["']?\s*(?:[:=]|\s+)\s*")([^"\r\n]*)(")/gim,
+        preservePrefix: true,
+        preserveSuffix: true,
+    },
+    {
+        id: 'sensitive-assignment',
+        pattern: /((?:^|[\s,{])["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|client[_-]?secret|credential)["']?\s*(?:[:=]|\s+)\s*')([^'\r\n]*)(')/gim,
+        preservePrefix: true,
+        preserveSuffix: true,
+    },
+    {
+        id: 'sensitive-assignment',
+        pattern: /((?:^|[\s,{])["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|client[_-]?secret|credential)["']?\s*(?:[:=]|\s+)\s*)([^\s"',;}\]]{4,})/gim,
+        preservePrefix: true,
+    },
+    {
+        id: 'environment-secret',
+        pattern: /(\b[A-Z][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|PRIVATE_KEY)\s*=\s*)(?:"[^"]+"|'[^']+'|[^\s]+)/g,
+        preservePrefix: true,
+    },
+    {
+        id: 'provider-token',
+        pattern: /\b(?:sk-(?:proj-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA)[A-Za-z0-9._~+/=-]{6,}\b/g,
+    },
+    {
+        id: 'bearer-token',
+        pattern: /(\bBearer\s+)([A-Za-z0-9._~+/=-]{6,})\b/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'connection-string',
+        pattern: /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqps?):\/\/[^\s"'<>]+/gi,
+    },
+    {
+        id: 'url-userinfo',
+        pattern: /(https?:\/\/[^/\s:@]+:)([^/\s@]+)(@[^\s"'<>]+)/gi,
+    },
+];
+function resolvedLimits(options) {
+    const limits = { ...DEFAULT_LIMITS, ...(options.limits ?? {}) };
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new RedactionError('LIMIT_EXCEEDED', `${name} must be a positive safe integer`);
+        }
+    }
+    return limits;
+}
+function validatePatternSource(pattern) {
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(pattern.id)) {
+        throw new RedactionError('INVALID_PATTERN', 'organization redaction pattern IDs must be lowercase stable identifiers');
+    }
+    if (pattern.pattern.length === 0 || pattern.pattern.length > 512) {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' must contain 1-512 characters`);
+    }
+    if (/\\[1-9]|\(\?<[=!]|\([^)]*[+*][^)]*\)[+*{]/.test(pattern.pattern)) {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' uses a disallowed high-risk construct`);
+    }
+    const requestedFlags = pattern.flags ?? 'g';
+    if (/[^gimsuy]/.test(requestedFlags)) {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' has unsupported flags`);
+    }
+    const flags = requestedFlags.includes('g') ? requestedFlags : `${requestedFlags}g`;
+    try {
+        return new RegExp(pattern.pattern, flags);
+    }
+    catch {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' is not a valid regular expression`);
+    }
+}
+function fingerprint(value, key) {
+    if (key === undefined)
+        return undefined;
+    return `hmac-sha256:${createHmac('sha256', key).update(value).digest('hex').slice(0, 16)}`;
+}
+function marker(classification, value, options) {
+    const length = Buffer.byteLength(value);
+    const valueFingerprint = fingerprint(value, options.fingerprintKey);
+    const attributes = [
+        options.includeLength === false ? null : `len=${length}`,
+        valueFingerprint ? `fp=${valueFingerprint}` : null,
+    ].filter((part) => part !== null);
+    return {
+        marker: `[REDACTED:${classification}${attributes.length ? `;${attributes.join(';')}` : ''}]`,
+        finding: {
+            class: classification,
+            ...(options.includeLength === false ? {} : { length }),
+            ...(valueFingerprint ? { fingerprint: valueFingerprint } : {}),
+        },
+    };
+}
+function applyPattern(input, definition, options, findings) {
+    definition.pattern.lastIndex = 0;
+    return input.replace(definition.pattern, (...args) => {
+        const full = String(args[0]);
+        if (definition.id === 'url-userinfo') {
+            const prefix = String(args[1]);
+            const secret = String(args[2]);
+            const suffix = String(args[3]);
+            const redacted = marker(definition.id, secret, options);
+            findings.push(redacted.finding);
+            return `${prefix}${redacted.marker}${suffix}`;
+        }
+        if (definition.preservePrefix) {
+            const prefix = String(args[1]);
+            const secret = String(args[2] ?? full.slice(prefix.length));
+            if (secret.startsWith('[REDACTED:'))
+                return full;
+            const redacted = marker(definition.id, secret, options);
+            findings.push(redacted.finding);
+            const suffix = definition.preserveSuffix ? String(args[3] ?? '') : '';
+            return `${prefix}${redacted.marker}${suffix}`;
+        }
+        const redacted = marker(definition.id, full, options);
+        findings.push(redacted.finding);
+        return redacted.marker;
+    });
+}
+function decodedSecretClass(value) {
+    if (value.length < 24 || value.length > 16 * 1024 || value.length % 4 === 1)
+        return null;
+    try {
+        const decoded = Buffer.from(value, 'base64').toString('utf8');
+        if (!decoded || decoded.includes('\uFFFD'))
+            return null;
+        if (/-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/.test(decoded))
+            return 'encoded-private-key';
+        if (/(?:api[_-]?key|token|password|passwd|secret|authorization)\s*[:=]/i.test(decoded))
+            return 'encoded-secret';
+        if (/(?:sk-(?:proj-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA)[A-Za-z0-9._~+/=-]{6,}/.test(decoded))
+            return 'encoded-secret';
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Redact secret-bearing values from a complete text value. */
+export function redactText(input, options = {}) {
+    const limits = resolvedLimits(options);
+    if (Buffer.byteLength(input) > limits.maxInputBytes) {
+        throw new RedactionError('LIMIT_EXCEEDED', 'text exceeds the configured redaction byte limit');
+    }
+    const findings = [];
+    let text = input;
+    for (const definition of BUILTIN_PATTERNS) {
+        text = applyPattern(text, definition, options, findings);
+    }
+    for (const configured of options.organizationPatterns ?? []) {
+        const definition = {
+            id: `organization-${configured.id}`,
+            pattern: validatePatternSource(configured),
+        };
+        text = applyPattern(text, definition, options, findings);
+    }
+    text = text.replace(/\b[A-Za-z0-9+/]{24,}={0,2}\b/g, (candidate) => {
+        const classification = decodedSecretClass(candidate);
+        if (!classification)
+            return candidate;
+        const redacted = marker(classification, candidate, options);
+        findings.push(redacted.finding);
+        return redacted.marker;
+    });
+    return { text, sensitivity: findings.length ? 'sensitive' : 'none', findings };
+}
+function sensitiveKey(key, options) {
+    if (BUILTIN_SENSITIVE_KEY.test(key))
+        return true;
+    let matched = false;
+    for (const source of options.sensitiveKeyPatterns ?? []) {
+        if (source.length === 0 || source.length > 256) {
+            throw new RedactionError('INVALID_PATTERN', 'sensitive key patterns must contain 1-256 characters');
+        }
+        try {
+            if (new RegExp(source, 'i').test(key))
+                matched = true;
+        }
+        catch {
+            throw new RedactionError('INVALID_PATTERN', 'a sensitive key pattern is not a valid regular expression');
+        }
+    }
+    return matched;
+}
+/** Recursively redact nested JSON/YAML-compatible values while preserving shape and field names. */
+export function redactStructured(input, options = {}) {
+    const limits = resolvedLimits(options);
+    const findings = [];
+    const active = new WeakSet();
+    let nodes = 0;
+    const visit = (value, path, depth, key) => {
+        nodes += 1;
+        if (nodes > limits.maxNodes || depth > limits.maxDepth) {
+            throw new RedactionError('LIMIT_EXCEEDED', 'structured value exceeds configured redaction traversal limits');
+        }
+        if (key !== undefined && sensitiveKey(key, options)) {
+            const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+            const redacted = marker('sensitive-field', serialized ?? String(value), options);
+            findings.push({ ...redacted.finding, path });
+            return redacted.marker;
+        }
+        if (value === null || typeof value === 'boolean' || typeof value === 'number')
+            return value;
+        if (typeof value === 'bigint')
+            return String(value);
+        if (typeof value === 'string') {
+            const redacted = redactText(value, options);
+            findings.push(...redacted.findings.map((finding) => ({ ...finding, path })));
+            return redacted.text;
+        }
+        if (typeof value !== 'object') {
+            throw new RedactionError('UNSUPPORTED_VALUE', `unsupported structured value at ${path}`);
+        }
+        if (active.has(value))
+            throw new RedactionError('UNSUPPORTED_VALUE', `circular structured value at ${path}`);
+        active.add(value);
+        try {
+            if (Array.isArray(value)) {
+                if (value.length > limits.maxArrayItems) {
+                    throw new RedactionError('LIMIT_EXCEEDED', `array exceeds configured item limit at ${path}`);
+                }
+                return value.map((item, index) => visit(item, `${path}/${index}`, depth + 1));
+            }
+            const entries = Object.entries(value);
+            if (entries.length > limits.maxObjectKeys) {
+                throw new RedactionError('LIMIT_EXCEEDED', `object exceeds configured key limit at ${path}`);
+            }
+            return Object.fromEntries(entries.map(([childKey, child]) => [
+                childKey,
+                visit(child, `${path}/${childKey.replaceAll('~', '~0').replaceAll('/', '~1')}`, depth + 1, childKey),
+            ]));
+        }
+        finally {
+            active.delete(value);
+        }
+    };
+    const value = visit(input, '', 0);
+    return { value, sensitivity: findings.length ? 'sensitive' : 'none', findings };
+}
+/**
+ * A bounded streaming interface. It buffers one logical output value and emits
+ * only after full-value sanitization, so secrets split across chunks cannot
+ * escape. Exceeding the configured limit fails without emitting partial data.
+ */
+export class RedactionTransform extends Transform {
+    options;
+    chunks = [];
+    bytes = 0;
+    limits;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        this.limits = resolvedLimits(options);
+    }
+    _transform(chunk, encoding, callback) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+        this.bytes += value.length;
+        if (this.bytes > this.limits.maxInputBytes) {
+            callback(new RedactionError('LIMIT_EXCEEDED', 'stream exceeds the configured redaction byte limit'));
+            return;
+        }
+        this.chunks.push(value);
+        callback();
+    }
+    _flush(callback) {
+        try {
+            let source;
+            try {
+                source = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(this.chunks));
+            }
+            catch {
+                throw new RedactionError('INVALID_UTF8', 'stream is not valid UTF-8');
+            }
+            this.push(redactText(source, this.options).text);
+            callback();
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+}
+export function createRedactionTransform(options = {}) {
+    return new RedactionTransform(options);
+}
+//# sourceMappingURL=redaction.js.map

package/dist/src/governance/retention.js

@@ -0,0 +1,274 @@
+import { createHash, randomUUID } from 'node:crypto';
+export const DEFAULT_RETENTION_RULES = [
+    { id: 'raw-audit-short-lived', version: '1', category: 'raw-audit', tier: 'raw', duration: 'P7D', action: 'delete' },
+    { id: 'identity-audit-durable', version: '1', category: 'identity-audit', tier: 'durable', duration: 'P30D', action: 'summarize' },
+    { id: 'network-inventory-durable', version: '1', category: 'network-inventory', tier: 'durable', duration: 'P30D', action: 'archive', archiveSink: 'encrypted-artifact-store' },
+    { id: 'dr-evidence-durable', version: '1', category: 'dr-evidence', tier: 'durable', duration: 'P90D', action: 'archive', archiveSink: 'encrypted-artifact-store' },
+    { id: 'sanitized-summary-durable', version: '1', category: 'sanitized-summary', tier: 'durable', duration: 'P365D', action: 'summarize' },
+    { id: 'generic-durable', version: '1', category: 'generic', tier: 'durable', duration: 'P90D', action: 'summarize' },
+];
+function digest(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function parseDuration(value) {
+    if (value === null || value === undefined)
+        return null;
+    const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(value);
+    if (!match || !match.slice(1).some(Boolean))
+        throw new Error(`unsupported retention duration '${value}'`);
+    const days = Number(match[1] ?? 0);
+    const hours = Number(match[2] ?? 0);
+    const minutes = Number(match[3] ?? 0);
+    const seconds = Number(match[4] ?? 0);
+    const milliseconds = (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1_000;
+    if (!Number.isSafeInteger(milliseconds) || milliseconds < 1)
+        throw new Error(`invalid retention duration '${value}'`);
+    return milliseconds;
+}
+export function validateRetentionRules(rules) {
+    const ids = new Set();
+    const actions = new Set(['retain', 'summarize', 'redact-fields', 'archive', 'delete']);
+    for (const rule of rules) {
+        if (!/^[a-z0-9][a-z0-9.-]{0,127}$/.test(rule.id))
+            throw new Error('retention rule IDs must be lowercase stable identifiers');
+        if (ids.has(rule.id))
+            throw new Error(`duplicate retention rule '${rule.id}'`);
+        ids.add(rule.id);
+        if (!rule.version.trim())
+            throw new Error(`retention rule '${rule.id}' requires a version`);
+        if (!actions.has(rule.action))
+            throw new Error(`retention rule '${rule.id}' has an unsupported action`);
+        if (rule.tier !== undefined && rule.tier !== 'raw' && rule.tier !== 'durable') {
+            throw new Error(`retention rule '${rule.id}' has an unsupported tier`);
+        }
+        if (rule.priority !== undefined && !Number.isSafeInteger(rule.priority)) {
+            throw new Error(`retention rule '${rule.id}' priority must be a safe integer`);
+        }
+        for (const [name, value] of Object.entries({ category: rule.category, classification: rule.classification, sink: rule.sink })) {
+            if (value !== undefined && (typeof value !== 'string' || value.length === 0)) {
+                throw new Error(`retention rule '${rule.id}' ${name} must be a non-empty string`);
+            }
+        }
+        parseDuration(rule.duration);
+        if (rule.action === 'redact-fields' && (!rule.redactFields || rule.redactFields.length === 0)) {
+            throw new Error(`retention rule '${rule.id}' requires redactFields`);
+        }
+        if (rule.action === 'archive' && !rule.archiveSink) {
+            throw new Error(`retention rule '${rule.id}' requires archiveSink`);
+        }
+        if (rule.redactFields !== undefined && (!Array.isArray(rule.redactFields) || rule.redactFields.some((field) => typeof field !== 'string' || !field))) {
+            throw new Error(`retention rule '${rule.id}' redactFields must contain non-empty strings`);
+        }
+    }
+}
+function ruleMatches(rule, input) {
+    return (rule.category === undefined || rule.category === input.category)
+        && (rule.classification === undefined || rule.classification === input.classification)
+        && (rule.sink === undefined || rule.sink === input.sinkId)
+        && (rule.tier === undefined || rule.tier === input.tier);
+}
+function specificity(rule) {
+    return [rule.category, rule.classification, rule.sink, rule.tier].filter((value) => value !== undefined).length;
+}
+export function resolveRetentionRule(input, rules = [], requestedPolicyId) {
+    const candidates = [
+        ...rules.map((rule) => ({ rule, configured: true })),
+        ...DEFAULT_RETENTION_RULES.map((rule) => ({ rule, configured: false })),
+    ]
+        .filter(({ rule }) => (requestedPolicyId === undefined || rule.id === requestedPolicyId) && ruleMatches(rule, input))
+        .sort((left, right) => (right.rule.priority ?? 0) - (left.rule.priority ?? 0)
+        || specificity(right.rule) - specificity(left.rule)
+        || Number(right.configured) - Number(left.configured)
+        || left.rule.id.localeCompare(right.rule.id));
+    const selected = candidates[0]?.rule;
+    if (!selected)
+        throw new Error(`no retention rule matches ${input.category}/${input.classification}/${input.sinkId}/${input.tier}`);
+    parseDuration(selected.duration);
+    if (selected.action === 'redact-fields' && (!selected.redactFields || selected.redactFields.length === 0)) {
+        throw new Error(`retention rule '${selected.id}' requires redactFields`);
+    }
+    if (selected.action === 'archive' && !selected.archiveSink) {
+        // Built-in archive policies deliberately require the project to select a destination.
+        if (!DEFAULT_RETENTION_RULES.some((rule) => rule.id === selected.id)) {
+            throw new Error(`retention rule '${selected.id}' requires archiveSink`);
+        }
+    }
+    return { ...selected };
+}
+export function createEvidenceLifecycle(input) {
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    const created = Date.parse(createdAt);
+    if (!Number.isFinite(created))
+        throw new Error('evidence creation time must be valid ISO-8601');
+    if (input.tier === 'raw' && !input.rawCaptureReason?.trim()) {
+        throw new Error('full raw evidence capture requires an explicit reason');
+    }
+    if (!input.sink.mutable && input.tier === 'raw') {
+        throw new Error(`raw evidence cannot be published to immutable sink '${input.sink.id}'; publish a sanitized summary instead`);
+    }
+    const immutableSummaryRule = !input.sink.mutable && input.category === 'sanitized-summary'
+        ? {
+            id: 'immutable-sanitized-summary', version: '1', category: 'sanitized-summary',
+            sink: input.sink.id, tier: 'durable', duration: null, action: 'retain', priority: 10_000,
+        }
+        : undefined;
+    const rule = resolveRetentionRule({
+        category: input.category,
+        classification: input.classification,
+        sinkId: input.sink.id,
+        tier: input.tier,
+    }, [...(immutableSummaryRule ? [immutableSummaryRule] : []), ...(input.rules ?? [])], input.requestedPolicyId);
+    const duration = parseDuration(rule.duration);
+    if (!input.sink.mutable && duration !== null && rule.action !== 'retain') {
+        throw new Error(`sink '${input.sink.id}' cannot satisfy finite lifecycle action '${rule.action}'`);
+    }
+    return {
+        schemaVersion: 'ops-evidence-lifecycle.aiwg.io/v1',
+        artifactId: input.artifactId.startsWith('sha256:') && /^sha256:[a-f0-9]{64}$/.test(input.artifactId)
+            ? input.artifactId
+            : digest(input.artifactId),
+        category: input.category,
+        classification: input.classification,
+        sinkId: input.sink.id,
+        tier: input.tier,
+        createdAt,
+        policyId: rule.id,
+        policyVersion: rule.version,
+        dispositionDeadline: duration === null ? null : new Date(created + duration).toISOString(),
+        action: rule.action,
+        ...(rule.redactFields ? { dispositionFields: [...rule.redactFields] } : {}),
+        ...(rule.archiveSink ? { archiveSink: rule.archiveSink } : {}),
+        ...(input.rawCaptureReason ? { rawCaptureReasonDigest: digest(input.rawCaptureReason) } : {}),
+        holds: [],
+    };
+}
+export function reapplyRetentionPolicy(input) {
+    const metadata = createEvidenceLifecycle({
+        artifactId: input.record.metadata.artifactId,
+        category: input.record.metadata.category,
+        classification: input.record.metadata.classification,
+        sink: input.sink,
+        tier: input.record.metadata.tier,
+        rules: input.rules,
+        requestedPolicyId: input.requestedPolicyId,
+        rawCaptureReason: input.record.metadata.rawCaptureReasonDigest ? 'previously-approved-raw-capture' : undefined,
+        createdAt: input.record.metadata.createdAt,
+    });
+    return {
+        payload: input.record.payload,
+        metadata: {
+            ...metadata,
+            ...(input.record.metadata.rawCaptureReasonDigest
+                ? { rawCaptureReasonDigest: input.record.metadata.rawCaptureReasonDigest }
+                : {}),
+            holds: [...input.record.metadata.holds],
+        },
+    };
+}
+export function placeEvidenceHold(input) {
+    if (!input.holdId || !input.actor || !input.reason.trim())
+        throw new Error('hold ID, actor, and reason are required');
+    if (input.record.metadata.holds.some((hold) => hold.id === input.holdId && !hold.releasedAt)) {
+        throw new Error(`hold '${input.holdId}' is already active`);
+    }
+    const occurredAt = (input.now ?? new Date()).toISOString();
+    const reasonDigest = digest(input.reason);
+    const hold = { id: input.holdId, actor: input.actor, reasonDigest, placedAt: occurredAt };
+    return {
+        record: {
+            payload: input.record.payload,
+            metadata: { ...input.record.metadata, holds: [...input.record.metadata.holds, hold] },
+        },
+        audit: {
+            schemaVersion: 'ops-evidence-hold.aiwg.io/v1', eventId: randomUUID(),
+            artifactId: input.record.metadata.artifactId, holdId: input.holdId,
+            action: 'placed', actor: input.actor, reasonDigest, occurredAt,
+        },
+    };
+}
+export function releaseEvidenceHold(input) {
+    if (!input.actor || !input.reason.trim())
+        throw new Error('release actor and reason are required');
+    const occurredAt = (input.now ?? new Date()).toISOString();
+    const reasonDigest = digest(input.reason);
+    let released = false;
+    const holds = input.record.metadata.holds.map((hold) => {
+        if (hold.id !== input.holdId || hold.releasedAt)
+            return hold;
+        released = true;
+        return { ...hold, releasedAt: occurredAt, releasedBy: input.actor, releaseReasonDigest: reasonDigest };
+    });
+    if (!released)
+        throw new Error(`active hold '${input.holdId}' was not found`);
+    return {
+        record: { payload: input.record.payload, metadata: { ...input.record.metadata, holds } },
+        audit: {
+            schemaVersion: 'ops-evidence-hold.aiwg.io/v1', eventId: randomUUID(),
+            artifactId: input.record.metadata.artifactId, holdId: input.holdId,
+            action: 'released', actor: input.actor, reasonDigest, occurredAt,
+        },
+    };
+}
+function receipt(record, action, outcome, occurredAt, extras = {}) {
+    return {
+        schemaVersion: 'ops-disposition-receipt.aiwg.io/v1',
+        receiptId: randomUUID(),
+        artifactId: record.metadata.artifactId,
+        policyId: record.metadata.policyId,
+        policyVersion: record.metadata.policyVersion,
+        action,
+        outcome,
+        occurredAt,
+        ...(extras.destinationId ? { destinationId: extras.destinationId } : {}),
+        ...(extras.errorCode ? { errorCode: extras.errorCode } : {}),
+    };
+}
+function errorCode(error) {
+    if (error && typeof error === 'object' && 'code' in error && typeof error.code === 'string' && /^[A-Z0-9_-]{1,64}$/.test(error.code)) {
+        return error.code;
+    }
+    return 'LIFECYCLE_ACTION_FAILED';
+}
+/** Execute a due lifecycle action. Receipts contain identifiers/outcomes only, never removed payloads or error messages. */
+export async function executeLifecycle(record, adapter, now = new Date()) {
+    const occurredAt = now.toISOString();
+    if (record.metadata.holds.some((hold) => !hold.releasedAt)) {
+        return receipt(record, record.metadata.action, 'held', occurredAt);
+    }
+    if (record.metadata.dispositionDeadline === null || Date.parse(record.metadata.dispositionDeadline) > now.getTime()) {
+        return receipt(record, record.metadata.action, 'not-due', occurredAt);
+    }
+    const action = record.metadata.action;
+    try {
+        switch (action) {
+            case 'retain': break;
+            case 'summarize':
+                if (!adapter.summarize)
+                    throw Object.assign(new Error('summarize adapter is unavailable'), { code: 'SUMMARIZE_UNAVAILABLE' });
+                await adapter.summarize(record);
+                break;
+            case 'redact-fields':
+                if (!adapter.redactFields)
+                    throw Object.assign(new Error('redact-fields adapter is unavailable'), { code: 'REDACT_FIELDS_UNAVAILABLE' });
+                await adapter.redactFields(record, record.metadata.dispositionFields ?? []);
+                break;
+            case 'archive': {
+                if (!adapter.archive)
+                    throw Object.assign(new Error('archive adapter is unavailable'), { code: 'ARCHIVE_UNAVAILABLE' });
+                const destination = record.metadata.archiveSink ?? 'project-configured-archive';
+                await adapter.archive(record, destination);
+                return receipt(record, action, 'completed', occurredAt, { destinationId: destination });
+            }
+            case 'delete':
+                if (!adapter.delete)
+                    throw Object.assign(new Error('delete adapter is unavailable'), { code: 'DELETE_UNAVAILABLE' });
+                await adapter.delete(record);
+                break;
+        }
+        return receipt(record, action, 'completed', occurredAt);
+    }
+    catch (error) {
+        return receipt(record, action, 'failed', occurredAt, { errorCode: errorCode(error) });
+    }
+}
+//# sourceMappingURL=retention.js.map

package/dist/src/jobs/executor.js

@@ -2,13 +2,12 @@ import { spawn } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { resolveWorkspaceFile } from './flow.js';
+import { redactText } from '../governance/redaction.js';
 function redact(text, sensitiveValues) {
     let output = text;
     for (const value of sensitiveValues.filter(value => value.length >= 4))
         output = output.split(value).join('[REDACTED]');
-    return output
-        .replace(/\b(authorization|cookie|set-cookie)\s*[:=]\s*[^\s,;]+/giu, '$1=[REDACTED]')
-        .replace(/\b(bearer|token)\s+[A-Za-z0-9._~+\/-]{8,}/giu, '$1 [REDACTED]');
+    return redactText(output).text;
 }
 async function sensitiveValues(files) {
     const values = [];