@aiwg/cli 2026.10.11 → 2026.10.12

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

@@ -1,7 +1,7 @@
 {
   "$schema": "../../../schemas/models/model-catalog.v1.schema.json",
   "version": "1.0.0",
-  "refreshedAt": "2026-09-21",
+  "refreshedAt": "2026-10-27",
   "staleAfterDays": 90,
   "providers": {
     "antigravity": {
@@ -28,44 +28,94 @@
     "claude": {
       "roles": {
         "reasoning": {
-          "id": "claude-opus-5",
+          "id": "claude-opus-5-5",
           "status": "active",
-          "observed": false
+          "observed": true
         },
         "coding": {
-          "id": "claude-sonnet-5",
+          "id": "claude-sonnet-5-5",
           "status": "active",
-          "observed": false
+          "observed": true
         },
         "efficiency": {
-          "id": "claude-haiku-4-5",
+          "id": "claude-haiku-5-5",
           "status": "active",
-          "observed": false
+          "observed": true
         }
       },
       "sourceUrl": "https://platform.claude.com/docs/en/about-claude/models/overview",
-      "verifiedAt": "2026-09-21"
+      "verifiedAt": "2026-10-27",
+      "tiers": {
+        "flagship": {
+          "id": "claude-fable-5-1",
+          "status": "active",
+          "observed": true,
+          "selection": "user-elected"
+        },
+        "premium": {
+          "id": "claude-opus-5-5",
+          "status": "active",
+          "observed": true
+        },
+        "standard": {
+          "id": "claude-sonnet-5-5",
+          "status": "active",
+          "observed": true
+        },
+        "economy": {
+          "id": "claude-haiku-5-5",
+          "status": "active",
+          "observed": true
+        }
+      },
+      "verified_at": "2026-10-27",
+      "evidence": "Conductor-verified Claude Code harness current model list, 2026-10-27."
     },
     "codex": {
       "roles": {
         "reasoning": {
-          "id": "gpt-5.6-sol",
+          "id": "gpt-6.1-sol",
           "status": "active",
           "observed": true
         },
         "coding": {
-          "id": "gpt-5.6-terra",
+          "id": "gpt-6.1-terra",
           "status": "active",
           "observed": true
         },
         "efficiency": {
-          "id": "gpt-5.6-luna",
+          "id": "gpt-6-luna",
           "status": "active",
           "observed": true
         }
       },
       "sourceUrl": "https://learn.chatgpt.com/docs/models",
-      "verifiedAt": "2026-09-21"
+      "verifiedAt": "2026-10-27",
+      "tiers": {
+        "flagship": {
+          "id": "gpt-6-astra",
+          "status": "active",
+          "observed": true,
+          "selection": "user-elected"
+        },
+        "premium": {
+          "id": "gpt-6.1-sol",
+          "status": "active",
+          "observed": true
+        },
+        "standard": {
+          "id": "gpt-6.1-terra",
+          "status": "active",
+          "observed": true
+        },
+        "economy": {
+          "id": "gpt-6-luna",
+          "status": "active",
+          "observed": true
+        }
+      },
+      "verified_at": "2026-10-27",
+      "evidence": "Conductor-verified Codex CLI local model cache on titan (codex-cli 0.165.0), plus ~/.cache/aiwg/model-catalog.v1.json, 2026-10-27; no network verification by this worker."
     },
     "copilot": {
       "roles": {

package/dist/src/artifacts/binding-target-identity.js

@@ -0,0 +1,51 @@
+/** Resolve source aliases and bundle ownership before rule-target precedence. */
+import fs from 'node:fs';
+import path from 'node:path';
+function realpath(file) {
+    try {
+        return fs.realpathSync(file);
+    }
+    catch {
+        return path.resolve(file);
+    }
+}
+function sourcePath(file, options) {
+    const normalized = file.replace(/\\/g, '/');
+    const anchor = normalized.startsWith('agentic/code/') ? options.packageRoot : options.cwd;
+    return path.resolve(anchor ?? process.cwd(), normalized);
+}
+function identity(file, options) {
+    const absolute = sourcePath(file, options);
+    // Realpath handles symlinks; the supplied mapping handles materialized copies.
+    return realpath(options.logicalPath?.(realpath(absolute)) ?? absolute);
+}
+function inside(root, file) {
+    const relative = path.relative(root, file);
+    return relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`));
+}
+export function selectBindingTargetIdentities(entries, options = {}) {
+    const bundle = options.bundleRoot && identity(options.bundleRoot, options);
+    const snapshot = options.bundleRoot && sourcePath(options.bundleRoot, options);
+    const preferred = bundle && snapshot ? entries.filter(entry => inside(snapshot, sourcePath(entry.path, options)) || inside(bundle, identity(entry.path, options))) : [];
+    const candidates = preferred.length ? preferred : entries;
+    const unique = new Map();
+    for (const entry of candidates) {
+        const key = `${entry.type}:${identity(entry.path, options)}`;
+        const previous = unique.get(key);
+        // The projector must receive the entry in the bundle's current snapshot.
+        const inSnapshot = snapshot && inside(snapshot, sourcePath(entry.path, options));
+        if (!previous || inSnapshot)
+            unique.set(key, entry);
+    }
+    return [...unique.values()];
+}
+/** Retain the existing preference for canonical sources over packaged mirrors. */
+export function preferCanonicalBindingTargets(matches) {
+    if (matches.length > 1) {
+        const canonical = matches.filter(entry => !/(^|\/)agentic\/code\/plugins\//.test(entry.path.replace(/\\/g, '/')));
+        if (canonical.length === 1)
+            return canonical;
+    }
+    return matches;
+}
+//# sourceMappingURL=binding-target-identity.js.map

package/dist/src/artifacts/checksum-manifest.js

@@ -89,4 +89,16 @@ export function pruneManifest(manifest, cwd) {
     }
     return removed;
 }
+/** Format change-detection diagnostics from the same counters returned to callers. */
+export function formatManifestStats(stats) {
+    if (stats.checked === 0)
+        return [];
+    const messages = [
+        `  Change detection: ${stats.checked} checked, ${stats.statSkipped} skipped via stat, ${stats.checked - stats.statSkipped} content-read, ${stats.reindexed} re-indexed`,
+    ];
+    if (stats.pruned > 0) {
+        messages.push(`  Pruned ${stats.pruned} stale manifest entries (files no longer on disk)`);
+    }
+    return messages;
+}
 //# sourceMappingURL=checksum-manifest.js.map

package/dist/src/artifacts/index-builder.js

@@ -19,7 +19,7 @@ import { validateGateDocument } from '../gates/schema.js';
 import { INDEX_EXTRACTOR_VERSION, INDEX_VERSION, INDEX_DIR, OPERATIONAL_DISCOVERY_TYPES, PHASE_DIRECTORIES, GRAPH_CONFIGS, TEMPLATE_INDEX_EXTENSIONS, resolveGraphScanDir, loadUserGraphConfigs, loadGlobalGraphConfigs, resolveGraphBackendType, } from './types.js';
 import { parseCitationSidecar, citationResultToEdges, buildRefToPathMap } from './citation-parser.js';
 import { writeIndexFile, resolveIndexDir, loadGraphIndexFile, publishIndexFiles } from './index-reader.js';
-import { loadManifest, writeManifest, statMatches, makeEntry } from './checksum-manifest.js';
+import { loadManifest, writeManifest, statMatches, makeEntry, formatManifestStats } from './checksum-manifest.js';
 import { FRAMEWORK_RELATIONS_REVISION } from './framework-source-digest.js';
 import { normalizeOperationalState } from './operational-state.js';
 import { DEFAULT_PROJECT_AIWG_DIR, resolveProjectAiwgDir, } from '../config/project-artifacts.js';
@@ -963,6 +963,7 @@ function extractIndexArtifact(job, bindingOnly, warnings = []) {
     };
     return { checksum, entry };
 }
+/** Return change-detection counts for artifact builds; skipped/source builds return void. */
 export async function buildIndex(cwd, options = {}) {
     loadUserGraphConfigs(cwd);
     loadGlobalGraphConfigs();
@@ -993,7 +994,7 @@ export async function buildIndex(cwd, options = {}) {
             fs.mkdirSync(directory, { recursive: true });
             return staging ??= fs.mkdtempSync(path.join(directory, '.build-'));
         };
-        await buildIndexSnapshot(cwd, options, preparePublication, owned ? observation : undefined);
+        const stats = await buildIndexSnapshot(cwd, options, preparePublication, owned ? observation : undefined);
         // A receipt hit verifies the existing snapshot directly against the scan's
         // stats. There is no extraction interval to recheck. Real builds still probe
         // again after preparation so concurrent source changes remain pending.
@@ -1004,6 +1005,7 @@ export async function buildIndex(cwd, options = {}) {
             recordIndexVerification(owned, cwd, { before: observation.before, after, wallMs: Date.now() - start }, staging);
         if (staging)
             publishIndexFiles(staging, directory);
+        return stats;
     }
     catch (error) {
         if (owned) {
@@ -1141,14 +1143,9 @@ async function buildIndexSnapshot(cwd, options, preparePublication, observation)
         log(`Artifact index built in ${buildTimeMs}ms`);
         log(`  Indexed ${newCount} new, updated ${updatedCount}, unchanged ${unchangedCount}`);
         log(`  Total: ${total} artifacts`);
-        if (!force && manifestStats.checked > 0) {
-            const fastPath = manifestStats.statSkipped;
-            const slowPath = manifestStats.checked - manifestStats.statSkipped;
-            log(`  Change detection: ${manifestStats.checked} checked, ${fastPath} skipped via stat, ${slowPath} content-read, ${manifestStats.reindexed} re-indexed`);
-            if (manifestStats.pruned > 0) {
-                log(`  Pruned ${manifestStats.pruned} stale manifest entries (files no longer on disk)`);
-            }
-        }
+        if (!force)
+            for (const message of formatManifestStats(manifestStats))
+                log(message);
         const displayDir = graph ? indexOutputDir : `${INDEX_DIR}/`;
         log(`  Output: ${displayDir}`);
     };
@@ -1211,7 +1208,7 @@ async function buildIndexSnapshot(cwd, options, preparePublication, observation)
             if (observation)
                 observation.unchanged = true;
             reportBuild(buildTimeMs, files.length);
-            return;
+            return manifestStats;
         }
     }
     const publicationDir = preparePublication();
@@ -1245,6 +1242,7 @@ async function buildIndexSnapshot(cwd, options, preparePublication, observation)
                 ...(!force && existingEntries[relativePath] ? { existingChecksum: existingEntries[relativePath].checksum } : {}) });
         }
     const preparation = await runIndexPreparation(jobs, prepareIndexArtifact, import.meta.url, workers, options.onDiagnostic ?? (message => console.warn(`Index preparation: ${message}`)));
+    manifestStats.reindexed = preparation.results.filter(result => result.entry !== undefined).length;
     for (const result of preparation.results)
         for (const warning of result.warnings ?? []) {
             (options.onDiagnostic ?? (message => console.warn(`Index preparation: ${message}`)))(warning);
@@ -1313,7 +1311,6 @@ async function buildIndexSnapshot(cwd, options, preparePublication, observation)
                     log(`  unchanged (checksum): ${relativePath}`);
                 continue;
             }
-            manifestStats.reindexed++;
             nextManifestEntries[relativePath] = makeEntry(checksum, stat);
             entry = prepared.entry;
         }
@@ -1363,7 +1360,7 @@ async function buildIndexSnapshot(cwd, options, preparePublication, observation)
             if (manifestStats.checksumSkipped > 0 || projectionNeedsRepair)
                 writeBuildManifest(nextManifestEntries);
             reportBuild(buildTimeMs, total);
-            return;
+            return manifestStats;
         }
     }
     // Apply metadata supplements if configured (enriches filename-metadata nodes from sidecars)
@@ -1563,5 +1560,6 @@ async function buildIndexSnapshot(cwd, options, preparePublication, observation)
     writeBuildManifest(nextManifestEntries);
     // Report
     reportBuild(buildTimeMs, total);
+    return manifestStats;
 }
 //# sourceMappingURL=index-builder.js.map

package/dist/src/artifacts/query-engine.js

@@ -12,6 +12,7 @@ import { refreshFrameworkCapabilities, resolveFrameworkCorpusRoot, isCorpusBundl
 import { resolveFrameworkIndexRoot } from './framework-index-paths.js';
 import { ensureRelations, selectPrebuiltRelations, emptyRuleStats } from './relations.js';
 import { minimatch } from 'minimatch';
+import { selectBindingTargetIdentities, preferCanonicalBindingTargets } from './binding-target-identity.js';
 import { inferRuleActivation } from '../rules/activation.mjs';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -1624,7 +1625,7 @@ function findShowMatches(entries, types, needle) {
     return matches;
 }
 /** Preselect exact candidates once; the canonical resolver still owns precedence and ambiguity. */
-export function createRuleBindingTargetResolver(entries) {
+export function createRuleBindingTargetResolver(entries, options = {}) {
     const candidates = new Map();
     for (const entry of entries) {
         if (!['skill', 'agent', 'flow'].includes(entry.type))
@@ -1643,13 +1644,13 @@ export function createRuleBindingTargetResolver(entries) {
             candidates.set(key, selected);
         }
     }
-    return (type, id) => resolveRuleBindingTarget(candidates.get(`${type}\0${id}`) ?? [], type, id);
+    return (type, id, bundleRoot = options.bundleRoot) => resolveRuleBindingTarget(candidates.get(`${type}\0${id}`) ?? [], type, id, { ...options, bundleRoot });
 }
 /** Resolve exact rule binding IDs using the same precedence and ambiguity as show.
  * Canonical layout slugs remain valid when frontmatter names are display names.
  * Titles and filesystem paths are deliberately excluded (#2938).
  */
-export function resolveRuleBindingTarget(entries, type, id) {
+export function resolveRuleBindingTarget(entries, type, id, options = {}) {
     const exact = entries.filter(entry => {
         if (entry.type !== type)
             return false;
@@ -1660,14 +1661,7 @@ export function resolveRuleBindingTarget(entries, type, id) {
             : basename.replace(/\.[^.]+$/, '');
         return entry.name === id || discoveryIdForEntry(entry) === id || slug === id;
     });
-    let matches = findShowMatches(exact, [type], id);
-    // Generated plugin copies (agentic/code/plugins/*) mirror canonical framework
-    // and addon artifacts. Prefer the canonical source when it is unambiguous.
-    if (matches.length > 1) {
-        const canonical = matches.filter(entry => !/(^|\/)agentic\/code\/plugins\//.test(normalizeIndexedPath(entry.path)));
-        if (canonical.length === 1)
-            matches = canonical;
-    }
+    const matches = preferCanonicalBindingTargets(findShowMatches(selectBindingTargetIdentities(exact, options), [type], id));
     if (matches.length === 0)
         throw new Error(`Missing ${type} binding target: ${id}`);
     if (matches.length > 1)

package/dist/src/cli/handlers/doctor-help.js

@@ -0,0 +1,32 @@
+// Public doctor options and exit-status contract.
+export const DOCTOR_HELP = `aiwg doctor — check AIWG installation health
+
+Usage:
+  aiwg doctor [options]
+  aiwg -doctor [options]
+  aiwg --doctor [options]
+
+Options:
+  --deployment          Verify configured provider deployments
+  --provider <name>     Limit deployment verification to one provider
+  --bundle <name>       Limit deployment verification to one bundle
+  --scope <scope>       Verification scope: project or user
+  --user                Alias for --scope user
+  --qualify             With --probe-workers, record installation and configured model/role approval
+  --yes                 Confirm worker qualification without a terminal
+  --dry-run             With --probe-workers, preview qualification without writes
+  --cli NAME            Limit worker probes/qualification to one configured CLI
+  --decision-offload    Show offline advisory decision readiness and adoption report
+  --probe-workers       Run bounded worker CLI version probes (default: config-only, no subprocess)
+  --project-local       Include project-local artifact diagnostics
+  --json                Emit machine-readable output (with --probe-workers: one worker-probe record per CLI; with --deployment: deployment verification; with --decision-offload: offline snapshot)
+  --verbose, -v         Include verbose diagnostics
+  --help, -h            Show this help
+
+Exit status:
+  0  Checks completed; ordinary doctor warnings are advisory.
+  1  Diagnostic errors, failed or partial explicit worker qualification, or blocked recorded invocations.
+  2  Invalid usage.
+  --qualify uses the same exit status in text and JSON output.
+`;
+//# sourceMappingURL=doctor-help.js.map

package/dist/src/cli/handlers/gates.js

@@ -3,13 +3,14 @@ function jsonResult(value, exitCode = 0) {
 }
 function usage() {
     return [
-        'Usage: aiwg gates <validate|evaluate|show|list> [options]',
+        'Usage: aiwg gates <validate|evaluate|show|list|coverage> [options]',
         '',
         'Commands:',
         '  validate <pack|binding|report> <path> [--pack-dir <dir>] [--aiwg-root <dir>]',
         '  evaluate --binding <file> --metrics <file> --holdout <file> [--upstream <file>] --now <iso> --trusted-binding-digest <sha256> [--pack-dir <dir>] [--aiwg-root <dir>]',
         '  show <id> [--pack-dir <dir>] [--aiwg-root <dir>]',
         '  list [--namespace <ns>] [--rule [<rule-id>]] [--pack-dir <dir>] [--aiwg-root <dir>]',
+        '  coverage [--rule <rule-id>] [--json] [--pack-dir <dir>] [--aiwg-root <dir>]',
         '',
         'Packs live in <bundle>/gate-packs/*.gatepack.yaml|json and register as',
         'aiwg:<bundle>/<name> (shipped).',
@@ -77,7 +78,7 @@ async function executeGates(ctx) {
     try {
         if (!command || command === '--help' || command === '-h')
             return { exitCode: 0, message: usage(), rawOutput: true };
-        const { validateGateFile, evaluateGatesFromFiles, showGatePack, listGatePacks, packsReferencedByRule, } = await import('../../gates/driver.js');
+        const { validateGateFile, evaluateGatesFromFiles, showGatePack, listGatePacks, } = await import('../../gates/driver.js');
         const options = driverOptions(ctx);
         if (command === 'validate') {
             const args = positionals(ctx.args, 'validate');
@@ -115,27 +116,27 @@ async function executeGates(ctx) {
                 return { exitCode: 2, message: `gates show requires <id>\n\n${usage()}`, rawOutput: true };
             return jsonResult(showGatePack(id, options), 0);
         }
-        if (command === 'list') {
+        if (command === 'coverage' || command === 'list' && ctx.args.includes('--rule')) {
+            const { listRuleGateCoverage, formatRuleGateCoverage } = await import('../../rules/gate-coverage.js');
+            const value = takeOption(ctx.args, '--rule');
+            const rule = value && !value.startsWith('-') ? value : undefined;
+            const rules = listRuleGateCoverage(options, rule);
+            if (command === 'coverage') {
+                return ctx.args.includes('--json') ? jsonResult({ schema: 'aiwg-gates-coverage/v1', rules })
+                    : { exitCode: 0, message: formatRuleGateCoverage(rules), rawOutput: true };
+            }
             const namespace = takeOption(ctx.args, '--namespace');
-            const ruleIndex = ctx.args.indexOf('--rule');
-            const ruleValue = ruleIndex >= 0 ? ctx.args[ruleIndex + 1] : undefined;
-            const rule = ruleIndex >= 0 ? (ruleValue && !ruleValue.startsWith('-') ? ruleValue : null) : undefined;
             const packs = listGatePacks({ ...options, ...(namespace ? { namespace } : {}) });
-            if (rule === undefined)
-                return jsonResult({ schema: 'aiwg-gates-list/v1', packs }, 0);
-            if (rule === null) {
-                return jsonResult({
-                    schema: 'aiwg-gates-list/v1', packs,
-                    enforcedBy: { status: 'stub', note: 'Rule enforcedBy coverage is tracked in #2839; rules without enforcedBy remain guidance.' },
-                }, 0);
-            }
-            const referenced = new Set(await packsReferencedByRule(rule, options));
+            const referenced = new Set(rules.flatMap(item => item.enforcedBy.map(reference => reference.split('#')[0])));
             return jsonResult({
-                schema: 'aiwg-gates-list/v1', rule,
-                packs: packs.filter(pack => referenced.has(pack.id)),
-                enforcedBy: { status: 'stub', note: 'Rule enforcedBy coverage is tracked in #2839.' },
+                schema: 'aiwg-gates-list/v1', ...(rule ? { rule } : {}), rules,
+                packs: rule ? packs.filter(pack => referenced.has(pack.id)) : packs,
             }, 0);
         }
+        if (command === 'list') {
+            const namespace = takeOption(ctx.args, '--namespace');
+            return jsonResult({ schema: 'aiwg-gates-list/v1', packs: listGatePacks({ ...options, ...(namespace ? { namespace } : {}) }) });
+        }
         return { exitCode: 2, message: usage(), rawOutput: true };
     }
     catch (error) {

package/dist/src/cli/handlers/models-help.js

@@ -27,7 +27,7 @@ Artifact selectors and options:
   --drift                      Include catalog drift for sources/refresh
   --url <url>                  Remote catalog URL for refresh
   --help, -h                   Show this reference
-  TIER: economy | standard | premium | max-quality
+  TIER: economy | standard | premium | flagship (alias: max-quality)
 
 Direct worker resolution (plans an invocation; does not launch it):
   aiwg models resolve --role <role> --task <class> --group <group>
@@ -43,6 +43,12 @@ Direct worker resolution (plans an invocation; does not launch it):
   --transport                  Must match group execution transport (default: shell)
   --format                     JSON plan or POSIX shell command (default: json)
   --json                       Alias for --format json
+  --max-attempts <count>        Tighten total attempts, including the initial attempt
+  --timeout-ms <ms>             Tighten the hard stop; positive multiple of 1000 (whole seconds)
+  --max-output-tokens <count>   Tighten the existing task token budget (tokens)
+  --max-usd <amount>            Tighten the task cost ceiling (costUsd)
+                               Limits may only tighten resolved policy; larger values fail
+                               JSON includes ceilings and their origins
   --authorize-premium          Authorize premium for this resolution only
                                Agents require explicit human confirmation of escalation
 

package/dist/src/cli/handlers/models.js

@@ -144,7 +144,7 @@ async function resolveDirect(ctx, services) {
         return { exitCode: 2 };
     }
 }
-const TIERS = new Set(['economy', 'standard', 'premium', 'max-quality']);
+const TIERS = new Set(['economy', 'standard', 'premium', 'flagship', 'max-quality']);
 const PROVIDERS = new Set(Object.keys(loadProviderModelCapabilities().providers));
 function parseArgs(args) {
     const [subcommand = 'help', ...rest] = args;
@@ -241,7 +241,7 @@ function select(artifacts, parsed, useTierSelector = true) {
         && (!framework || item.framework === framework)));
 }
 function normalizedTier(tier) {
-    return tier === 'max-quality' ? 'premium' : tier ?? 'standard';
+    return tier === 'max-quality' ? 'flagship' : tier ?? 'standard';
 }
 function resolved(item, provider, catalog) {
     const policy = {
@@ -331,7 +331,7 @@ async function execute(ctx, services = { load: loadWorkerInputs }) {
         return { exitCode: 0 };
     }
     // Preserve artifact/native resolve when direct-only flags are absent.
-    if (ctx.args[0] === 'resolve' && ctx.args.slice(1).some(arg => /^--(?:task|group|brief|workdir|final-output|transport|format|authorize-premium)(?:=|$)/.test(arg))) {
+    if (ctx.args[0] === 'resolve' && ctx.args.slice(1).some(arg => /^--(?:task|group|brief|workdir|final-output|transport|format|authorize-premium|max-attempts|timeout-ms|max-output-tokens|max-usd)(?:=|$)/.test(arg))) {
         return resolveDirect(ctx, services);
     }
     if (await handleWorkerAdoptionArgs(ctx.args, ctx.cwd, 'models', ctx.signal, ctx.dryRun))

package/dist/src/cli/handlers/script-runner.js

@@ -120,11 +120,13 @@ export class DefaultScriptRunner {
                     clearTimeout(timeoutId);
                 if (killEscalationId)
                     clearTimeout(killEscalationId);
-                // On failure in capture mode, surface the captured stderr
-                if (options.capture && code !== 0 && capturedStderrBytes > 0) {
+                // On failure in capture mode, surface the captured stderr. Every
+                // failure carries a message so callers never print an empty ERROR.
+                if (options.capture && code !== 0) {
+                    const stderr = Buffer.concat(capturedStderr).toString().trim();
                     resolve({
                         exitCode: code ?? 1,
-                        message: Buffer.concat(capturedStderr).toString().trim(),
+                        message: stderr || `Script exited with code ${code ?? 1}: ${path.basename(fullPath)}`,
                     });
                 }
                 else {
@@ -183,8 +185,9 @@ export class DefaultScriptRunner {
             // the runner still supports arbitrary scripts via its subprocess path.
             const deployer = await import(pathToFileURL(fullPath).href);
             const exitCode = (await deployer.main(args, { capture: options.capture === true })) ?? 0;
-            const message = Buffer.concat(diagnostics).toString().trim();
-            return exitCode && message ? { exitCode, message } : { exitCode };
+            const message = Buffer.concat(diagnostics).toString().trim()
+                || (exitCode ? `Deployment script exited with code ${exitCode}: ${path.basename(fullPath)}` : '');
+            return exitCode || message ? { exitCode, message } : { exitCode };
         }
         catch (error) {
             const message = Buffer.concat(diagnostics).toString().trim()

package/dist/src/cli/handlers/sessions-intake.js

@@ -0,0 +1,104 @@
+// `aiwg sessions import --from-dir`: idempotent intake-directory batch import (#3168).
+import { join } from 'node:path';
+import { fingerprintSourceFile, intakeSourceId, isRecognisedIntakeFile, listIntakeDirFiles, summarizeIntakeReceipts, INTAKE_DIR_SCHEMA_VERSION, } from '../../sessions/index.js';
+export async function importFromDir(ctx, args, dir, deps) {
+    const { assertSupportedImportProvider, normalizeWorkspaceId, isDryRun, preview, ok, openRepository, adapterVersionFor, importSource, importFailureReason, } = deps;
+    const provider = assertSupportedImportProvider(args.values.get('--provider') ?? 'generic');
+    const workspaceId = args.values.has('--workspace')
+        ? normalizeWorkspaceId(ctx.cwd, args.values.get('--workspace'))
+        : 'default';
+    const prefix = args.values.get('--source-id');
+    const files = await listIntakeDirFiles(dir);
+    if (isDryRun(ctx, args)) {
+        return preview('import', {
+            fromDir: dir,
+            provider,
+            workspaceId,
+            sourceIdPrefix: prefix ?? null,
+            files: files.map((file) => {
+                const recognition = isRecognisedIntakeFile(provider, file);
+                return {
+                    file,
+                    sourceId: recognition.recognised ? intakeSourceId(prefix, file) : null,
+                    recognised: recognition.recognised,
+                    reason: recognition.reason ?? null,
+                };
+            }),
+            wouldPersist: false,
+        });
+    }
+    const repository = openRepository(ctx, args);
+    try {
+        const interrupted = new Map();
+        const receipts = [];
+        for (const file of files) {
+            const recognition = isRecognisedIntakeFile(provider, file);
+            const input = join(dir, file);
+            if (!recognition.recognised) {
+                receipts.push({
+                    file, sourceId: null, digest: null, status: 'skipped',
+                    reason: recognition.reason ?? 'unrecognised file', sessionsInserted: 0, eventsInserted: 0,
+                });
+                continue;
+            }
+            const sourceId = intakeSourceId(prefix, file);
+            let digest = null;
+            try {
+                const fingerprint = await fingerprintSourceFile({ selectedPath: input, allowedRoots: [dir] });
+                digest = fingerprint.digest;
+                const checkpoint = repository.getCheckpoint(sourceId, adapterVersionFor(provider));
+                if (checkpoint?.prefixDigest === digest && checkpoint.sourceSize === fingerprint.size) {
+                    receipts.push({
+                        file, sourceId, digest, status: 'already-imported',
+                        reason: 'content digest already imported', sessionsInserted: 0, eventsInserted: 0,
+                    });
+                    continue;
+                }
+            }
+            catch (error) {
+                receipts.push({
+                    file, sourceId, digest, status: 'rejected',
+                    reason: importFailureReason(error), sessionsInserted: 0, eventsInserted: 0,
+                });
+                continue;
+            }
+            const fileValues = new Map(args.values);
+            fileValues.delete('--from-dir');
+            fileValues.set('--source-id', sourceId);
+            try {
+                const result = await importSource(ctx, {
+                    command: 'import', positionals: [input], flags: new Set(args.flags),
+                    values: fileValues, codexRoots: args.codexRoots, exclude: args.exclude,
+                });
+                const data = result.envelope.data;
+                for (const run of data.interruptedRuns ?? [])
+                    interrupted.set(run.runId, run);
+                receipts.push({
+                    file, sourceId, digest, status: 'imported', reason: null,
+                    sessionsInserted: data.totals?.sessionsInserted ?? 0,
+                    eventsInserted: data.totals?.eventsInserted ?? 0,
+                });
+            }
+            catch (error) {
+                receipts.push({
+                    file, sourceId, digest, status: 'rejected',
+                    reason: importFailureReason(error), sessionsInserted: 0, eventsInserted: 0,
+                });
+            }
+        }
+        return ok('import', {
+            fromDir: dir,
+            provider,
+            workspaceId,
+            sourceIdPrefix: prefix ?? null,
+            schemaVersion: INTAKE_DIR_SCHEMA_VERSION,
+            files: receipts,
+            summary: summarizeIntakeReceipts(receipts),
+            interruptedRuns: [...interrupted.values()],
+        });
+    }
+    finally {
+        repository.close();
+    }
+}
+//# sourceMappingURL=sessions-intake.js.map