@aiwg/cli 2026.8.15 → 2026.8.17

package/dist/src/providers/transformation-receipt-integration.js

@@ -1,5 +1,5 @@
-import { createHash } from 'node:crypto';
-import { access, lstat, readFile, readdir } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { access, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { readAiwgConfig } from '../config/aiwg-config.js';
@@ -25,6 +25,65 @@ const FRAMEWORK_BUNDLE_DIRS = {
     validation: 'validation-complete',
     'knowledge-base': 'knowledge-base',
 };
+const PROVIDER_TRANSFORMATION_EVIDENCE_STATE_SCHEMA = 'aiwg.provider-transformation-evidence-state.v1';
+export function providerTransformationEvidenceStatePath(projectRoot, provider, scope) {
+    const receiptPath = providerTransformationReceiptPath(projectRoot, provider, scope);
+    return receiptPath.replace(/\.json$/, '.evidence.json');
+}
+function validateEvidenceState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('evidence state must be an object');
+    const state = value;
+    if (state.schemaVersion !== PROVIDER_TRANSFORMATION_EVIDENCE_STATE_SCHEMA)
+        throw new Error('unsupported evidence state schema');
+    if (!Number.isFinite(Date.parse(state.recordedAt)))
+        throw new Error('recordedAt must be an RFC 3339 date-time');
+    if (state.scope !== 'project' && state.scope !== 'user')
+        throw new Error('scope must be project or user');
+    if (!['local-source', 'source-unavailable', 'verification-failed'].includes(state.disposition)) {
+        throw new Error('unsupported source evidence disposition');
+    }
+    if (!state.provider || state.provider.includes('/') || state.provider.includes('\\'))
+        throw new Error('provider is invalid');
+    return state;
+}
+async function writeEvidenceState(options, disposition) {
+    const provider = normalizeProviderDefinitionId(options.provider) ?? options.provider;
+    const target = providerTransformationEvidenceStatePath(options.projectRoot, provider, options.scope);
+    await mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
+    const temporary = path.join(path.dirname(target), `.${path.basename(target)}.${randomUUID()}.tmp`);
+    const state = {
+        schemaVersion: PROVIDER_TRANSFORMATION_EVIDENCE_STATE_SCHEMA,
+        recordedAt: options.generatedAt ?? new Date().toISOString(),
+        provider,
+        scope: options.scope,
+        disposition,
+    };
+    try {
+        await writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        await rename(temporary, target);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    await rm(providerTransformationReceiptPath(options.projectRoot, provider, options.scope), { force: true });
+    return target;
+}
+async function readEvidenceState(options) {
+    const provider = normalizeProviderDefinitionId(options.provider) ?? options.provider;
+    try {
+        const state = validateEvidenceState(JSON.parse(await readFile(providerTransformationEvidenceStatePath(options.projectRoot, provider, options.scope), 'utf8')));
+        if (state.provider !== provider || state.scope !== options.scope)
+            throw new Error('evidence state identity does not match deployment');
+        return state;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
 function sha256(value) {
     return createHash('sha256').update(value).digest('hex');
 }
@@ -225,6 +284,17 @@ function receiptBundles(installed, options) {
         .sort();
     return deployed.length > 0 ? deployed : [...new Set(options.requestedBundles)].sort();
 }
+/**
+ * Return whether the deployed provider surface includes project-local source
+ * material that cannot be authenticated by an AIWG signed web release.
+ */
+export async function providerReceiptHasLocalSources(rawOptions) {
+    const provider = normalizeProviderDefinitionId(rawOptions.provider) ?? rawOptions.provider;
+    const options = { ...rawOptions, provider };
+    const installed = await installedEntries(options);
+    return receiptBundles(installed, options)
+        .some(bundle => installed[bundle]?.source === 'project-local');
+}
 /**
  * Convert an already signature-verified web release into the stable verifier
  * result contract for the complete canonical bundle consumed by deployment.
@@ -375,6 +445,27 @@ export async function resolveProviderReceiptRuntimeEvidence(rawOptions) {
     };
 }
 export async function finalizeProviderTransformationReceipt(options) {
+    if (options.sourceDisposition) {
+        const evidenceStatePath = await writeEvidenceState(options, options.sourceDisposition);
+        if (options.sourceDisposition === 'local-source') {
+            return {
+                status: 'policy-exempt',
+                receiptPath: null,
+                evidenceStatePath,
+                outputCount: 0,
+                reason: 'local-source development deployments are exempt from signed-release receipt issuance',
+            };
+        }
+        return {
+            status: options.sourceDisposition === 'source-unavailable' ? 'source-unavailable' : 'skipped',
+            receiptPath: null,
+            evidenceStatePath,
+            outputCount: 0,
+            reason: options.sourceDisposition === 'source-unavailable'
+                ? 'verified signed-release source evidence is not available from cache or configured resource access'
+                : 'canonical source verification failed',
+        };
+    }
     if (!options.sourceVerifications) {
         return {
             status: 'skipped',
@@ -412,9 +503,11 @@ export async function finalizeProviderTransformationReceipt(options) {
         transformer: evidence.transformer,
         outputPaths: evidence.outputPaths,
     });
+    const receiptPath = await writeProviderTransformationReceipt(options.projectRoot, receipt);
+    await rm(providerTransformationEvidenceStatePath(options.projectRoot, evidence.provider, options.scope), { force: true });
     return {
         status: 'written',
-        receiptPath: await writeProviderTransformationReceipt(options.projectRoot, receipt),
+        receiptPath,
         outputCount: receipt.outputs.length,
     };
 }
@@ -425,6 +518,40 @@ export async function diagnoseIntegratedProviderTransformationReceipt(options) {
         await access(receiptPath);
     }
     catch {
+        const state = await readEvidenceState(options);
+        if (state?.disposition === 'local-source') {
+            return {
+                status: 'policy-exempt',
+                receiptPath,
+                checkedOutputs: 0,
+                findings: [{
+                        kind: 'policy-exempt',
+                        message: 'This local-source development deployment is explicitly exempt from signed-release transformation receipts.',
+                    }],
+            };
+        }
+        if (state?.disposition === 'source-unavailable') {
+            return {
+                status: 'source-evidence-unavailable',
+                receiptPath,
+                checkedOutputs: 0,
+                findings: [{
+                        kind: 'source-evidence-unavailable',
+                        message: 'The deployment succeeded, but verified signed-release source evidence was unavailable from cache or configured resource access.',
+                    }],
+            };
+        }
+        if (state?.disposition === 'verification-failed') {
+            return {
+                status: 'drifted',
+                receiptPath,
+                checkedOutputs: 0,
+                findings: [{
+                        kind: 'source-verification-failure',
+                        message: 'Canonical source verification failed during receipt finalization.',
+                    }],
+            };
+        }
         return {
             status: 'missing-receipt',
             receiptPath,

package/dist/src/security/artifact-verifier.js

@@ -1,4 +1,4 @@
-import { ARTIFACT_TRUST_STATE_SCHEMA_VERSION, channelStateKey, decodeBase64, dssePae, isIdentityRevoked, parseTrustRoot, publicKeyFingerprint, scopeMatches, selectDelegations, sha256, validateTrustState, verifyBytes, } from './artifact-trust.js';
+import { ARTIFACT_TRUST_STATE_SCHEMA_VERSION, canonicalJson, channelStateKey, decodeBase64, dssePae, isIdentityRevoked, parseTrustRoot, publicKeyFingerprint, scopeMatches, selectDelegations, sha256, validateTrustState, verifyBytes, } from './artifact-trust.js';
 export const ARTIFACT_VERIFICATION_RESULT_SCHEMA_VERSION = 'aiwg.verify.result.v1';
 export const ARTIFACT_VERIFICATION_EXIT_CODES = {
     verified: 0,
@@ -351,6 +351,12 @@ export async function verifyArtifact(input) {
             identities: allAuthenticated.map(identity => identity.id).sort(),
         });
     }
+    if (!Buffer.from(canonicalJson(statement), 'utf8').equals(payload)) {
+        return result('mismatched', input, [{ code: 'NONCANONICAL_SIGNED_PAYLOAD', message: 'Signed provenance payload is not canonical JSON' }], {
+            ...common,
+            identities: allAuthenticated.map(identity => identity.id).sort(),
+        });
+    }
     const scopeInput = {
         assetType: statement.predicate.assetType,
         namespace: statement.predicate.publisher.namespace,

package/dist/src/serve/pty-bridge.js

@@ -695,19 +695,14 @@ export async function handlePtyConnection(sessionId, ws, command = 'aiwg', cmdAr
         }
     }
     else if (!session.exited) {
-        // Reconnect to existing session — replay buffer
+        // Reconnect to an existing session by replaying the complete retained
+        // buffer. Do not trim at the last full-screen erase: terminal erase
+        // sequences repaint the current viewport but xterm still needs the bytes
+        // that preceded them to reconstruct scrollback when a user switches away
+        // from a session and later returns (#2146).
         registry.addClient(sessionId, clientId, ws);
         if (session.outputBuffer) {
-            // Trim replay to start from the last full-screen erase so that tmux's
-            // screen-init sequences (cursor moves, status-bar paint) from before the
-            // erase don't render as literal garbage in a fresh xterm.js context.
-            // Everything before \x1b[2J would be cleared by the erase anyway;
-            // everything after is the session content tmux redrew (MOTD, history, etc).
-            // If no erase is found, replay the whole buffer unchanged.
-            const ERASE = '\x1b[2J';
-            const lastErase = session.outputBuffer.lastIndexOf(ERASE);
-            const replay = lastErase !== -1 ? session.outputBuffer.slice(lastErase) : session.outputBuffer;
-            ws.send(JSON.stringify({ type: 'data', payload: replay }));
+            ws.send(JSON.stringify({ type: 'data', payload: session.outputBuffer }));
         }
     }
     else {

package/dist/src/skills/run.js

@@ -25,6 +25,8 @@ import { spawn } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { resolveRuntime, supportedRuntimes } from './runtime.js';
+import { recordTypeForEntry, stableRecordId } from '../artifacts/browser-export.js';
+import { loadFortemiCoreMetadataEntries } from '../artifacts/fortemi-core-query-adapter.js';
 /**
  * Resolve the AIWG installation root. Prefers `$AIWG_ROOT` env, falls
  * back to the channel manager's framework-root resolver.
@@ -53,22 +55,29 @@ async function findSkillEntry(cwd, name) {
     const reader = await import('../artifacts/index-reader.js');
     const entries = [];
     for (const g of ['framework', 'project', 'codebase']) {
-        const idx = reader.loadGraphIndexFile(cwd, 'metadata.json', g);
-        if (idx)
-            entries.push(...Object.values(idx.entries));
+        const canonical = loadFortemiCoreMetadataEntries(cwd, g);
+        if (canonical.entries.length > 0) {
+            entries.push(...canonical.entries);
+        }
+        else {
+            const idx = reader.loadGraphIndexFile(cwd, 'metadata.json', g);
+            if (idx)
+                entries.push(...Object.values(idx.entries));
+        }
     }
     if (entries.length === 0) {
         const legacy = reader.loadMetadataIndex(cwd);
         if (legacy)
             entries.push(...Object.values(legacy.entries));
     }
-    const skills = entries.filter(e => e.type === 'skill');
+    const skills = entries.filter(e => e.type === 'skill' || e.type === 'aiwg.skill');
     const needle = name.trim();
     // Basename match — skills are conventionally `<dir>/SKILL.md`
     const matches = skills.filter(e => {
         const dir = path.basename(path.dirname(e.path));
         const stem = path.basename(e.path).replace(/\.[^.]+$/, '');
-        return dir === needle || stem === needle || e.path === needle;
+        const id = stableRecordId(recordTypeForEntry({ ...e, type: 'skill' }, 'v2'), e.path);
+        return id === needle || e.name === needle || dir === needle || stem === needle || e.path === needle;
     });
     if (matches.length === 0)
         return null;
@@ -248,7 +257,7 @@ export async function main(args, env) {
     });
 }
 function printUsage() {
-    console.log('Usage: aiwg run skill <name> [--cwd <path>] [-- <args...>]');
+    console.log('Usage: aiwg run skill <stable-id-or-name> [--cwd <path>] [-- <args...>]');
     console.log('');
     console.log('Examples:');
     console.log('  aiwg run skill voice-apply -- --voice technical-authority --input draft.md');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.8.15",
+  "version": "2026.8.17",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",
@@ -67,6 +67,7 @@
   "dependencies": {
     "@fortemi/core": "2026.7.15",
     "@modelcontextprotocol/sdk": "^1.30.0",
+    "ajv": "^8.20.0",
     "chalk": "^4.1.2",
     "chokidar": "^4.0.3",
     "commander": "^12.1.0",