@aiwg/cli 2026.10.5 → 2026.10.7

package/dist/src/memory/maintenance.js

@@ -0,0 +1,254 @@
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, resolve, sep } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { acquireDirectoryLock } from '../artifacts/prebuilt-build-lock.js';
+import { sha256 } from './context-pack.js';
+import { MaintenancePlanSchema, MaintenanceReceiptSchema, validateMaintenancePlan } from './maintenance-contract.js';
+export function maintenancePlanDigest(plan) {
+    return sha256(JSON.stringify(MaintenancePlanSchema.parse(plan)));
+}
+export function maintenanceOperationKey(plan, index) {
+    return sha256(`${maintenancePlanDigest(plan)}:${index}`);
+}
+/** Reject paths escaping through either spelling or an existing symlink. */
+export function maintenancePath(root, path) {
+    const base = realpathSync(root);
+    const target = resolve(root, path);
+    if (!target.startsWith(`${resolve(root)}${sep}`))
+        throw new Error('Maintenance paths must remain inside the workspace');
+    let ancestor = target;
+    while (!existsSync(ancestor))
+        ancestor = dirname(ancestor);
+    const actual = realpathSync(ancestor);
+    if (actual !== base && !actual.startsWith(`${base}${sep}`))
+        throw new Error('Maintenance path traverses outside the workspace');
+    return target;
+}
+function writeAtomic(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+        renameSync(temp, path);
+    }
+    finally {
+        if (existsSync(temp))
+            unlinkSync(temp);
+    }
+}
+function selectOwner(operation, owners) {
+    if (!operation.owner || !operation.review)
+        throw new Error('Executable maintenance requires an owner preview and explicit reviewer');
+    const owner = owners.find(value => value.name === operation.owner.name);
+    if (!owner)
+        throw new Error(`Unavailable maintenance owner: ${operation.owner.name}`);
+    if (operation.scope !== 'project')
+        throw new Error('These lifecycle owners support explicit project scope only');
+    if (operation.sessionEffect !== 'next-session')
+        throw new Error('Durable owner edits require next-session effect; current sessions are unchanged');
+    return owner;
+}
+export function removesResident(operation) {
+    return operation.from.placement === 'resident'
+        && (operation.to.placement !== 'resident' || operation.to.lifecycle !== 'active');
+}
+function checkOwnerUniqueness(plan) {
+    const names = plan.operations.map(op => op.owner?.name);
+    if (new Set(names).size !== names.length) {
+        throw new Error('One exact snapshot operation per owner is supported per plan; review a new plan for the next revision');
+    }
+}
+/** Read-only review. A plan file is the only output written by the CLI planner. */
+export async function previewMaintenancePlan(input, owners) {
+    const plan = MaintenancePlanSchema.parse(input);
+    if (!plan.operations.length)
+        throw new Error('An executable plan requires at least one operation');
+    checkOwnerUniqueness(plan);
+    for (const operation of plan.operations) {
+        const owner = selectOwner(operation, owners);
+        if (!await owner.pending?.(operation)) {
+            validateMaintenancePlan({ ...plan, operations: [operation] }, await owner.records(), { retirementBasis: operation.review.retirementBasis });
+        }
+        await owner.validate(operation);
+        if (removesResident(operation) && !await verifyMaintenanceRetrieval(operation, owners)) {
+            throw new Error('Indexed retrieval must be verified before removing resident content');
+        }
+    }
+    // Also validate overlap between a target and another operation's merge inputs.
+    const inputs = plan.operations.flatMap(op => [op.target.id, ...(op.related ?? []).map(value => value.id)]);
+    if (new Set(inputs).size !== inputs.length)
+        throw new Error('Maintenance operations overlap');
+    return plan;
+}
+export async function verifyMaintenanceRetrieval(operation, owners) {
+    for (const owner of owners)
+        if (owner.verifyRetrieval && await owner.verifyRetrieval(operation))
+            return true;
+    return false;
+}
+/** Inspect committed owner receipts and end states without locks, journals or index refreshes. */
+export async function verifyMaintenancePlan(input, owners) {
+    const plan = MaintenancePlanSchema.parse(input);
+    if (!plan.operations.length)
+        throw new Error('An executable plan requires at least one operation');
+    checkOwnerUniqueness(plan);
+    const selected = plan.operations.map(operation => selectOwner(operation, owners));
+    const inputs = plan.operations.flatMap(operation => [operation.target.id, ...(operation.related ?? []).map(item => item.id)]);
+    if (new Set(inputs).size !== inputs.length)
+        throw new Error('Maintenance operations overlap');
+    const operations = [];
+    for (const [index, operation] of plan.operations.entries()) {
+        const owner = selected[index];
+        const key = maintenanceOperationKey(plan, index);
+        const findings = [];
+        const receipt = await owner.receipt(key, { readOnly: true });
+        if (receipt === undefined)
+            findings.push('Exact owner receipt is missing; the operation is unapplied or incomplete');
+        let records;
+        try {
+            records = await owner.records();
+        }
+        catch (error) {
+            if (!(error instanceof Error) || error.message !== 'Canonical semantic-memory source identity or digest has changed')
+                throw error;
+            findings.push('Canonical source identity or digest has drifted');
+            records = [];
+        }
+        for (const [inputIndex, target] of [operation.target, ...(operation.related ?? [])].entries()) {
+            const record = records.find(item => item.id === target.id);
+            if (!record) {
+                findings.push(`Retained source is missing: ${target.id}`);
+                continue;
+            }
+            const expected = inputIndex === 0 ? operation.to : {
+                placement: operation.from.placement, lifecycle: 'superseded',
+            };
+            if (record.digest !== target.digest || record.version !== target.version + 1
+                || record.scope !== operation.scope || record.authority.owner !== owner.name
+                || record.placement !== expected.placement || record.lifecycle !== expected.lifecycle) {
+                findings.push(`Source revision or end state differs from the plan: ${target.id}`);
+            }
+            if (expected.lifecycle !== 'active' && (!record.tombstone || record.tombstone.id !== target.id
+                || record.tombstone.digest !== target.digest || record.tombstone.disposition !== expected.lifecycle
+                || record.tombstone.reason !== operation.rationale || record.tombstone.reviewer !== operation.review.reviewer)) {
+                findings.push(`Retained tombstone differs from the plan: ${target.id}`);
+            }
+            if (expected.lifecycle === 'active' && record.tombstone)
+                findings.push(`Active source retains a stale tombstone: ${target.id}`);
+        }
+        const lineage = [operation.target.id, ...(operation.related ?? []).map(item => item.id)];
+        const lineageField = operation.op === 'merge' ? 'mergedFrom' : operation.op === 'split' ? 'splitFrom' : 'supersedes';
+        for (const replacement of operation.replacements ?? []) {
+            const matches = records.filter(record => record.digest === sha256(replacement.value)
+                && isDeepStrictEqual(record[lineageField], lineage));
+            if (!matches.some(record => record.version === 1 && record.lifecycle === 'active'
+                && record.scope === operation.scope && record.authority.owner === owner.name
+                && record.placement === operation.to.placement)) {
+                findings.push(`Replacement revision or lineage differs from the plan: ${replacement.key}`);
+            }
+        }
+        if (owner.verifyEndState)
+            findings.push(...await owner.verifyEndState(operation, key));
+        if (removesResident(operation) || (operation.to.lifecycle === 'active' && ['indexed', 'task-context'].includes(operation.to.placement))) {
+            try {
+                if (!await verifyMaintenanceRetrieval(operation, owners))
+                    findings.push('Indexed retrieval is unavailable for the recorded end state');
+            }
+            catch (error) {
+                if (!(error instanceof Error) || (!error.message.includes('no owner-native indexed retrieval projection')
+                    && error.message !== 'Canonical semantic-memory source identity or digest has changed'))
+                    throw error;
+                findings.push(error.message);
+            }
+        }
+        operations.push({ operationId: key, owner: owner.name, findings });
+    }
+    return { planDigest: maintenancePlanDigest(plan), operations,
+        findings: operations.flatMap(operation => operation.findings.map(finding => `${operation.owner}: ${finding}`)) };
+}
+export class MaintenanceApplyError extends Error {
+    receipt;
+    constructor(message, receipt) { super(message); this.name = 'MaintenanceApplyError'; this.receipt = receipt; }
+}
+/** Per-owner commits remain authoritative; this journal records progress, never memory bodies. */
+export async function applyMaintenancePlan(input, options) {
+    const plan = MaintenancePlanSchema.parse(input);
+    const digest = maintenancePlanDigest(plan);
+    if (options.confirmedDigest !== digest)
+        throw new Error('Apply requires confirmation of the exact plan digest');
+    if (!plan.operations.length)
+        throw new Error('An executable plan requires at least one operation');
+    checkOwnerUniqueness(plan);
+    const selected = plan.operations.map(op => selectOwner(op, options.owners));
+    const journalPath = maintenancePath(options.root, `.aiwg/memory/maintenance/${digest.replace(':', '_')}.json`);
+    const lockPath = maintenancePath(options.root, '.aiwg/memory/maintenance/.lock');
+    mkdirSync(dirname(lockPath), { recursive: true });
+    let release;
+    try {
+        release = await acquireDirectoryLock(lockPath, { timeoutMs: 0, reclaimDeadOwner: true });
+    }
+    catch (error) {
+        throw new Error(`Concurrent maintenance plan owns the workspace lock: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const resumed = existsSync(journalPath);
+    const entries = [];
+    const keys = plan.operations.map((_, index) => maintenanceOperationKey(plan, index));
+    const receipt = () => {
+        const completed = entries.map(entry => entry.operationId);
+        const pending = keys.filter(key => !completed.includes(key));
+        return MaintenanceReceiptSchema.parse({ schemaVersion: 'aiwg.maintenance-receipt.v1', planDigest: digest,
+            ownerReceipts: entries, ...(pending.length ? { partial: { completed, pending } } : {}),
+            ...(resumed ? { resumedFrom: journalPath } : {}),
+        });
+    };
+    try {
+        if (resumed) {
+            const prior = MaintenanceReceiptSchema.parse(JSON.parse(readFileSync(journalPath, 'utf8')));
+            if (prior.planDigest !== digest)
+                throw new Error('Maintenance journal belongs to a different plan');
+        }
+        // Recover commits even if interruption happened before the coordinator journal write.
+        for (let index = 0; index < selected.length; index++) {
+            const committed = await selected[index].receipt(keys[index]);
+            if (committed !== undefined)
+                entries.push({ operationId: keys[index], owner: selected[index].name, receipt: committed });
+        }
+        const pending = plan.operations.filter((_, index) => !entries.some(entry => entry.operationId === keys[index]));
+        if (pending.length)
+            await previewMaintenancePlan({ ...plan, operations: pending }, options.owners);
+        writeAtomic(journalPath, receipt());
+        for (let index = 0; index < selected.length; index++) {
+            if (entries.some(entry => entry.operationId === keys[index]))
+                continue;
+            const operation = plan.operations[index];
+            if (removesResident(operation) && !await verifyMaintenanceRetrieval(operation, options.owners))
+                throw new Error('Indexed retrieval is unavailable');
+            const result = await selected[index].apply(operation, keys[index]);
+            await options.afterOwner?.(index);
+            entries.push({ operationId: keys[index], owner: selected[index].name, receipt: result });
+            writeAtomic(journalPath, receipt());
+        }
+        return receipt();
+    }
+    catch (error) {
+        // A thrown remote refresh or interruption can follow a committed local owner mutation.
+        for (let index = 0; index < selected.length; index++) {
+            if (entries.some(entry => entry.operationId === keys[index]))
+                continue;
+            try {
+                const committed = await selected[index].receipt(keys[index]);
+                if (committed !== undefined)
+                    entries.push({ operationId: keys[index], owner: selected[index].name, receipt: committed });
+            }
+            catch { /* Unavailable owner remains pending; never claim its success. */ }
+        }
+        const partial = receipt();
+        writeAtomic(journalPath, partial);
+        throw new MaintenanceApplyError(error instanceof Error ? error.message : String(error), partial);
+    }
+    finally {
+        await release();
+    }
+}
+//# sourceMappingURL=maintenance.js.map

package/dist/src/memory/project-registry.js

@@ -10,6 +10,7 @@ import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { boundedExecFileSync } from '../process/bounded-child-process.mjs';
+import { helperEnvironment } from '../process/cli-command.mjs';
 import { projectAiwgPath, resolveProjectAiwgDir } from '../config/project-artifacts.js';
 export function projectMemoryHome() {
     const override = process.env.AIWG_PROJECT_MEMORY_HOME;
@@ -248,7 +249,7 @@ function sanitizeProjectId(id) {
 }
 function discoverGitRemotes(cwd) {
     try {
-        const stdout = boundedExecFileSync('git', ['remote', '-v'], 'quick', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const stdout = boundedExecFileSync('git', ['remote', '-v'], 'quick', { cwd, env: helperEnvironment(), encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
         const remotes = stdout
             .split('\n')
             .map((line) => line.trim().split(/\s+/)[1])

package/dist/src/memory/provider-memory-adapter.js

@@ -0,0 +1,154 @@
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { resolveHermesHomePath } from '../providers/hermes-home.js';
+import { resolveOmpPaths } from '../providers/omp-paths.mjs';
+import { PROVIDER_IDS, getProviderDefinition, getProviderArtifactPathStrings, resolveProviderPathValue, } from '../providers/provider-definitions.js';
+import { deployedSkillRoots } from '../providers/deployed-skill-roots.js';
+import { resolveMuseXdgSkillsDir } from '../providers/muse-paths.js';
+import { grokBuildUserPaths, resolveGrokHome } from '../providers/grok-build-paths.js';
+const COMMON_LIMITS = [
+    'canonical-edit-and-regenerate', 'immutable-running-session', 'opaque-system-content',
+    'explicit-scope-selection', 'authority-review-required',
+];
+// Deliberately exhaustive: a new provider needs a reviewed maintenance policy.
+// Paths, ceilings, nesting and loading syntax remain owned by provider definitions.
+const POLICIES = {
+    antigravity: { limits: ['runtime-load-unobserved'], sessionEffect: 'next-session' },
+    claude: { limits: ['imports-consume-startup-context'], sessionEffect: 'next-session', liveLoadVisibility: true },
+    codex: { limits: ['runtime-truncation-and-restart', 'runtime-load-unobserved'], sessionEffect: 'next-session' },
+    copilot: { limits: ['no-general-precedence', 'surface-and-enabled-state-required', 'scope-limited-imports', 'runtime-load-unobserved'], sessionEffect: 'next-session' },
+    cursor: { limits: ['always-apply-except-globs', 'runtime-load-unobserved'], sessionEffect: 'next-session' },
+    'deepseek-harness': { limits: ['runtime-load-unobserved'], sessionEffect: 'next-session' },
+    factory: { limits: ['runtime-load-unobserved'], sessionEffect: 'next-session' },
+    grokbot: { limits: ['runtime-load-unobserved'], sessionEffect: 'unknown' },
+    'grok-build': { limits: ['runtime-load-unobserved'], sessionEffect: 'next-session' },
+    hermes: { limits: ['write-is-not-reload-proof', 'external-connections-only', 'distinct-native-memory-stores'], sessionEffect: 'next-session' },
+    muse: { limits: ['trust-gated-startup', 'runtime-load-unobserved'], sessionEffect: 'unknown' },
+    opencode: { limits: ['configuration-registration-mutation', 'runtime-load-unobserved'], sessionEffect: 'next-session' },
+    openclaw: { limits: ['durable-and-injected-sizes-separate', 'no-verified-project-startup'], sessionEffect: 'unknown', liveLoadVisibility: true },
+    openhuman: { limits: ['runtime-load-unobserved'], sessionEffect: 'unknown' },
+    pi: { limits: ['runtime-load-unobserved'], sessionEffect: 'next-session' },
+    omp: { limits: ['nearest-nonempty-context', 'depth-ordered-include-deduplication', 'runtime-load-unobserved'], sessionEffect: 'next-session' },
+    warp: { limits: ['runtime-load-unobserved'], sessionEffect: 'next-session' },
+    windsurf: { limits: ['runtime-load-unobserved'], sessionEffect: 'next-session' },
+    generic: { limits: ['indexed-baseline-only'], sessionEffect: 'unknown' },
+};
+function memoryRoots(definition) {
+    if (definition.id === 'generic')
+        return [];
+    const { paths, context } = definition;
+    const values = [
+        ...Object.values(paths.artifacts), ...Object.values(paths.contextDiscovery),
+        paths.kernelSkills, paths.contextFiles.contextFile, paths.contextFiles.hookFile,
+        ...context.startupFiles, ...context.bootstrapTargets, context.configRegistration?.file ?? null,
+        ...Object.values(getProviderArtifactPathStrings(definition.id) ?? {}),
+        // The deployment helper has a Claude compatibility fallback when no kernel
+        // root exists. That fallback is not this provider's memory surface.
+        ...(paths.kernelSkills ? deployedSkillRoots('.', definition.id) : []),
+        ...definition.surfaces.related
+            .filter(surface => surface.relationship === 'same-provider' || surface.relationship === 'shared-adapter')
+            .flatMap(surface => Object.values(surface.paths).flat()),
+    ];
+    if (context.includeSyntax) {
+        for (const include of context.includeSyntax.split('\n')) {
+            // A template such as @<relative-path> is syntax, not a concrete root.
+            if (/^@[^<>\s]+$/.test(include))
+                values.push(include.slice(1));
+        }
+    }
+    if (definition.skillNamespace.pathType === 'home-dir' && !['grokbot', 'hermes'].includes(definition.id)) {
+        values.push(resolveProviderPathValue(`~/${definition.skillNamespace.skillsBaseDir}`, '.'));
+    }
+    if (definition.id === 'muse')
+        values.push(resolveMuseXdgSkillsDir());
+    if (definition.id === 'grok-build') {
+        const home = resolveGrokHome();
+        if (home)
+            values.push(...Object.values(grokBuildUserPaths(home)));
+    }
+    // Native user stores absent from deployment paths. Keep these with the
+    // adapter owner so audit never invents another provider path registry.
+    if (definition.id === 'claude' || definition.id === 'codex') {
+        const home = definition.id === 'claude'
+            ? process.env.CLAUDE_CONFIG_DIR || path.join(homedir(), '.claude')
+            : process.env.CODEX_HOME || path.join(homedir(), '.codex');
+        for (const value of Object.values(paths.artifacts)) {
+            if (value?.startsWith(`.${definition.id}/`))
+                values.push(path.resolve(home, value.slice(definition.id.length + 2)));
+        }
+        values.push(path.resolve(home, definition.id === 'claude' ? 'CLAUDE.md' : 'AGENTS.md'));
+        if (definition.id === 'codex')
+            values.push(path.resolve(home, 'AGENTS.override.md'));
+        if (definition.id === 'claude')
+            values.push(path.resolve(home, 'projects/*/memory'));
+    }
+    if (definition.id === 'hermes')
+        values.push(resolveHermesHomePath('memories/MEMORY.md'), resolveHermesHomePath('memories/USER.md'));
+    if (definition.id === 'omp') {
+        const resolved = resolveOmpPaths();
+        values.push(path.join(resolved.agentDir, 'AGENTS.md'), ...Object.values(resolved.resourceDirs));
+    }
+    return [...new Set(values.filter((value) => Boolean(value)))];
+}
+function hasRuntimeEvidence(item, providerId) {
+    const { evidence } = item.observation;
+    return item.visibility === 'runtime' && Boolean(evidence.source && evidence.at
+        && evidence.session && evidence.version && evidence.provider === providerId);
+}
+function createAdapter(definition, policy) {
+    const supported = definition.context.support === 'supported';
+    const native = definition.id !== 'generic';
+    const adapter = {
+        providerId: definition.id,
+        memoryRoots: () => memoryRoots(definition),
+        disposition(item) {
+            const { status } = item.observation;
+            if (item.visibility === 'hidden' || status === 'opaque')
+                return 'opaque';
+            if (status === 'observed' && (!policy.liveLoadVisibility || !hasRuntimeEvidence(item, definition.id))) {
+                return 'inferred';
+            }
+            return status;
+        },
+        supports: { read: native, write: native, estimate: supported, liveLoadVisibility: policy.liveLoadVisibility ?? false },
+        sessionEffect: () => policy.sessionEffect,
+        context: definition.context,
+        limits: [...COMMON_LIMITS, ...policy.limits, ...(!supported ? ['unknown-estimates'] : [])],
+        diagnostic: native ? null : 'No native memory surface is supported; use the indexed AIWG baseline.',
+        estimate(size) {
+            const unknown = { bytes: null, confidence: 'unknown', kind: size.kind };
+            if (size.observation.status === 'unknown')
+                return unknown;
+            const known = { ...size, observation: { ...size.observation, status: size.observation.status } };
+            const disposition = adapter.disposition(known);
+            if (!supported || !Number.isSafeInteger(size.bytes) || (size.bytes ?? -1) < 0
+                || ['opaque', 'absent', 'inaccessible'].includes(disposition))
+                return unknown;
+            if (size.kind === 'injected') {
+                // A durable file's size cannot establish the amount injected into a session.
+                if (disposition !== 'observed' || !hasRuntimeEvidence(known, definition.id))
+                    return unknown;
+                return { bytes: size.bytes, confidence: 'measured', kind: size.kind };
+            }
+            return { bytes: size.bytes, confidence: disposition === 'inferred' ? 'inferred' : 'measured', kind: size.kind };
+        },
+    };
+    return adapter;
+}
+export const PROVIDER_MEMORY_ADAPTERS = new Map(PROVIDER_IDS.map(providerId => {
+    const definition = getProviderDefinition(providerId);
+    const policy = POLICIES[providerId];
+    if (!definition || !policy)
+        throw new Error(`Missing memory adapter contract for ${providerId}`);
+    return [providerId, createAdapter(definition, policy)];
+}));
+/** Always checks coverage, including generic; never silently skips a missing adapter. */
+export function listProviderMemoryAdapters(registry = PROVIDER_MEMORY_ADAPTERS) {
+    return PROVIDER_IDS.map(providerId => {
+        const adapter = registry.get(providerId);
+        if (!adapter || adapter.providerId !== providerId)
+            throw new Error(`Missing memory adapter contract for ${providerId}`);
+        return adapter;
+    });
+}
+//# sourceMappingURL=provider-memory-adapter.js.map

package/dist/src/memory/recommend-cli.js

@@ -0,0 +1,83 @@
+import { memoryUsage, memoryInput, MEMORY_EXIT_USAGE } from './cli-result.js';
+import { readFile } from 'node:fs/promises';
+import { parseMemoryCostOptions, resolveMemoryCostInputs } from './cli.js';
+import { auditMemory } from './audit.js';
+import { formatMemoryRecommendations, recommendMemory, RecommendationInputsSchema } from './recommend.js';
+export const MEMORY_RECOMMEND_USAGE = `Usage: aiwg memory recommend [--scope global|project|provider] [--provider <id>] [--json]
+    [--evidence <json-file>] [--usage <json-file>] [--candidate <id> --emit-review-input]
+Read-only recommendations: duplicates, taxonomy, conflicts, supersession, tiers and retirement.
+JSON: aiwg.memory-recommendations.v1. Writes nothing; never approves or applies a plan.
+--evidence supplies per-item owner/provenance/criticality/pin/review/creation/history evidence
+and configurable thresholds. --usage uses the same observed utility input as memory cost.
+Unknown history and rare obligations block retirement. Thresholds are local starting points.
+New knowledge defaults to indexed storage; prefer buildWorkspaceContextPack before residency.
+--emit-review-input prints one selected advisory candidate as JSON to stdout. Save it with
+shell redirection, review it, then use memory plan --recommendation <file> --reviewer <name>
+--out <new-plan-file>. Conflicts and blocked/rejected proposals require owner resolution.
+${MEMORY_EXIT_USAGE}`;
+export function parseMemoryRecommendOptions(args) {
+    const shared = [];
+    const extra = {};
+    const seen = new Set();
+    for (let index = 0; index < args.length; index++) {
+        const [flag, inline, ...rest] = args[index].split('=');
+        if (['--evidence', '--candidate', '--emit-review-input'].includes(flag)) {
+            if (rest.length)
+                throw new Error(`Unknown memory recommend argument: ${args[index]}`);
+            if (seen.has(flag))
+                throw new Error(`Duplicate memory recommend option: ${flag}`);
+            seen.add(flag);
+            if (flag === '--emit-review-input') {
+                if (inline !== undefined)
+                    throw new Error(`${flag} takes no value`);
+                extra.emitReviewInput = true;
+            }
+            else {
+                const value = inline ?? args[++index];
+                if (!value || value.startsWith('-'))
+                    throw new Error(`${flag} requires a value`);
+                if (flag === '--evidence')
+                    extra.evidence = value;
+                else
+                    extra.candidate = value;
+            }
+        }
+        else {
+            if (['--demote', '--startup-measurement'].includes(flag))
+                throw new Error(`Unknown memory recommend argument: ${args[index]}`);
+            shared.push(args[index]);
+            if (['--scope', '--provider', '--usage'].includes(flag) && inline === undefined) {
+                const value = args[++index];
+                if (!value || value.startsWith('-'))
+                    throw new Error(`${flag} requires a value`);
+                shared.push(value);
+            }
+        }
+    }
+    // Reuse the audit/cost strict scope and provider conventions.
+    const opts = { ...parseMemoryCostOptions(shared), ...extra };
+    if (!opts.help && Boolean(opts.emitReviewInput) !== Boolean(opts.candidate))
+        throw new Error('--candidate and --emit-review-input must be selected together');
+    return opts;
+}
+export async function runMemoryRecommendCli(args) {
+    const opts = memoryUsage(() => parseMemoryRecommendOptions(args));
+    if (opts.help) {
+        console.log(MEMORY_RECOMMEND_USAGE);
+        return;
+    }
+    const input = opts.evidence ? await memoryInput(async () => RecommendationInputsSchema.parse(JSON.parse(await readFile(opts.evidence, 'utf8')))) : {};
+    const audit = await auditMemory(opts);
+    const report = recommendMemory(audit, input, await memoryInput(() => resolveMemoryCostInputs(opts)));
+    if (opts.candidate) {
+        const selected = report.candidates.find(c => c.id === opts.candidate);
+        if (!selected)
+            throw new Error('Recommendation candidate is missing or changed; rerun recommend');
+        if (selected.status !== 'advisory')
+            throw new Error(`Cannot emit review input: candidate is ${selected.status}: ${selected.blockedReasons.join('; ')}`);
+        report.candidates = [selected];
+    }
+    console.log(opts.json || opts.emitReviewInput ? JSON.stringify(report, null, 2) : formatMemoryRecommendations(report));
+    return report.candidates.length || audit.findings.length ? 1 : 0;
+}
+//# sourceMappingURL=recommend-cli.js.map