@aiwg/cli 2026.7.25 → 2026.8.1

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

@@ -0,0 +1,97 @@
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { CodexJobExecutor } from '../../jobs/executor.js';
+import { loadJobFlow, resolveWorkspaceFile } from '../../jobs/flow.js';
+import { GiteaWorkItemClient } from '../../jobs/gitea.js';
+import { renderExternalTrigger } from '../../jobs/render.js';
+import { runExternalJob } from '../../jobs/runner.js';
+import { AiwgError, EXIT_CODES, handlerResultFromError } from '../errors.js';
+function option(args, name) {
+    const index = args.indexOf(name);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function usage(message) {
+    throw new AiwgError({ code: 'ERR_USAGE_JOB', message, exitCode: EXIT_CODES.USAGE, hint: 'Run `aiwg job help` for usage.' });
+}
+function help() {
+    console.log(`AIWG external-trigger jobs
+
+Usage:
+  aiwg job validate <flow>
+  aiwg job render-cron <flow> [--format cron|systemd|gitea-actions]
+  aiwg job run <flow> --once [--state-dir <absolute-path>] [--json]
+
+The operating system or CI owns time. AIWG validates and executes one reviewed job.`);
+}
+async function validateFiles(flow) {
+    const workspace = await fs.realpath(flow.spec.executor.workspace);
+    if (workspace !== flow.spec.executor.workspace) {
+        throw new Error('executor.workspace must be canonical (no symlink or relative segments)');
+    }
+    const prompt = resolveWorkspaceFile(flow, flow.spec.executor.prompt);
+    const schema = resolveWorkspaceFile(flow, flow.spec.executor.resultSchema);
+    const [promptStat, schemaSource] = await Promise.all([fs.stat(prompt), fs.readFile(schema, 'utf8'), fs.access(flow.spec.executor.binary, constants.X_OK)]);
+    if (!promptStat.isFile())
+        throw new Error('executor.prompt must resolve to a regular file');
+    JSON.parse(schemaSource);
+    for (const root of flow.spec.security.approvedAttachmentRoots) {
+        const [canonical, stat] = await Promise.all([fs.realpath(root), fs.stat(root)]);
+        if (canonical !== root || !stat.isDirectory())
+            throw new Error('approvedAttachmentRoots must contain canonical directories');
+    }
+}
+async function execute(ctx) {
+    try {
+        const [subcommand = 'help', flowArg] = ctx.args;
+        if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+            help();
+            return { exitCode: 0 };
+        }
+        if (!['validate', 'render-cron', 'run'].includes(subcommand))
+            usage(`Unknown job subcommand: ${subcommand}`);
+        if (!flowArg || flowArg.startsWith('-'))
+            usage(`job ${subcommand} requires a flow file`);
+        const loaded = await loadJobFlow(flowArg, ctx.cwd);
+        await validateFiles(loaded.flow);
+        if (subcommand === 'validate') {
+            console.log(JSON.stringify({ valid: true, apiVersion: loaded.flow.apiVersion, kind: loaded.flow.kind, name: loaded.flow.metadata.name }));
+            return { exitCode: 0 };
+        }
+        if (subcommand === 'render-cron') {
+            const format = (option(ctx.args.slice(2), '--format') ?? 'cron');
+            if (!['cron', 'systemd', 'gitea-actions'].includes(format))
+                usage(`Unsupported scheduler format: ${format}`);
+            console.log(renderExternalTrigger(loaded.flow, loaded.file, format));
+            return { exitCode: 0 };
+        }
+        if (!ctx.args.includes('--once'))
+            usage('job run requires --once; AIWG does not own a resident scheduler');
+        const stateRoot = option(ctx.args.slice(2), '--state-dir');
+        if (stateRoot && !stateRoot.startsWith('/'))
+            usage('--state-dir must be absolute');
+        if (stateRoot && path.resolve(stateRoot) === path.parse(path.resolve(stateRoot)).root)
+            usage('--state-dir must not be a filesystem root');
+        const client = await GiteaWorkItemClient.create(loaded.flow);
+        const result = await runExternalJob({
+            flow: loaded.flow,
+            client,
+            executor: new CodexJobExecutor(),
+            ...(stateRoot ? { stateRoot } : {}),
+            signal: ctx.signal,
+        });
+        console.log(JSON.stringify(result, null, ctx.args.includes('--json') ? 2 : 0));
+        return { exitCode: result.status === 'failed-verification' ? EXIT_CODES.GENERAL : EXIT_CODES.OK };
+    }
+    catch (error) {
+        return handlerResultFromError(error);
+    }
+}
+export const jobHandler = {
+    id: 'job',
+    name: 'External Job',
+    description: 'Validate, render, or run one externally triggered provider job',
+    category: 'orchestration',
+    aliases: ['job'],
+    execute,
+};
+//# sourceMappingURL=job.js.map

package/dist/src/cli/handlers/resource-versions.js

@@ -3,6 +3,7 @@ import { loadResourceTrustRootFile, readVerifiedRegularFile, resolveWebRelease,
 import { getProjectDir } from "../../config/aiwg-config.js";
 import { cleanWebResourceCache } from "../../resources/cache-cleanup.js";
 import { writeWebResourceLock } from "../../resources/lockfile.js";
+import { createResourceCredentialProvider } from "../../auth/resource-credentials.js";
 const MAX_RESOURCE_MANIFEST_BYTES = 4 * 1024 * 1024;
 const DEFAULT_CHANNELS = ["stable", "latest", "canary", "main"];
 function usage() {
@@ -82,6 +83,7 @@ function webReleaseOptionsFromEnvironment() {
         ? undefined
         : loadResourceTrustRootFile(path.resolve(trustRootFile));
     return {
+        credentialProvider: createResourceCredentialProvider(process.env),
         ...(baseUrl === undefined ? {} : { baseUrl }),
         ...(cacheRoot === undefined ? {} : { cacheRoot }),
         ...(publicKeyPem === undefined ? {} : { publicKeyPem }),

package/dist/src/cli/handlers/runtime-info.js

@@ -258,7 +258,7 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
             console.log(`Catalog: ${summary.catalogPath}`);
             // Scheduler backend detection
             const { execSync } = await import('child_process');
-            let schedulerBackend = 'aiwg-cli (daemon)';
+            let schedulerBackend = 'external trigger required (system cron/systemd/CI)';
             let chronyInstalled = false;
             try {
                 execSync('which chronyc 2>/dev/null || which chronyd 2>/dev/null', { stdio: 'pipe' });
@@ -273,7 +273,7 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
             const isClaudeCodeContext = process.env.CLAUDE_CODE_VERSION !== undefined ||
                 process.env.ANTHROPIC_API_KEY !== undefined;
             if (isClaudeCodeContext) {
-                schedulerBackend = 'native-cron (CronCreate) / aiwg-cli fallback';
+                schedulerBackend = 'native-cron (CronCreate); external trigger outside agent sessions';
             }
             console.log(`\nScheduler:`);
             console.log(`  Backend:  ${schedulerBackend}`);

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

@@ -64,7 +64,7 @@ function parseServeArgs(args) {
 // ============================================================
 // WebSocket routing (#851)
 //
-// @hono/node-server v1.x does not export createNodeWebSocket.
+// @hono/node-server does not export createNodeWebSocket.
 // We wire WebSocket routes directly via the Node.js HTTP server's
 // 'upgrade' event and the `ws` npm package instead.
 // ============================================================
@@ -550,7 +550,7 @@ export async function startServer(opts) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const app = new Hono();
     // WebSocket routes are handled via Node.js upgrade event below (see setupWebSockets).
-    // @hono/node-server v1.x does not export createNodeWebSocket.
+    // @hono/node-server does not export createNodeWebSocket.
     // Health check
     app.get('/api/health', (c) => c.json({ status: 'ok', readOnly: opts.readOnly }));
     // Connection status — server health, PTY sessions, sandboxes, subsystem status (#887)

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

@@ -1,7 +1,22 @@
 import { existsSync, mkdirSync, realpathSync, statSync, } from 'node:fs';
 import { dirname, isAbsolute, resolve, } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { CLAUDE_ADAPTER_VERSION, ClaudeSessionAdapter, CODEX_ADAPTER_VERSION, CodexSessionAdapter, COPILOT_ADAPTER_VERSION, CopilotSessionAdapter, CURSOR_ADAPTER_VERSION, CursorSessionAdapter, FACTORY_ADAPTER_VERSION, FactorySessionAdapter, HERMES_ADAPTER_VERSION, HermesSessionAdapter, OPENCODE_ADAPTER_VERSION, OpenCodeSessionAdapter, OPENCLAW_ADAPTER_VERSION, OpenClawSessionAdapter, OPENHUMAN_ADAPTER_VERSION, OpenHumanSessionAdapter, WARP_ADAPTER_VERSION, WarpSessionAdapter, DEVIN_DESKTOP_ADAPTER_VERSION, DevinDesktopSessionAdapter, CandidateExtractionService, GENERIC_ADAPTER_VERSION, GenericSessionInterchangeAdapter, IncrementalSessionImporter, ImportLeaseContentionError, FilesystemMemoryDestination, FilesystemPromotionDispositionCoordinator, MemoryPromotionGateway, SESSION_CONTRACT_VERSION, SESSION_PROVIDER_IDS, SessionContractError, SessionRepository, SessionSourceSchema, StructuralCandidateExtractor, resolveMemoryConsumerManifest, assertSessionProviderId, acquireImportLease, defaultDiscoveryManifestPath, discoverWorkspaceHistories, deriveSessionTimeline, importDiscoveryManifest, previewDiscoveryImport, publicDiscoveryManifest, readDiscoveryManifest, redactSourceLocator, sha256, parseTimelineGap, writeDiscoveryManifest, } from '../../sessions/index.js';
 const JSON_CONTRACT_VERSION = '1.0.0';
+async function createLineMemoryPromotionDestination(projectRoot, manifestPath) {
+    const modulePath = resolve(dirname(manifestPath), 'commands', 'line-memory.mjs');
+    if (!existsSync(modulePath)) {
+        throw new SessionContractError('UNSUPPORTED_OPERATION', 'line-memory promotion adapter is missing from the installed addon');
+    }
+    const loaded = await import(pathToFileURL(modulePath).href);
+    if (!loaded.LineMemoryPromotionDestination) {
+        throw new SessionContractError('UNSUPPORTED_OPERATION', 'line-memory addon does not export its promotion adapter');
+    }
+    return new loaded.LineMemoryPromotionDestination({
+        projectRoot,
+        consumer: 'line-memory',
+    });
+}
 const EXIT = {
     ok: 0, usage: 2, unsupported: 3, unavailable: 4, contract: 5, storage: 6,
     locked: 7, coverage: 8,
@@ -28,6 +43,8 @@ Commands:
   restore <session-id>            Restore a reversible catalog tombstone
   purge <session-id>              Preview terminal AIWG-copy purge
   audit --workspace <id>          Read content-free mutation events
+  analytics <view> --workspace <id>  Summary, tool-calls, escalations, or HITL
+  forensics <view> --workspace <id>  Authorized timeline, indicators, or evidence
   doctor                          Check catalog availability and integrity
 
 Options:
@@ -219,6 +236,95 @@ async function executeCommand(ctx, args) {
                         nextCursor: result.nextCursor },
                 });
             }
+            case 'analytics': {
+                const view = requiredPositional(args, 0, 'analytics view');
+                const { workspaceId } = readAuthorizationContext(ctx, args, command, repository);
+                const query = analyticsQuery(args, workspaceId);
+                if (view === 'summary') {
+                    return ok(command, {
+                        view,
+                        summary: repository.analyticsSummary(query),
+                    });
+                }
+                const categories = analyticsCategories(view);
+                const items = repository.listAnalyticsFacts({ ...query, categories });
+                return ok(command, {
+                    analyticsVersion: '1.0.0',
+                    view,
+                    items,
+                    count: items.length,
+                    groupBy: analyticsGrouping(items, args.values.get('--group-by')),
+                });
+            }
+            case 'forensics': {
+                if (!args.flags.has('--authorize-forensics')) {
+                    throw new CliError('OPERATION_NOT_AUTHORIZED', 'forensic extraction requires --authorize-forensics for this invocation', EXIT.usage);
+                }
+                const view = requiredPositional(args, 0, 'forensics view');
+                const { workspaceId } = authorizationContext(ctx, args, command);
+                const query = analyticsQuery(args, workspaceId);
+                if (view === 'indicators') {
+                    const items = repository.listAnalyticsFacts({
+                        ...query,
+                        categories: ['indicator'],
+                    });
+                    return ok(command, forensicOutput(view, items, args));
+                }
+                if (view === 'timeline') {
+                    const target = requiredPositional(args, 1, 'session-id or query');
+                    const direct = repository.getSession(target, workspaceId);
+                    const sessionIds = direct
+                        ? [target]
+                        : [...new Set(repository.search({
+                                query: target,
+                                workspaceId,
+                                limit: boundedInteger(args.values.get('--limit'), 50, 1, 500, '--limit'),
+                            }).items.map((item) => item.sessionId))];
+                    const items = sessionIds.flatMap((sessionId) => repository.listAnalyticsFacts({ ...query, sessionId }));
+                    return ok(command, forensicOutput(view, items, args));
+                }
+                if (view === 'evidence') {
+                    const id = requiredPositional(args, 1, 'event-id, fact-id, or candidate-id');
+                    const evidence = repository.getAnalyticsEvidence(id, workspaceId);
+                    if (evidence.fact && evidence.event) {
+                        return ok(command, {
+                            analyticsVersion: '1.0.0',
+                            view,
+                            fact: evidence.fact,
+                            event: {
+                                eventId: evidence.event.eventId,
+                                sessionId: evidence.event.sessionId,
+                                sourceId: evidence.event.sourceId,
+                                importRunId: evidence.event.importRunId,
+                                sequence: evidence.event.sequence,
+                                kind: evidence.event.kind,
+                                occurredAt: evidence.event.occurredAt,
+                                sensitivity: evidence.event.sensitivity,
+                                rawReference: evidence.event.rawReference,
+                                digest: evidence.event.digest,
+                            },
+                        });
+                    }
+                    const candidate = repository.getCandidate(id, undefined, workspaceId);
+                    if (!candidate) {
+                        throw new CliError('EVIDENCE_NOT_FOUND', `authorized analytics evidence not found: ${id}`, EXIT.unavailable);
+                    }
+                    return ok(command, {
+                        analyticsVersion: '1.0.0',
+                        view,
+                        candidate: {
+                            candidateId: candidate.candidateId,
+                            version: candidate.version,
+                            type: candidate.type,
+                            evidence: candidate.evidence.map(({ quote: _quote, ...citation }) => citation),
+                            sensitivity: candidate.sensitivity,
+                            security: candidate.security,
+                            reviewState: candidate.reviewState,
+                        },
+                    });
+                }
+                throw new CliError('INVALID_ARGUMENT', `unknown forensics view: ${view}`, EXIT.usage);
+            }
             case 'extract': {
                 const { workspaceId } = authorizationContext(ctx, args, command);
                 const sessionId = args.positionals[0];
@@ -315,11 +421,14 @@ async function executeCommand(ctx, args) {
                 const candidateId = requiredPositional(args, 0, 'candidate-id');
                 const version = boundedInteger(requiredPositional(args, 1, 'version'), 1, 1, Number.MAX_SAFE_INTEGER, 'version');
                 const consumer = requiredValue(args, '--consumer');
-                const destination = new FilesystemMemoryDestination({
-                    projectRoot: ctx.cwd,
-                    consumer,
-                    manifestPath: resolveMemoryConsumerManifest(ctx.cwd, consumer),
-                });
+                const manifestPath = resolveMemoryConsumerManifest(ctx.cwd, consumer);
+                const destination = consumer === 'line-memory'
+                    ? await createLineMemoryPromotionDestination(ctx.cwd, manifestPath)
+                    : new FilesystemMemoryDestination({
+                        projectRoot: ctx.cwd,
+                        consumer,
+                        manifestPath,
+                    });
                 const scopedPromotionStore = {
                     getCandidate: (id, candidateVersion) => repository.getCandidate(id, candidateVersion, workspaceId),
                     getPromotionReceipt: (id, candidateVersion, namedConsumer) => repository.getCandidate(id, candidateVersion, workspaceId)
@@ -997,6 +1106,7 @@ function parseArgs(argv) {
         '--manifest', '--provider-home', '--codex-root', '--lock-wait-ms', '--min-coverage', '--gap',
         '--inactivity-threshold',
         '--control-events',
+        '--session', '--status', '--actor', '--group-by',
     ]);
     let command;
     for (let index = 0; index < argv.length; index += 1) {
@@ -1184,6 +1294,96 @@ function dependentAction(value) {
     }
     return value;
 }
+function analyticsQuery(args, workspaceId) {
+    const providerInput = args.values.get('--provider');
+    const statusInput = args.values.get('--status');
+    return {
+        workspaceId,
+        provider: providerInput ? assertSessionProviderId(providerInput) : undefined,
+        sessionId: args.values.get('--session'),
+        dateFrom: args.values.get('--date-from'),
+        dateTo: args.values.get('--date-to'),
+        tool: args.values.get('--tool'),
+        status: statusInput ? analyticsStatus(statusInput) : undefined,
+        actor: args.values.get('--actor') ?? args.values.get('--participant'),
+        tag: args.values.get('--tag'),
+        sensitivity: args.values.get('--sensitivity'),
+        extractionState: args.values.get('--extraction-state'),
+        limit: boundedInteger(args.values.get('--limit'), 500, 1, 5_000, '--limit'),
+    };
+}
+function analyticsStatus(value) {
+    const allowed = new Set([
+        'requested', 'running', 'succeeded', 'failed', 'granted', 'denied',
+        'timed-out', 'unsupported', 'provider-unknown', 'observed',
+    ]);
+    if (!allowed.has(value)) {
+        throw new CliError('INVALID_ARGUMENT', `invalid analytics status: ${value}`, EXIT.usage);
+    }
+    return value;
+}
+function analyticsCategories(view) {
+    if (view === 'tool-calls')
+        return ['tool-call', 'tool-result'];
+    if (view === 'escalations')
+        return ['escalation'];
+    if (view === 'hitl')
+        return ['hitl'];
+    throw new CliError('INVALID_ARGUMENT', `unknown analytics view: ${view}`, EXIT.usage);
+}
+function analyticsGrouping(items, groupBy) {
+    if (!groupBy)
+        return null;
+    if (!['tool', 'session', 'provider'].includes(groupBy)) {
+        throw new CliError('INVALID_ARGUMENT', `invalid --group-by value: ${groupBy}`, EXIT.usage);
+    }
+    const counts = {};
+    for (const item of items) {
+        const value = groupBy === 'tool'
+            ? item.toolName
+            : groupBy === 'session'
+                ? item.sessionId
+                : item.provider;
+        const key = typeof value === 'string' && value ? value : '<unknown>';
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return Object.fromEntries(Object.entries(counts).sort(([left], [right]) => left.localeCompare(right)));
+}
+function forensicOutput(view, items, args) {
+    const output = {
+        analyticsVersion: '1.0.0',
+        view,
+        items,
+        count: items.length,
+        authorization: {
+            explicit: true,
+            providerLogsModified: false,
+            historicalContentExecuted: false,
+        },
+    };
+    if (args.flags.has('--markdown')) {
+        output.markdown = [
+            `# Session Forensics ${view}`,
+            '',
+            `Facts: ${items.length}`,
+            '',
+            '| Time | Provider | Session | Category | Status | Evidence |',
+            '|---|---|---|---|---|---|',
+            ...items.map((item) => {
+                const citation = item.sourceCitation;
+                return [
+                    item.occurredAt ?? '<unknown>',
+                    item.provider ?? '<unknown>',
+                    item.sessionId ?? '<unknown>',
+                    item.category ?? '<unknown>',
+                    item.status ?? '<unknown>',
+                    citation?.eventId ?? item.eventId ?? '<unknown>',
+                ].map((value) => String(value).replaceAll('|', '\\|')).join(' | ');
+            }).map((row) => `| ${row} |`),
+        ].join('\n');
+    }
+    return output;
+}
 function isDryRun(ctx, args) {
     return Boolean(ctx.dryRun || args.flags.has('--dry-run'));
 }
@@ -1202,6 +1402,12 @@ function emit(value) {
 function printHuman(value) {
     if (value.status === 'preview')
         console.log('Preview (no changes applied)');
+    if (value.command === 'sessions.forensics' && value.data
+        && typeof value.data === 'object' && 'markdown' in value.data
+        && typeof value.data.markdown === 'string') {
+        console.log(value.data.markdown);
+        return;
+    }
     if (value.command === 'sessions.timeline' && value.data
         && typeof value.data === 'object' && 'items' in value.data) {
         const data = value.data;

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

@@ -19,7 +19,7 @@
 import { access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AiwgError, EXIT_CODES, handlerResultFromError } from '../errors.js';
-import { loadCapabilityMatrix, } from '../../providers/capability-matrix.js';
+import { loadCapabilityMatrix, isExternalStrategy, } from '../../providers/capability-matrix.js';
 import { getProjectDir, readAiwgConfig, writeAiwgConfig } from '../../config/aiwg-config.js';
 import { auditLegacyPermissions, archiveLegacyPermissionManifests, backupConfig, normalizeProjectPermissions, } from '../../policy/authorization.js';
 import { capabilityProviderId, normalizeProviderId, resolveActiveProvider } from '../provider-resolution.js';
@@ -48,6 +48,7 @@ async function detectProvider(ctx) {
 // ── Formatters ────────────────────────────────────────────────────────────────
 const NATIVE_MARK = '✓ native';
 const EMULATED_MARK = '~ emulated';
+const EXTERNAL_MARK = '↗ external';
 const UNSUPPORTED_MARK = '- not supported';
 function emulationLabel(strategy) {
     if (!strategy)
@@ -70,7 +71,9 @@ function formatProvider(id, provider, matrix, meta) {
     for (const featureId of featureKeys) {
         const isNative = provider.native_features?.[featureId] === true;
         const emulation = provider.emulation?.[featureId] ?? null;
-        const status = isNative ? NATIVE_MARK : (emulation ? EMULATED_MARK : UNSUPPORTED_MARK);
+        const status = isNative
+            ? NATIVE_MARK
+            : isExternalStrategy(emulation) ? EXTERNAL_MARK : (emulation ? EMULATED_MARK : UNSUPPORTED_MARK);
         const feat = matrix.features[featureId];
         lines.push(`\n  ${featureId} — ${status}`);
         if (feat?.description)
@@ -79,6 +82,9 @@ function formatProvider(id, provider, matrix, meta) {
             if (feat?.native_example)
                 lines.push(`    example: ${feat.native_example}`);
         }
+        else if (isExternalStrategy(emulation)) {
+            lines.push(`    trigger: system cron, systemd timer, or CI; AIWG does not own the clock`);
+        }
         else if (emulation) {
             lines.push(`    fallback: ${emulationLabel(emulation)}`);
         }
@@ -319,7 +325,9 @@ async function handleSteward(args, ctx) {
                 const emulation = provider.emulation?.[featureId] ?? null;
                 const status = isNative
                     ? `✓ native`
-                    : (emulation ? `~ emulated (${emulationLabel(emulation)})` : `- not supported`);
+                    : isExternalStrategy(emulation)
+                        ? `↗ external trigger (system cron/systemd/CI)`
+                        : (emulation ? `~ emulated (${emulationLabel(emulation)})` : `- not supported`);
                 console.log(`    ${provider.display_name.padEnd(20)} (${providerId.padEnd(12)}) ${status}`);
             }
             console.log('');
@@ -386,6 +394,11 @@ async function handleSteward(args, ctx) {
             if (feat.native_example)
                 console.log(`  Example: ${feat.native_example}`);
         }
+        else if (isExternalStrategy(emulation)) {
+            console.log(`  ↗ Use an external trigger`);
+            console.log(`  Strategy: system cron, systemd timer, or CI launches a reviewed provider command`);
+            console.log(`  Boundary: AIWG does not provide or own the clock/scheduler`);
+        }
         else if (emulation) {
             console.log(`  ~ Use AIWG emulation`);
             console.log(`  Strategy: ${emulationLabel(emulation)}`);

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

@@ -1147,9 +1147,18 @@ export const packagePluginHandler = {
                 message: "Error: plugin name is required.\n\nRun `aiwg package-plugin --help` for usage.",
             };
         }
+        const positionalSource = positional && (positional.includes('/') || positional.includes('\\'))
+            ? positional
+            : undefined;
         const normalizedArgs = hasExplicitPlugin
             ? ctx.args
-            : ["--plugin", positional, ...ctx.args.slice(1)];
+            : positionalSource
+                ? [
+                    "--plugin", path.basename(path.resolve(ctx.cwd, positionalSource)),
+                    "--source", positionalSource,
+                    ...ctx.args.slice(1),
+                ]
+                : ["--plugin", positional, ...ctx.args.slice(1)];
         const frameworkRoot = await getFrameworkRoot();
         const runner = createScriptRunner(frameworkRoot);
         return runner.run("tools/plugin/package-plugins.mjs", normalizedArgs, {