@aiwg/cli 2026.7.25 → 2026.8.1

package/agentic/code/providers/model-catalog.v1.json

@@ -0,0 +1,96 @@
+{
+  "$schema": "../../../schemas/models/model-catalog.v1.schema.json",
+  "version": "1.0.0",
+  "refreshedAt": "2026-07-20",
+  "staleAfterDays": 90,
+  "providers": {
+    "claude": {
+      "roles": {
+        "reasoning": { "id": "claude-opus-4-7", "status": "active", "observed": false },
+        "coding": { "id": "claude-sonnet-4-6", "status": "active", "observed": false },
+        "efficiency": { "id": "claude-haiku-4-5", "status": "active", "observed": false }
+      },
+      "sourceUrl": "https://docs.anthropic.com/en/docs/about-claude/models/overview", "verifiedAt": "2026-07-20"
+    },
+    "codex": {
+      "roles": {
+        "reasoning": { "id": "gpt-5.4", "status": "active", "observed": true },
+        "coding": { "id": "gpt-5.5", "status": "active", "observed": true },
+        "efficiency": { "id": "gpt-5.4-mini", "status": "active", "observed": true }
+      },
+      "sourceUrl": "https://learn.chatgpt.com/docs/agent-configuration/subagents", "verifiedAt": "2026-07-20"
+    },
+    "copilot": {
+      "roles": {
+        "reasoning": { "id": "claude-opus-4.6", "status": "unverified", "observed": false },
+        "coding": { "id": "claude-sonnet-4.6", "status": "unverified", "observed": false },
+        "efficiency": { "id": "gpt-5.1-codex-mini", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.github.com/en/copilot/reference/ai-models/supported-models", "verifiedAt": "2026-07-20"
+    },
+    "cursor": {
+      "roles": {
+        "reasoning": { "id": "claude-4.6-opus-high-thinking", "status": "unverified", "observed": false },
+        "coding": { "id": "claude-4.6-sonnet", "status": "unverified", "observed": false },
+        "efficiency": { "id": "auto", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://cursor.com/docs/models", "verifiedAt": "2026-07-20"
+    },
+    "factory": {
+      "roles": {
+        "reasoning": { "id": "heavy", "status": "active", "observed": false },
+        "coding": { "id": "medium", "status": "active", "observed": false },
+        "efficiency": { "id": "light", "status": "active", "observed": false }
+      },
+      "sourceUrl": "https://docs.factory.ai/cli/user-guides/choosing-your-model", "verifiedAt": "2026-07-20"
+    },
+    "opencode": {
+      "roles": {
+        "reasoning": { "id": "anthropic/claude-opus-4-7", "status": "unverified", "observed": false },
+        "coding": { "id": "anthropic/claude-sonnet-4-6", "status": "unverified", "observed": false },
+        "efficiency": { "id": "anthropic/claude-haiku-4-5", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://opencode.ai/docs/models", "verifiedAt": "2026-07-20"
+    },
+    "warp": {
+      "roles": {
+        "reasoning": { "id": "profile-selected", "status": "unverified", "observed": false },
+        "coding": { "id": "profile-selected", "status": "unverified", "observed": false },
+        "efficiency": { "id": "profile-selected", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.warp.dev/agent-platform/capabilities/agent-profiles-permissions", "verifiedAt": "2026-07-20"
+    },
+    "windsurf": {
+      "roles": {
+        "reasoning": { "id": "inherited", "status": "unverified", "observed": false },
+        "coding": { "id": "inherited", "status": "unverified", "observed": false },
+        "efficiency": { "id": "inherited", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.devin.ai/desktop/cascade/models", "verifiedAt": "2026-07-20"
+    },
+    "openclaw": {
+      "roles": {
+        "reasoning": { "id": "configured/reasoning", "status": "unverified", "observed": false },
+        "coding": { "id": "configured/coding", "status": "unverified", "observed": false },
+        "efficiency": { "id": "configured/efficiency", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://docs.openclaw.ai/tools/subagents", "verifiedAt": "2026-07-20"
+    },
+    "hermes": {
+      "roles": {
+        "reasoning": { "id": "global-delegation-model", "status": "unverified", "observed": false },
+        "coding": { "id": "global-delegation-model", "status": "unverified", "observed": false },
+        "efficiency": { "id": "global-delegation-model", "status": "unverified", "observed": false }
+      },
+      "sourceUrl": "https://hermes-agent.nousresearch.com/docs/user-guide/features/delegation", "verifiedAt": "2026-07-20"
+    },
+    "openhuman": {
+      "roles": {
+        "reasoning": { "id": "Hint(reasoning)", "status": "active", "observed": false },
+        "coding": { "id": "Hint(coding)", "status": "active", "observed": false },
+        "efficiency": { "id": "Hint(efficiency)", "status": "active", "observed": false }
+      },
+      "sourceUrl": "https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/agent/harness/definition.rs", "verifiedAt": "2026-07-20"
+    }
+  }
+}

package/agentic/code/providers/model-policy-evaluations.v1.json

@@ -0,0 +1,50 @@
+{
+  "version": "1.0.0",
+  "evaluatedAt": "2026-07-20",
+  "method": "Deterministic representative-fixture rubric: required instructions, bounded scope, tool contract, output contract, and risk controls are scored from canonical artifacts. Provider live resolution is tracked separately by #1807.",
+  "threshold": 0.8,
+  "cases": [
+    {
+      "tier": "economy",
+      "kind": "agent",
+      "artifact": "technical-writer",
+      "checks": ["instructions", "bounded-scope", "tool-contract", "output-contract"],
+      "score": 1
+    },
+    {
+      "tier": "economy",
+      "kind": "skill",
+      "artifact": "radar-status",
+      "checks": ["instructions", "bounded-scope", "tool-contract", "output-contract"],
+      "score": 1
+    },
+    {
+      "tier": "standard",
+      "kind": "agent",
+      "artifact": "software-implementer",
+      "checks": ["instructions", "multi-step-work", "tool-contract", "verification"],
+      "score": 1
+    },
+    {
+      "tier": "standard",
+      "kind": "skill",
+      "artifact": "uat-execute",
+      "checks": ["instructions", "multi-step-work", "tool-contract", "verification"],
+      "score": 1
+    },
+    {
+      "tier": "premium",
+      "kind": "agent",
+      "artifact": "security-architect",
+      "checks": ["instructions", "risk-controls", "tool-contract", "decision-rationale"],
+      "score": 1
+    },
+    {
+      "tier": "premium",
+      "kind": "skill",
+      "artifact": "security-gate",
+      "checks": ["instructions", "risk-controls", "tool-contract", "decision-rationale"],
+      "score": 1
+    }
+  ]
+}

package/agentic/code/providers/premium-model-allowlist.v1.json

@@ -0,0 +1,36 @@
+{
+  "version": "1.0.0",
+  "reviewedAt": "2026-07-20",
+  "exemptions": {
+    "agents": {
+      "factory-compat": "Compatibility documentation is not a deployable agent definition and has no YAML frontmatter.",
+      "openai-compat": "Compatibility documentation is not a deployable agent definition and has no YAML frontmatter.",
+      "windsurf-compat": "Compatibility documentation is not a deployable agent definition and has no YAML frontmatter."
+    },
+    "skills": {}
+  },
+  "agents": {
+    "architecture-designer": "Cross-system architecture tradeoffs have a high downstream rework cost.",
+    "aiwg-model-reasoning-worker": "Cross-domain architecture and synthesis assignments have high downstream rework cost.",
+    "cloud-architect": "Infrastructure topology decisions carry material reliability and security risk.",
+    "forensics-orchestrator": "Evidence-preserving investigation plans require high-confidence sequencing.",
+    "incident-responder": "Active incident containment decisions can cause irreversible operational impact.",
+    "legal-liaison": "Legal and regulatory interpretation has material compliance consequences.",
+    "legal-reviewer": "Legal approval findings can block release and require high-confidence review.",
+    "security-architect": "System threat boundaries and trust decisions are security-critical.",
+    "security-auditor": "Vulnerability findings and exploitability judgments are security-critical.",
+    "security-gatekeeper": "Release security gate decisions require high-confidence risk assessment.",
+    "vision-owner": "Product-direction decisions coordinate multiple downstream delivery tracks."
+  },
+  "skills": {
+    "best-practices-audit": "External evidence synthesis can change high-impact technical policy.",
+    "crisis-response": "Public crisis decisions carry material legal and reputational risk.",
+    "flow-deploy-to-production": "Production release and rollback decisions have high operational impact.",
+    "flow-incident-response": "Incident orchestration must preserve containment and evidence integrity.",
+    "legal-compliance": "Legal and regulatory compliance conclusions require high confidence.",
+    "physical-threat-modeling": "Physical safety and asset protection decisions are high impact.",
+    "security-assessment": "Security posture findings influence remediation and release decisions.",
+    "security-audit": "Security audit conclusions require high-confidence vulnerability analysis.",
+    "security-gate": "The skill makes a release-blocking security decision."
+  }
+}

package/bin/aiwg.mjs

@@ -21,7 +21,7 @@
  * @implements #919
  */
 
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import path from 'path';
 import { existsSync, readFileSync } from 'fs';
 import os from 'os';
@@ -186,7 +186,7 @@ async function resolveRouterPath() {
  * argv — handlers still see the flags. Call before the router loads so the
  * logger picks up the right level when it initializes.
  */
-async function applyVerbosityFromArgs(args) {
+async function applyVerbosityFromArgs(args, routerPath) {
   let level = 'warn'; // default
   if (args.includes('--quiet') || args.includes('-q')) level = 'error';
   else if (args.includes('-vvv')) { level = 'debug'; process.env['AIWG_DEBUG'] ??= '1'; }
@@ -201,10 +201,9 @@ async function applyVerbosityFromArgs(args) {
   // and set the level. Failing to import the logger here is non-fatal — the
   // logger's own fallbacks will pick up AIWG_LOG_LEVEL from env.
   try {
-    const routerPath = await resolveRouterPath();
     const logPath = path.join(path.dirname(routerPath), 'log.js');
     if (existsSync(logPath)) {
-      const { setLogLevel, setInvocationId, pruneOldLogs } = await import('file://' + logPath);
+      const { setLogLevel, setInvocationId, pruneOldLogs } = await import(pathToFileURL(logPath).href);
       setLogLevel(level);
       setInvocationId(invocationId);
       // One-shot prune of old JSONL files on startup. Bounded work; safe to
@@ -240,18 +239,24 @@ async function main() {
     return;
   }
 
+  // Resolve the active router once. In dev mode this points into the checkout,
+  // while packageRoot still points at the globally installed launcher.
+  const routerPath = await resolveRouterPath();
+  const activePackageRoot = path.resolve(path.dirname(routerPath), '..', '..', '..');
+
   // Wire up the logger level from -v/-vv/--quiet/AIWG_LOG_LEVEL before any
   // handler runs, and stamp the top-level invocation ID so the logger can
   // tag every record with it.
-  await applyVerbosityFromArgs(args);
+  await applyVerbosityFromArgs(args, routerPath);
 
   // Update notifier: print any pending notice from the previous run's
   // background check, then schedule the next background check. Both are
   // non-blocking — the current command never waits on the network.
   // Honors NO_UPDATE_NOTIFIER, CI=*, and non-TTY stderr.
-  const { scheduleBackgroundCheck, maybePrintNotice } = await import('../dist/src/update/notifier.mjs');
-  maybePrintNotice();
-  scheduleBackgroundCheck(packageRoot);
+  const notifierPath = path.join(activePackageRoot, 'dist', 'src', 'update', 'notifier.mjs');
+  const { scheduleBackgroundCheck, maybePrintNotice } = await import(pathToFileURL(notifierPath).href);
+  maybePrintNotice(activePackageRoot);
+  scheduleBackgroundCheck(activePackageRoot);
 
   // Top-level cancellation controller. SIGINT / SIGTERM flip it, long-running
   // handlers plumb ctx.signal through fetches and loops so Ctrl-C cancels
@@ -276,9 +281,8 @@ async function main() {
 
   // Direct in-process dispatch — no tsx fork, no facade, no router-loader.
   trace('resolve:router');
-  const routerPath = await resolveRouterPath();
   trace('import:router');
-  const { run } = await import('file://' + routerPath);
+  const { run } = await import(pathToFileURL(routerPath).href);
   trace('dispatch:begin');
   try {
     await run(args, { cwd: process.cwd(), signal: abortController.signal });

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

@@ -8,5 +8,6 @@
 export { run } from '../cli/router.js';
 export * from '../resources/index.js';
 export * from '../sessions/index.js';
+export * from '../memory/index.js';
 export * from '../security/threat-assessment-config.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/api/index.js

@@ -8,5 +8,6 @@
 export { run } from '../cli/router.js';
 export * from '../resources/index.js';
 export * from '../sessions/index.js';
+export * from '../memory/index.js';
 export * from '../security/threat-assessment-config.js';
 //# sourceMappingURL=index.js.map

package/dist/src/artifacts/cli.js

@@ -23,6 +23,7 @@ import { GRAPH_CONFIGS, OPERATIONAL_DISCOVERY_TYPES, OPERATIONAL_SHOW_TYPES, isO
 import { SUPPORTED_VIEWS } from './corpus-views/renderers.js';
 import { parseResourceSelector, readVerifiedRegularFile, } from '../resources/web-release.js';
 import { findPackageRoot } from '../cli/find-package-root.js';
+import { createResourceCredentialProvider } from '../auth/resource-credentials.js';
 const MAX_RESOURCE_TRUST_ROOT_BYTES = 64 * 1024;
 function webReleaseOptionsFromEnvironment() {
     const baseUrl = process.env.AIWG_RESOURCE_BASE_URL;
@@ -42,6 +43,7 @@ function webReleaseOptionsFromEnvironment() {
         }
     }
     return {
+        credentialProvider: createResourceCredentialProvider(process.env),
         ...(baseUrl === undefined ? {} : { baseUrl }),
         ...(cacheRoot === undefined ? {} : { cacheRoot }),
         ...(publicKeyPem === undefined ? {} : { publicKeyPem }),
@@ -937,12 +939,19 @@ async function handleExport(args) {
         console.log('  --out <path>           Write JSON or .shard output to a file');
         console.log('  --repo <name>          Source repository label (default: cwd basename)');
         console.log('  --privacy <level>      private, sanitized, or public (default: private)');
-        console.log('  --schema-version <v>   Export contract version: v1 or v2 (default: v1)');
+        console.log('  --schema-version <v>   Browser: v1|v2; shard: 2.0.0|1.2.0');
+        console.log('  --profile <name>       Shard profile: full-v1 (default) or core-v1');
+        console.log('  --fail-on-loss         Reject a full-v1 conversion that reports any loss');
+        console.log('  --dry-run              Build and report without writing the shard');
+        console.log('  --force                Replace an existing output path');
+        console.log('  --migrate-from <path>  Diagnose a source-less legacy shard (dry-run only)');
+        console.log('  --json                 Emit the machine-readable conversion report');
         console.log('  --generated-at <iso>   Override generated timestamp for deterministic fixtures');
         console.log('');
         console.log('Examples:');
         console.log('  aiwg index export --format fortemi --graph project --out aiwg-fortemi-index.json');
-        console.log('  aiwg index export --format fortemi-shard --graph project --out aiwg-index.shard');
+        console.log('  aiwg index export --format fortemi-shard --graph project --schema-version 2.0.0 --profile full-v1 --fail-on-loss --out aiwg-index.shard');
+        console.log('  aiwg index export --format fortemi-shard --migrate-from legacy.shard --dry-run --json');
         console.log('  aiwg index export --format fortemi --privacy sanitized --generated-at 2026-01-01T00:00:00.000Z');
         return;
     }
@@ -960,29 +969,65 @@ async function handleExport(args) {
         process.exit(1);
     }
     const generatedAt = parseFlagValue(args, '--generated-at', 'Error: --generated-at requires an ISO timestamp value');
-    const schemaVersion = parseFlagValue(args, '--schema-version', 'Error: --schema-version must be v1 or v2');
-    if (schemaVersion && !['v1', 'v2'].includes(schemaVersion)) {
-        console.error('Error: --schema-version must be v1 or v2');
+    const schemaVersion = parseFlagValue(args, '--schema-version', 'Error: --schema-version requires a value');
+    const profile = parseFlagValue(args, '--profile', 'Error: --profile requires a value');
+    const migrateFrom = parseFlagValue(args, '--migrate-from', 'Error: --migrate-from requires a shard path');
+    const dryRun = args.includes('--dry-run');
+    const json = args.includes('--json');
+    if (format === 'fortemi' && schemaVersion && !['v1', 'v2'].includes(schemaVersion)) {
+        console.error('Error: browser export --schema-version must be v1 or v2');
+        process.exit(1);
+    }
+    if (format === 'fortemi-shard' && schemaVersion && !['1.2.0', '2.0.0'].includes(schemaVersion)) {
+        console.error('Error: shard --schema-version must be 2.0.0 or 1.2.0');
         process.exit(1);
     }
-    if (format === 'fortemi-shard' && schemaVersion && schemaVersion !== 'v2') {
-        console.error('Error: --format fortemi-shard requires --schema-version v2');
+    if (format === 'fortemi-shard' && profile && !['full-v1', 'core-v1'].includes(profile)) {
+        console.error('Error: shard --profile must be full-v1 or core-v1');
         process.exit(1);
     }
-    if (format === 'fortemi-shard' && !out) {
+    if (format === 'fortemi-shard' && !out && !migrateFrom) {
         console.error('Error: --format fortemi-shard requires --out <path>');
         process.exit(1);
     }
     try {
         if (format === 'fortemi-shard') {
-            const { writeAiwgFortemiKnowledgeShard } = await import('./fortemi-shard-export.js');
+            const { diagnoseAiwgFortemiShardMigration, writeAiwgFortemiKnowledgeShard, } = await import('./fortemi-shard-export.js');
+            if (migrateFrom) {
+                if (!dryRun) {
+                    throw new Error('--migrate-from is diagnostic-only and requires --dry-run; '
+                        + 'source-less core-v1 artifacts cannot be promoted losslessly.');
+                }
+                const diagnosis = diagnoseAiwgFortemiShardMigration(process.cwd(), migrateFrom);
+                if (json)
+                    console.log(JSON.stringify(diagnosis, null, 2));
+                else {
+                    console.log(`Migration supported: no`);
+                    console.log(`Diagnostic: ${diagnosis.diagnostic}`);
+                    console.log(`Action: ${diagnosis.action}`);
+                }
+                return;
+            }
             const result = await writeAiwgFortemiKnowledgeShard(process.cwd(), out, {
                 graph,
                 repo,
                 privacy: privacy,
                 generatedAt,
+                schemaVersion: schemaVersion,
+                profile: profile,
+                failOnLoss: args.includes('--fail-on-loss'),
+                dryRun,
+                overwrite: args.includes('--force'),
             });
-            console.log(`Exported ${result.items} AIWG records to ${result.outPath} (${result.bytes} bytes)`);
+            if (json)
+                console.log(JSON.stringify(result, null, 2));
+            else {
+                const action = result.written ? 'Exported' : 'Would export';
+                console.log(`${action} ${result.items} AIWG records as `
+                    + `${result.conversion.schemaVersion}/${result.conversion.profile} `
+                    + `to ${result.outPath} (${result.bytes} bytes; `
+                    + `${result.conversion.losses.length} losses)`);
+            }
             return;
         }
         const { buildAiwgFortemiIndexExport, writeAiwgFortemiIndexExport } = await import('./browser-export.js');

package/dist/src/artifacts/fortemi-shard-export.js

@@ -1,7 +1,20 @@
 import fs from "fs";
 import path from "path";
 import { buildAiwgFortemiIndexExport, } from "./browser-export.js";
-async function loadFortemiShardConverter() {
+const SUPPORTED_SHARD_TUPLES = new Set([
+    "1.2.0/core-v1",
+    "2.0.0/full-v1",
+]);
+export function resolveAiwgFortemiShardTuple(options) {
+    const schemaVersion = options.schemaVersion ?? "2.0.0";
+    const profile = options.profile ?? "full-v1";
+    if (!SUPPORTED_SHARD_TUPLES.has(`${schemaVersion}/${profile}`)) {
+        throw new Error(`Unsupported Fortemi Knowledge Shard tuple ${schemaVersion}/${profile}; `
+            + "supported tuples are 2.0.0/full-v1 and 1.2.0/core-v1.");
+    }
+    return { schemaVersion, profile };
+}
+async function loadFortemiShardConverters() {
     let core;
     try {
         core = (await import(
@@ -10,35 +23,111 @@ async function loadFortemiShardConverter() {
     catch {
         throw new Error("Portable Fortemi shard export requires @fortemi/core with aiwgFortemiIndexToKnowledgeShard.");
     }
-    if (!core.aiwgFortemiIndexToKnowledgeShard) {
-        throw new Error("Installed @fortemi/core does not support portable AIWG shards; upgrade to the release containing aiwgFortemiIndexToKnowledgeShard.");
+    if (!core.aiwgFortemiIndexToKnowledgeShard
+        || !core.aiwgFortemiIndexToKnowledgeShardWithReport) {
+        throw new Error("Installed @fortemi/core does not support both public AIWG shard converters; "
+            + "upgrade to a compatible published release.");
     }
-    return core.aiwgFortemiIndexToKnowledgeShard;
+    return core;
 }
-export async function buildAiwgFortemiKnowledgeShard(cwd, options = {}, converter) {
+export async function buildAiwgFortemiKnowledgeShardWithReport(cwd, options = {}, converter, reportConverter) {
     const exported = buildAiwgFortemiIndexExport(cwd, {
         ...options,
         schemaVersion: "v2",
     });
-    const convert = converter ?? (await loadFortemiShardConverter());
-    return convert(exported, {
-        createdAt: options.generatedAt,
-        matricVersion: "aiwg",
-    });
+    const tuple = resolveAiwgFortemiShardTuple(options);
+    const needsCore = tuple.profile === "core-v1" ? !converter : !reportConverter;
+    const core = needsCore ? await loadFortemiShardConverters() : null;
+    if (tuple.profile === "core-v1") {
+        const archive = await (converter ?? core.aiwgFortemiIndexToKnowledgeShard)(exported, { createdAt: options.generatedAt, matricVersion: "aiwg" });
+        return {
+            ...tuple,
+            success: true,
+            lossless: true,
+            losses: [],
+            receipt: null,
+            archive,
+        };
+    }
+    const result = await (reportConverter ?? core.aiwgFortemiIndexToKnowledgeShardWithReport)(exported, { createdAt: options.generatedAt, matricVersion: "aiwg" });
+    if (!result.success || !result.archive) {
+        throw new Error("Fortemi full-v1 conversion failed without producing an archive; losses="
+            + JSON.stringify(result.losses));
+    }
+    if (options.failOnLoss && (!result.lossless || result.losses.length > 0)) {
+        throw new Error(`Fortemi full-v1 conversion reported ${result.losses.length} loss(es); `
+            + "archive was not written because --fail-on-loss was set.");
+    }
+    return {
+        ...tuple,
+        success: result.success,
+        lossless: result.lossless,
+        losses: result.losses,
+        receipt: result.receipt,
+        archive: result.archive,
+    };
+}
+export async function buildAiwgFortemiKnowledgeShard(cwd, options = {}, converter, reportConverter) {
+    return (await buildAiwgFortemiKnowledgeShardWithReport(cwd, options, converter, reportConverter)).archive;
 }
-export async function writeAiwgFortemiKnowledgeShard(cwd, outPath, options = {}, converter) {
+export async function writeAiwgFortemiKnowledgeShard(cwd, outPath, options = {}, converter, reportConverter) {
     const exported = buildAiwgFortemiIndexExport(cwd, {
         ...options,
         schemaVersion: "v2",
     });
-    const convert = converter ?? (await loadFortemiShardConverter());
-    const shard = await convert(exported, {
-        createdAt: options.generatedAt,
-        matricVersion: "aiwg",
-    });
+    const conversion = await buildAiwgFortemiKnowledgeShardWithReport(cwd, options, converter, reportConverter);
     const resolved = path.resolve(cwd, outPath);
+    const report = {
+        bytes: conversion.archive.byteLength,
+        items: exported.items.length,
+        outPath: resolved,
+        written: !options.dryRun,
+        conversion: {
+            schemaVersion: conversion.schemaVersion,
+            profile: conversion.profile,
+            success: conversion.success,
+            lossless: conversion.lossless,
+            losses: conversion.losses,
+            receipt: conversion.receipt,
+        },
+    };
+    if (options.dryRun)
+        return report;
+    if (fs.existsSync(resolved) && !options.overwrite) {
+        throw new Error(`Refusing to overwrite existing shard ${resolved}; choose a new path or pass --force.`);
+    }
     fs.mkdirSync(path.dirname(resolved), { recursive: true });
-    fs.writeFileSync(resolved, shard);
-    return { bytes: shard.byteLength, items: exported.items.length, outPath: resolved };
+    const temporary = `${resolved}.tmp-${process.pid}`;
+    try {
+        fs.writeFileSync(temporary, conversion.archive, { flag: "wx" });
+        if (options.overwrite) {
+            fs.renameSync(temporary, resolved);
+        }
+        else {
+            fs.linkSync(temporary, resolved);
+            fs.unlinkSync(temporary);
+        }
+    }
+    catch (error) {
+        if (fs.existsSync(temporary))
+            fs.unlinkSync(temporary);
+        throw error;
+    }
+    return report;
+}
+export function diagnoseAiwgFortemiShardMigration(cwd, inputPath) {
+    const resolved = path.resolve(cwd, inputPath);
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+        throw new Error(`Legacy shard input does not exist or is not a regular file: ${resolved}`);
+    }
+    return {
+        supported: false,
+        inputPath: resolved,
+        mutationPlanned: false,
+        diagnostic: "Source-less core-v1 to full-v1 conversion is unsupported because omitted rich "
+            + "components cannot be reconstructed without loss.",
+        action: "Regenerate from the source-backed AIWG index with "
+            + "--schema-version 2.0.0 --profile full-v1; retain the legacy shard for rollback.",
+    };
 }
 //# sourceMappingURL=fortemi-shard-export.js.map

package/dist/src/artifacts/types.js

@@ -178,6 +178,10 @@ export const BUILTIN_GRAPH_CONFIGS = {
             '~/.aiwg/flows',
             '~/.aiwg/runbooks',
             '~/.aiwg/frameworks',
+            '~/.aiwg/addons',
+            '~/.aiwg/extensions',
+            '~/.aiwg/plugins',
+            '~/.aiwg/providers',
         ],
         extensions: [...DEFAULT_INDEX_EXTENSIONS],
         shared: true,