@aiwg/cli 2026.8.27 → 2026.8.28

package/bin/aiwg.mjs

@@ -407,6 +407,12 @@ async function main() {
   // commands remain reachable so an operator can explicitly adopt or switch.
   if (args[0] !== 'installation') {
     const identityPath = path.join(activePackageRoot, 'dist', 'src', 'installation', 'manager.mjs');
+    if (activePackageRoot !== packageRoot && !existsSync(identityPath)) {
+      console.error(`Dev mode: compiled installation manager not found at ${identityPath}`);
+      console.error(`  Run: (cd ${activePackageRoot} && npm run build:cli)`);
+      console.error(`  Or switch back: aiwg --use-stable`);
+      process.exit(1);
+    }
     const { assertCanonicalInstallation } = await import(pathToFileURL(identityPath).href);
     assertCanonicalInstallation({ actualRoot: activePackageRoot });
   }

package/dist/src/a2a/client.js

@@ -102,7 +102,10 @@ export class A2AClient {
     }
     operationPath(v1Path, legacyPath) {
         if (this.selectedInterface) {
-            return this.protocolVersion === '1.0' ? `/${v1Path}` : `/v1/${legacyPath}`;
+            // An advertised interface URL is already the operation base. Appending
+            // the legacy route prefix again turns cards ending in `/v1` into
+            // `/v1/v1/...` and breaks otherwise valid negotiated 0.3 calls.
+            return this.protocolVersion === '1.0' ? `/${v1Path}` : `/${legacyPath}`;
         }
         return `${this.agentPath()}/${legacyPath}`;
     }

package/dist/src/a2a/codecs.js

@@ -24,8 +24,11 @@ export function decodePushNotificationConfig(version, input, path = '$') {
     const result = {
         url: stringAt(version, `${path}.url`, obj.url),
     };
-    const id = version === '1.0' ? obj.id : obj.configId;
-    assignOptionalString(version, result, 'configId', id, `${path}.${version === '1.0' ? 'id' : 'configId'}`);
+    // The deployed 0.3 sandbox predates the stable field rename and returns
+    // `id`; accept that compatibility spelling while continuing to encode the
+    // documented 0.3 `configId` shape.
+    const id = version === '1.0' ? obj.id : (obj.configId ?? obj.id);
+    assignOptionalString(version, result, 'configId', id, `${path}.${version === '1.0' || obj.configId === undefined ? 'id' : 'configId'}`);
     assignOptionalString(version, result, 'token', obj.token, `${path}.token`);
     if (version === '0.3') {
         assignOptionalString(version, result, 'secret', obj.secret, `${path}.secret`);

package/dist/src/a2a/protocol.js

@@ -38,7 +38,7 @@ export function normalizeAgentCard(card) {
         if (!entry || typeof entry !== 'object' || typeof entry.url !== 'string') {
             throw new A2ANegotiationError('agent_card.interface_invalid', `supportedInterfaces[${preference}] must contain an absolute URL`);
         }
-        assertAbsoluteUrl(entry.url, `supportedInterfaces[${preference}].url`);
+        assertAbsoluteInterfaceUrl(entry.url, `supportedInterfaces[${preference}].url`);
         const interfaceVersion = normalizeProtocolVersion(entry.protocolVersion);
         if (entry.protocolVersion !== undefined && !interfaceVersion) {
             throw new A2ANegotiationError('agent_card.interface_version_invalid', `supportedInterfaces[${preference}].protocolVersion is unsupported`);
@@ -133,4 +133,15 @@ function assertAbsoluteUrl(value, field) {
         throw new A2ANegotiationError('agent_card.url_invalid', `${field} must be an absolute HTTP(S) URL`);
     }
 }
+function assertAbsoluteInterfaceUrl(value, field) {
+    try {
+        const url = new URL(value);
+        if (!['http:', 'https:', 'ws:', 'wss:'].includes(url.protocol)) {
+            throw new Error('unsupported interface scheme');
+        }
+    }
+    catch {
+        throw new A2ANegotiationError('agent_card.url_invalid', `${field} must be an absolute HTTP(S) or WS(S) URL`);
+    }
+}
 //# sourceMappingURL=protocol.js.map

package/dist/src/activity-log/cli.js

@@ -18,6 +18,7 @@
 import { ACTIVITY_OPERATIONS, formatEntry, formatUtcTimestamp, isActivityOperation, } from './types.js';
 import { parseLog, parseUtcDate } from './parser.js';
 import { resolveStorage } from '../storage/index.js';
+import { redactText } from '../governance/redaction.js';
 const LOG_PATH = 'activity.log';
 const DEFAULT_LIMIT = 20;
 export async function main(args) {
@@ -74,7 +75,9 @@ async function handleAppend(args) {
             `  Valid operations: ${ACTIVITY_OPERATIONS.join(', ')}`);
     }
     const op = args[0];
-    const summary = args.slice(1).join(' ').trim();
+    const summary = redactText(args.slice(1).join(' ').trim(), {
+        limits: { maxInputBytes: 16 * 1024 },
+    }).text;
     if (!isActivityOperation(op)) {
         throw new Error(`Invalid operation "${op}". Valid operations: ${ACTIVITY_OPERATIONS.join(', ')}`);
     }

package/dist/src/api/index.d.ts

@@ -18,5 +18,6 @@ export * from '../providers/transformation-receipt-integration.js';
 export * from '../marketplace/artifact-attestation.js';
 export * from '../uhp/index.js';
 export * from '../mission-protocol/index.js';
+export * from '../governance/index.js';
 export { ARTIFACT_TRUST_ROOT_MEDIA_TYPE, ARTIFACT_TRUST_ROOT_SCHEMA_VERSION, ARTIFACT_TRUST_STATE_SCHEMA_VERSION, bootstrapTrustRoot, parseTrustRoot, parseTrustState, readTrustState, validateTrustRoot, validateTrustState, verifyRootTransition, writeTrustState, channelStateKey, canonicalJson, dssePae, publicKeyFingerprint, sha256, type ArtifactTrustRoot, type ArtifactTrustState, type RootBootstrapResult, type RootTransitionResult, type ArtifactTrustPolicySettings, type TrustedChannelState, } from '../security/artifact-trust.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/api/index.js

@@ -18,5 +18,6 @@ export * from '../providers/transformation-receipt-integration.js';
 export * from '../marketplace/artifact-attestation.js';
 export * from '../uhp/index.js';
 export * from '../mission-protocol/index.js';
+export * from '../governance/index.js';
 export { ARTIFACT_TRUST_ROOT_MEDIA_TYPE, ARTIFACT_TRUST_ROOT_SCHEMA_VERSION, ARTIFACT_TRUST_STATE_SCHEMA_VERSION, bootstrapTrustRoot, parseTrustRoot, parseTrustState, readTrustState, validateTrustRoot, validateTrustState, verifyRootTransition, writeTrustState, channelStateKey, canonicalJson, dssePae, publicKeyFingerprint, sha256, } from '../security/artifact-trust.js';
 //# sourceMappingURL=index.js.map

package/dist/src/artifacts/fortemi-core-sync.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
+import { parse as parseYaml } from "yaml";
 import { GRAPH_CONFIGS, getProjectIndexRoot, loadGlobalGraphConfigs } from "./types.js";
 import { buildAiwgFortemiIndexExport, } from "./browser-export.js";
 import { loadGraphIndexFile } from "./index-reader.js";
@@ -263,4 +264,40 @@ export function getFortemiCorePrebuiltStatus(graph = "framework") {
         reason: !exportExists ? "prebuilt manifest exists but export file is missing" : reason,
     };
 }
+/**
+ * Compare source script declarations with their compact prebuilt records.
+ * This is deliberately independent of cache freshness: a checksum-valid index
+ * can still be operationally broken when compaction drops runtime metadata.
+ */
+export function getFortemiCoreExecutableSkillStatus(graph = "framework", packageRoot) {
+    const root = packageRoot ?? findPackageRoot(path.dirname(fileURLToPath(import.meta.url)));
+    if (!root)
+        return { sourceExecutableCount: 0, packagedExecutableCount: 0, missing: [] };
+    const exportPath = path.join(root, "prebuilt", "fortemi-core", graph, "aiwg-fortemi-index-v2.json");
+    if (!fs.existsSync(exportPath))
+        return { sourceExecutableCount: 0, packagedExecutableCount: 0, missing: [] };
+    const exported = JSON.parse(fs.readFileSync(exportPath, "utf-8"));
+    let sourceExecutableCount = 0;
+    let packagedExecutableCount = 0;
+    const missing = [];
+    for (const item of exported.items ?? []) {
+        if (item.type !== "aiwg.skill" || typeof item.source?.path !== "string")
+            continue;
+        const sourcePath = path.join(root, item.source.path);
+        if (!fs.existsSync(sourcePath))
+            continue;
+        const match = fs.readFileSync(sourcePath, "utf-8").match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
+        if (!match)
+            continue;
+        const script = parseYaml(match[1])?.script;
+        if (!script)
+            continue;
+        sourceExecutableCount += 1;
+        if (item.search?.frontmatter?.aiwg_script)
+            packagedExecutableCount += 1;
+        else
+            missing.push(item.name ?? item.id);
+    }
+    return { sourceExecutableCount, packagedExecutableCount, missing };
+}
 //# sourceMappingURL=fortemi-core-sync.js.map

package/dist/src/audit/operator-decision.js

@@ -10,9 +10,8 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { appendFile, chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { redactStructured } from '../governance/redaction.js';
 export const OPERATOR_DECISION_SCHEMA = 'operator-decision.aiwg.io/v1';
-const secretKey = /token|secret|password|credential|authorization|cookie|csrf|api[_-]?key/i;
-const secretValue = /(?:bearer\s+\S+|\bsk-[a-z0-9_-]+|\bgh[pousr]_[a-z0-9_]+)/i;
 export function digestDecisionContext(context) {
     const safe = redact(context).value;
     return `sha256:${createHash('sha256').update(canonicalJson(safe)).digest('hex')}`;
@@ -167,28 +166,13 @@ function canonicalJson(value) {
     return JSON.stringify(value);
 }
 function redact(value, path = '$') {
-    if (Array.isArray(value)) {
-        const rows = value.map((item, index) => redact(item, `${path}[${index}]`));
-        return { value: rows.map(row => row.value), paths: rows.flatMap(row => row.paths) };
-    }
-    if (value && typeof value === 'object') {
-        const output = {};
-        const paths = [];
-        for (const [key, item] of Object.entries(value)) {
-            if (secretKey.test(key)) {
-                output[key] = '[redacted]';
-                paths.push(`${path}.${key}`);
-            }
-            else {
-                const child = redact(item, `${path}.${key}`);
-                output[key] = child.value;
-                paths.push(...child.paths);
-            }
-        }
-        return { value: output, paths };
-    }
-    if (typeof value === 'string' && secretValue.test(value))
-        return { value: '[redacted]', paths: [path] };
-    return { value, paths: [] };
+    const result = redactStructured(value);
+    return {
+        value: result.value,
+        paths: result.findings.map((finding) => {
+            const suffix = finding.path?.replaceAll('/', '.').replace(/^\./, '') ?? '';
+            return suffix ? `${path}.${suffix}` : path;
+        }),
+    };
 }
 //# sourceMappingURL=operator-decision.js.map

package/dist/src/features/catalog.js

@@ -32,15 +32,16 @@ export const FEATURE_CATALOG = [
     },
     {
         name: 'sqlite',
-        description: 'SQLite storage backend for memory / activity-log / kb subsystems',
+        description: 'SQLite runtime for session catalogs and persistent storage backends',
         packages: ['better-sqlite3'],
         packageSpecs: { 'better-sqlite3': '12.8.0' },
         scriptPackages: ['better-sqlite3'],
         enables: [
+            'aiwg sessions list / discover / import-discovered / timeline / search',
             'storage.config: backend=sqlite for any subsystem',
             'transactional reads/writes against `.aiwg/storage/`',
         ],
-        cost: '~5 MB — native compile via node-gyp',
+        cost: '~5 MB — platform prebuild when available, otherwise a native compile via node-gyp',
     },
     {
         name: 'postgres',

package/dist/src/governance/boundary.js

@@ -0,0 +1,354 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { createSanitizedSummary, evaluatePublicationGate, resolveArtifactGovernance, resolveClassificationDefinitions, } from './classification.js';
+import { createEvidenceLifecycle, validateRetentionRules, } from './retention.js';
+import { redactStructured, redactText, } from './redaction.js';
+export const DEFAULT_PUBLICATION_SINKS = {
+    'local-ephemeral': {
+        id: 'local-ephemeral', visibility: 'restricted', external: false,
+        persistent: false, mutable: true, maxClassification: 'restricted-identity',
+    },
+    'private-repository': {
+        id: 'private-repository', visibility: 'private', external: false,
+        persistent: true, mutable: true, maxClassification: 'restricted-infrastructure',
+    },
+    'public-repository': {
+        id: 'public-repository', visibility: 'public', external: true,
+        persistent: true, mutable: true, maxClassification: 'public', acceptsSanitizedSummary: true,
+    },
+    'private-issue': {
+        id: 'private-issue', visibility: 'private', external: true,
+        persistent: true, mutable: false, maxClassification: 'confidential', acceptsSanitizedSummary: true,
+    },
+    'public-issue': {
+        id: 'public-issue', visibility: 'public', external: true,
+        persistent: true, mutable: false, maxClassification: 'public', acceptsSanitizedSummary: true,
+    },
+    'encrypted-artifact-store': {
+        id: 'encrypted-artifact-store', visibility: 'restricted', external: false,
+        persistent: true, mutable: true, maxClassification: 'restricted-identity',
+    },
+};
+export function resolveGovernancePolicy(policy = {}) {
+    const resolved = {
+        ...policy,
+        sinks: { ...DEFAULT_PUBLICATION_SINKS, ...(policy.sinks ?? {}) },
+    };
+    const classes = resolveClassificationDefinitions(resolved.classification);
+    const classificationReferences = [
+        resolved.classification?.defaultClassification,
+        ...Object.values(resolved.classification?.defaultsByKind ?? {}),
+        ...Object.values(resolved.classification?.defaultsByCategory ?? {}),
+    ].filter((value) => value !== undefined);
+    for (const value of classificationReferences) {
+        if (!classes[value])
+            throw new Error(`governance policy references unknown classification '${value}'`);
+    }
+    for (const [id, sink] of Object.entries(resolved.sinks ?? {})) {
+        if (!sink || typeof sink !== 'object')
+            throw new Error(`sink '${id}' must be an object`);
+        if (sink.id !== id)
+            throw new Error(`sink map key '${id}' does not match sink ID '${sink.id}'`);
+        if (!new Set(['public', 'private', 'restricted', 'unknown']).has(sink.visibility)) {
+            throw new Error(`sink '${id}' has invalid visibility`);
+        }
+        for (const property of ['external', 'persistent', 'mutable']) {
+            if (typeof sink[property] !== 'boolean')
+                throw new Error(`sink '${id}' requires boolean ${property}`);
+        }
+        for (const property of ['acceptsSanitizedSummary', 'allowRedactionOverride']) {
+            if (sink[property] !== undefined && typeof sink[property] !== 'boolean') {
+                throw new Error(`sink '${id}' requires boolean ${property}`);
+            }
+        }
+        if (sink.maxClassification && !classes[sink.maxClassification]) {
+            throw new Error(`sink '${id}' references unknown classification '${sink.maxClassification}'`);
+        }
+    }
+    validateRetentionRules(resolved.retention ?? []);
+    // Compile configured patterns up front. Empty input cannot create findings,
+    // but invalid or high-risk organization patterns still fail validation.
+    redactText('', resolved.redaction ?? {});
+    redactStructured({ validation: 'ok' }, resolved.redaction ?? {});
+    return resolved;
+}
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function safeAuditLabel(value) {
+    try {
+        if (/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(value) && redactText(value).sensitivity === 'none')
+            return value;
+    }
+    catch {
+        // Hashing is the fail-closed representation for malformed labels.
+    }
+    return sha256(value);
+}
+function stableStatus(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase().replaceAll('_', '-').replaceAll(' ', '-');
+    return new Set([
+        'ok', 'pass', 'passed', 'fail', 'failed', 'complete', 'completed', 'blocked',
+        'partial', 'unknown', 'in-progress', 'review-needed', 'success', 'error',
+    ]).has(normalized) ? normalized : undefined;
+}
+function contentDigest(value) {
+    if (typeof value === 'string')
+        return sha256(value);
+    try {
+        return sha256(JSON.stringify(value) ?? '[undefined]');
+    }
+    catch {
+        return sha256('[unserializable]');
+    }
+}
+function boundedExcerpt(value, maxBytes) {
+    if (typeof value !== 'string')
+        return undefined;
+    const source = Buffer.from(value);
+    return {
+        excerpt: source.subarray(0, maxBytes).toString('utf8'),
+        bytes: source.length,
+        digest: sha256(value),
+        truncated: source.length > maxBytes,
+    };
+}
+/** Reduce command evidence to outcomes, bounded excerpts, counts, and correlation digests by default. */
+export function minimizeEvidence(payload, maxExcerptBytes = 512) {
+    if (!Number.isSafeInteger(maxExcerptBytes) || maxExcerptBytes < 0 || maxExcerptBytes > 64 * 1024) {
+        throw new Error('maxExcerptBytes must be an integer from 0 through 65536');
+    }
+    if (typeof payload === 'string') {
+        return boundedExcerpt(payload, maxExcerptBytes);
+    }
+    if (Array.isArray(payload)) {
+        return { itemCount: payload.length, digest: contentDigest(payload) };
+    }
+    if (!payload || typeof payload !== 'object')
+        return payload;
+    const source = payload;
+    const result = {
+        schemaVersion: 'ops-minimum-evidence.aiwg.io/v1',
+        sourceFieldCount: Object.keys(source).length,
+        sourceDigest: contentDigest(source),
+    };
+    for (const key of ['status', 'outcome', 'success', 'exitCode', 'durationMs', 'startedAt', 'completedAt']) {
+        const value = source[key];
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+            result[key] = value;
+    }
+    const stdout = boundedExcerpt(source.stdout ?? source.output, maxExcerptBytes);
+    const stderr = boundedExcerpt(source.stderr, maxExcerptBytes);
+    if (stdout)
+        result.stdout = stdout;
+    if (stderr)
+        result.stderr = stderr;
+    if (source.command !== undefined)
+        result.commandDigest = contentDigest(source.command);
+    return result;
+}
+function validOverride(override, artifactId, sinkId, now) {
+    if (!override?.id || !override.actor || !override.reason.trim())
+        return false;
+    if (override.artifactId !== artifactId || override.sinkId !== sinkId)
+        return false;
+    const approvedAt = Date.parse(override.approvedAt);
+    if (!Number.isFinite(approvedAt) || approvedAt > now)
+        return false;
+    if (override.expiresAt !== undefined) {
+        const expiresAt = Date.parse(override.expiresAt);
+        if (!Number.isFinite(expiresAt) || expiresAt <= now || expiresAt <= approvedAt)
+            return false;
+    }
+    return true;
+}
+function emptyAudit(input, sinkId, now) {
+    return {
+        schemaVersion: 'ops-evidence-boundary.aiwg.io/v1',
+        eventId: randomUUID(),
+        occurredAt: now.toISOString(),
+        artifactId: sha256(input.id),
+        artifactKind: safeAuditLabel(input.kind),
+        sinkId: safeAuditLabel(sinkId),
+        decision: 'deny',
+        reasonCodes: [],
+        redaction: 'not-needed',
+        redactionCount: 0,
+        redactionClasses: [],
+    };
+}
+function sanitizePayload(payload, options) {
+    if (typeof payload === 'string') {
+        const result = redactText(payload, options);
+        return { value: result.text, findings: result.findings };
+    }
+    const result = redactStructured(payload, options);
+    return { value: result.value, findings: result.findings };
+}
+/**
+ * Mandatory sink boundary: minimize, redact, classify/gate, and attach lifecycle
+ * metadata before returning any publishable value. Failure returns no payload.
+ */
+export function prepareEvidenceForSink(input) {
+    const now = input.now ?? new Date();
+    const audit = emptyAudit(input.artifact, input.sinkId, now);
+    let policy;
+    try {
+        policy = resolveGovernancePolicy(input.policy);
+    }
+    catch {
+        audit.reasonCodes = ['invalid-governance-policy'];
+        return { allowed: false, audit };
+    }
+    const sink = policy.sinks?.[input.sinkId];
+    if (!sink) {
+        audit.reasonCodes = ['unknown-sink'];
+        audit.redaction = 'failed';
+        return { allowed: false, audit };
+    }
+    let governance;
+    try {
+        governance = resolveArtifactGovernance({
+            kind: input.artifact.kind,
+            category: input.artifact.category,
+            metadata: input.artifact.governance,
+            parent: input.artifact.parentGovernance,
+            policy: policy.classification,
+        });
+    }
+    catch {
+        audit.reasonCodes = ['invalid-classification-metadata'];
+        return { allowed: false, audit };
+    }
+    const tier = input.artifact.tier ?? 'durable';
+    let candidate;
+    try {
+        candidate = tier === 'raw' || input.artifact.category === 'sanitized-summary'
+            ? input.artifact.payload
+            : minimizeEvidence(input.artifact.payload, input.maxExcerptBytes);
+    }
+    catch {
+        audit.reasonCodes = ['minimization-failed'];
+        return { allowed: false, audit };
+    }
+    let findings = [];
+    try {
+        const sanitized = sanitizePayload(candidate, policy.redaction ?? {});
+        candidate = sanitized.value;
+        findings = sanitized.findings;
+        audit.redaction = findings.length ? 'completed' : 'not-needed';
+        audit.redactionCount = findings.length;
+        audit.redactionClasses = [...new Set(findings.map((finding) => finding.class))].sort();
+    }
+    catch {
+        const override = input.redactionOverride;
+        if (!sink.allowRedactionOverride || !validOverride(override, input.artifact.id, sink.id, now.getTime())) {
+            audit.redaction = 'failed';
+            audit.reasonCodes = ['sanitization-failed'];
+            return { allowed: false, audit };
+        }
+        audit.redaction = 'override';
+        audit.decision = 'override';
+        audit.redactionOverrideId = override.id;
+        audit.redactionOverrideActor = override.actor;
+        audit.redactionOverrideReasonDigest = sha256(override.reason);
+    }
+    const gate = evaluatePublicationGate({
+        artifactId: input.artifact.id,
+        artifactKind: input.artifact.kind,
+        governance,
+        sink,
+        sourceRepository: input.sourceRepository,
+        approval: input.publicationApproval,
+        classes: resolveClassificationDefinitions(policy.classification),
+        now,
+    });
+    audit.publication = gate.audit;
+    audit.reasonCodes = gate.reasonCodes;
+    let summary = false;
+    const immutableSinkRequiresSummary = !sink.mutable && input.artifact.category !== 'sanitized-summary';
+    if (!gate.allowed || immutableSinkRequiresSummary) {
+        if (!gate.allowed && gate.decision !== 'summarize') {
+            audit.decision = 'deny';
+            return { allowed: false, audit };
+        }
+        candidate = createSanitizedSummary({
+            artifactId: input.artifact.id,
+            artifactKind: input.artifact.kind,
+            status: stableStatus(input.artifact.status),
+            omittedFields: candidate && typeof candidate === 'object' ? Object.keys(candidate).length : 1,
+            redactionClasses: audit.redactionClasses,
+        });
+        governance = resolveArtifactGovernance({
+            kind: 'SanitizedSummary',
+            category: 'sanitized-summary',
+            metadata: { classification: 'public', owner: governance.owner, handling: { allowedSinks: [sink.id], crossRepo: 'allow' } },
+            policy: policy.classification,
+        });
+        const summaryGate = evaluatePublicationGate({
+            artifactId: input.artifact.id,
+            artifactKind: 'SanitizedSummary',
+            governance,
+            sink,
+            sourceRepository: input.sourceRepository,
+            classes: resolveClassificationDefinitions(policy.classification),
+            now,
+        });
+        audit.publication = summaryGate.audit;
+        if (!summaryGate.allowed) {
+            audit.decision = 'deny';
+            audit.reasonCodes = ['sanitized-summary-denied', ...summaryGate.reasonCodes];
+            return { allowed: false, audit };
+        }
+        summary = true;
+    }
+    let lifecycle;
+    try {
+        lifecycle = createEvidenceLifecycle({
+            artifactId: input.artifact.id,
+            category: summary ? 'sanitized-summary' : input.artifact.category,
+            classification: governance.classification,
+            sink,
+            tier: summary ? 'durable' : tier,
+            rules: policy.retention,
+            requestedPolicyId: governance.handling.retentionPolicy,
+            rawCaptureReason: input.artifact.rawCaptureReason,
+            createdAt: now.toISOString(),
+        });
+    }
+    catch {
+        audit.decision = 'deny';
+        audit.reasonCodes = ['retention-policy-unsatisfied'];
+        return { allowed: false, audit };
+    }
+    audit.retentionPolicyId = lifecycle.policyId;
+    audit.dispositionDeadline = lifecycle.dispositionDeadline;
+    audit.decision = summary ? 'summary' : gate.decision === 'override' || audit.redaction === 'override' ? 'override' : 'allow';
+    return {
+        allowed: true,
+        prepared: {
+            payload: candidate,
+            governance: {
+                classification: governance.classification,
+                ...(governance.owner ? { owner: governance.owner } : {}),
+                handling: {
+                    allowedSinks: governance.handling.allowedSinks ?? [sink.id],
+                    crossRepo: governance.handling.crossRepo ?? 'approval-required',
+                    retentionPolicy: lifecycle.policyId,
+                },
+            },
+            lifecycle,
+            summary,
+        },
+        audit,
+    };
+}
+/** Call a sink writer only after the boundary returns publishable evidence. */
+export async function publishEvidence(input) {
+    const result = prepareEvidenceForSink(input);
+    if (result.allowed && result.prepared)
+        await input.writer(result.prepared);
+    return result;
+}
+//# sourceMappingURL=boundary.js.map