@aiwg/cli 2026.8.27 → 2026.8.28

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 = [];

package/dist/src/ops/cli.js

@@ -11,6 +11,11 @@
  * @implements #544
  */
 import { OpsRegistry } from './registry.js';
+import { appendFile, chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { parse as parseYaml } from 'yaml';
+import { prepareEvidenceForSink, } from '../governance/index.js';
 /**
  * Main CLI entry point for `aiwg ops <subcommand> [args]`
  */
@@ -53,6 +58,9 @@ export async function main(args) {
         case 'adopt':
             await handleAdopt(registry, subArgs);
             break;
+        case 'evidence':
+            await handleEvidence(subArgs);
+            break;
         default:
             printUsage();
             if (subcommand) {
@@ -61,6 +69,91 @@ export async function main(args) {
             break;
     }
 }
+function flagValue(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--'))
+        throw new Error(`${name} requires a value`);
+    return value;
+}
+function parseData(source, label) {
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        try {
+            return parseYaml(source);
+        }
+        catch {
+            throw new Error(`${label} must contain valid JSON or YAML`);
+        }
+    }
+}
+async function readStdin(maxBytes = 16 * 1024 * 1024) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += value.length;
+        if (bytes > maxBytes)
+            throw new Error('evidence input exceeds 16 MiB');
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+async function readInput(args) {
+    const inputPath = flagValue(args, '--input');
+    return inputPath ? readFile(resolve(inputPath), 'utf8') : readStdin();
+}
+async function appendBoundaryAudit(cwd, value, configuredPath) {
+    const path = resolve(configuredPath ?? `${cwd}/.aiwg/ops/audit/governance-boundary.jsonl`);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await appendFile(path, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await chmod(path, 0o600);
+}
+async function writePreparedOutput(pathValue, value) {
+    const path = resolve(pathValue);
+    const temporary = `${path}.tmp-${randomUUID()}`;
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    await rename(temporary, path);
+    await chmod(path, 0o600);
+}
+async function handleEvidence(args) {
+    const action = args[0];
+    if (action !== 'prepare') {
+        throw new Error('Usage: aiwg ops evidence prepare [--input <json-or-yaml>] [--policy <json-or-yaml>] [--output <path>] [--audit <path>]');
+    }
+    const envelope = parseData(await readInput(args), 'evidence input');
+    if (!envelope || typeof envelope !== 'object' || !envelope.artifact || typeof envelope.sinkId !== 'string') {
+        throw new Error('evidence input requires artifact and sinkId');
+    }
+    const policyPath = flagValue(args, '--policy');
+    const policy = policyPath
+        ? parseData(await readFile(resolve(policyPath), 'utf8'), 'governance policy')
+        : undefined;
+    const result = prepareEvidenceForSink({
+        ...envelope,
+        policy,
+    });
+    await appendBoundaryAudit(process.cwd(), result.audit, flagValue(args, '--audit'));
+    const response = result.allowed && result.prepared
+        ? { schemaVersion: 'ops-prepared-evidence.aiwg.io/v1', prepared: result.prepared, audit: result.audit, auditRecorded: true }
+        : { schemaVersion: 'ops-prepared-evidence.aiwg.io/v1', denied: true, audit: result.audit, auditRecorded: true };
+    const outputPath = flagValue(args, '--output');
+    if (outputPath) {
+        if (!result.allowed)
+            throw new Error(`evidence publication denied: ${result.audit.reasonCodes.join(', ')}`);
+        await writePreparedOutput(outputPath, response);
+    }
+    else {
+        process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
+    }
+    if (!result.allowed)
+        process.exitCode = 2;
+}
 async function handleInit(registry, args) {
     // Parse flags
     let silent = false;
@@ -225,6 +318,7 @@ Subcommands:
   push [--workspace <n>]  Push workspace repos to remote
   discover [root...]      Scan filesystem for orphaned ops-workspace clones
   adopt <path>            Register an existing local clone as a repo entry
+  evidence prepare        Sanitize and policy-gate evidence before publication
 
 Init options:
   --silent                Skip interactive prompts
@@ -251,6 +345,7 @@ Examples:
   aiwg ops push --workspace personal
   aiwg ops discover ~/projects ~/work --max-depth 4
   aiwg ops discover --register --workspace home
+  aiwg ops evidence prepare --input request.yaml --policy .aiwg/ops/governance-policy.yaml
 
 Discover options:
   --max-depth <n>         Max walk depth from each root (default: 3)

package/dist/src/serve/dispatch-router.js

@@ -85,7 +85,7 @@ async function dispatchV2(executor, payload, opts) {
     // discovery dependency to the compatibility path.
     if (clientOpts.protocolPolicy === '0.3') {
         clientOpts.selectedInterface = {
-            url: `${executor.transportEndpoints.rest.replace(/\/+$/, '')}/agents/${encodeURIComponent(a2aInstanceId)}`,
+            url: `${executor.transportEndpoints.rest.replace(/\/+$/, '')}/agents/${encodeURIComponent(a2aInstanceId)}/v1`,
             protocolBinding: 'REST',
             protocolVersion: '0.3',
             preference: 0,

package/dist/src/sessions/repository.js

@@ -1,21 +1,23 @@
-import { createRequire } from 'node:module';
+import { requireFeaturePackage } from '../features/runtime.js';
 import { CandidateReviewReceiptSchema, DeletionReceiptSchema, IntelligenceCandidateSchema, PromotionDependencyDecisionSchema, PromotionReceiptSchema, SessionContractError, sha256, } from './contracts.js';
 import { coverageFromBatchRun, } from './batch-contracts.js';
 import { redactSessionText, sanitizeNativeExtensions } from './policy.js';
 import { deriveSessionAnalytics, } from './analytics.js';
-const require = createRequire(import.meta.url);
 const POLICY_PROVIDER_MIGRATION = 'policy-provider-identity:v2';
 const EVENT_ORIGIN_INTENT_MIGRATION = 'event-origin-intent:v1';
 export class SessionRepository {
     db;
     constructor(path = ':memory:') {
+        let Database;
         try {
-            const Database = require('better-sqlite3');
-            this.db = new Database(path);
+            Database = requireFeaturePackage('better-sqlite3');
         }
-        catch {
-            throw new Error('session SQLite repository requires optional peer dependency better-sqlite3');
+        catch (cause) {
+            throw new Error('session SQLite catalog is unavailable because better-sqlite3 could not be loaded; ' +
+                'run `aiwg features install sqlite`, then retry. If the native build fails, install ' +
+                'Python 3, make, and a C/C++ compiler supported by node-gyp.', { cause });
         }
+        this.db = new Database(path);
         this.db.pragma('foreign_keys = ON');
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('busy_timeout = 5000');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.8.27",
+  "version": "2026.8.28",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",