agentic-workflow-manager 3.1.0 → 3.2.1

package/dist/src/commands/hooks/uninstall.js

@@ -1,59 +1,23 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uninstallHook = uninstallHook;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../providers");
-const paths_1 = require("../../core/paths");
-function backupSettings(settingsPath) {
-    if (!fs_1.default.existsSync(settingsPath))
-        return null;
-    const backupDir = path_1.default.join((0, paths_1.awmHome)(), 'backups');
-    fs_1.default.mkdirSync(backupDir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '-').slice(0, 19);
-    const backupPath = path_1.default.join(backupDir, `settings.json.${ts}.bak`);
-    fs_1.default.copyFileSync(settingsPath, backupPath);
-    return backupPath;
-}
-function isAwmEntry(entry, scriptsDir, matcher) {
-    return (entry?.matcher === matcher &&
-        Array.isArray(entry?.hooks) &&
-        entry.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
-}
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
 function uninstallHook(options) {
     const config = (0, providers_1.getHookConfig)(options.agent);
     if (!config) {
         throw new Error(`hooks not supported for agent target: ${options.agent}`);
     }
-    if (!fs_1.default.existsSync(config.settingsPath)) {
-        return { status: 'not-installed', backupPath: null };
-    }
-    let settings;
-    try {
-        settings = JSON.parse(fs_1.default.readFileSync(config.settingsPath, 'utf-8'));
-    }
-    catch {
-        throw new Error(`${config.settingsPath} is not valid JSON. Manual cleanup required.`);
-    }
-    const entries = settings?.hooks?.[config.eventName] ?? [];
-    const beforeLength = entries.length;
-    const filtered = entries.filter((e) => !isAwmEntry(e, config.scriptsDir, config.matcher));
-    if (filtered.length === beforeLength) {
-        return { status: 'not-installed', backupPath: null };
-    }
-    const backupPath = backupSettings(config.settingsPath);
-    if (filtered.length === 0) {
-        delete settings.hooks[config.eventName];
-        if (Object.keys(settings.hooks).length === 0) {
-            delete settings.hooks;
+    switch (config.type) {
+        case 'cc-settings-merge':
+            return (0, claude_1.uninstallClaudeHook)(options.agent);
+        case 'codex-hooks-json':
+            return (0, codex_1.uninstallCodexHook)(options.agent);
+        /* istanbul ignore next -- HookConfig['type'] is exhaustively handled above */
+        default: {
+            const exhaustive = config.type;
+            throw new Error(`Unknown hook config type: ${String(exhaustive)}`);
         }
     }
-    else {
-        settings.hooks[config.eventName] = filtered;
-    }
-    fs_1.default.writeFileSync(config.settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    return { status: 'uninstalled', backupPath };
 }

package/dist/src/commands/init.js

@@ -49,6 +49,11 @@ const bundles_1 = require("../core/bundles");
 const registries_1 = require("../core/registries");
 const orchestrator_1 = require("../core/init/orchestrator");
 const steps_1 = require("../core/init/steps");
+const mutation_targets_1 = require("../core/init/mutation-targets");
+const provider_facts_1 = require("../core/init/provider-facts");
+const install_transaction_1 = require("../core/install-transaction");
+const provider_version_1 = require("../core/provider-version");
+const providers_1 = require("../providers");
 const paths_1 = require("../core/paths");
 const config_1 = require("../utils/config");
 // ---------------------------------------------------------------------------
@@ -91,44 +96,101 @@ function renderInitOutcome(o) {
 }
 async function runInit(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
-    const agent = opts.agent ?? 'claude-code';
-    // #7: make init the source of truth for the default agent. Persist the resolved
-    // agent so later `awm add`/`awm sync` (which read preferences.defaultAgent) target
-    // the right agent instead of stamping the static default. Do NOT clobber an existing
-    // explicit preference on a bare re-init: only write when an agent was passed via -a,
-    // or when no preferences file exists yet.
-    if (opts.agent != null || !(0, config_1.preferencesExist)()) {
-        (0, config_1.savePreferences)({ ...(0, config_1.getPreferences)(), defaultAgent: agent });
+    const agent = opts.agent === undefined ? 'claude-code' : (0, providers_1.requireAgentTarget)(opts.agent);
+    // R2: gate BEFORE anything is read or written — an unsupported provider
+    // version must never touch preferences.json or any provider file.
+    const gate = opts.assertProviderSupported ?? provider_version_1.assertProviderSupported;
+    try {
+        gate(agent);
+    }
+    catch (error) {
+        process.stderr.write(`awm init: ${error.message}\n`);
+        return 2;
     }
+    // #7 / R11: make init the source of truth for the default agent, but never
+    // clobber an existing explicit default on a bare re-init (`opts.agent`
+    // undefined) — only ENABLE the resolved agent into enabledAgents. On a
+    // machine with no preferences yet, `loadPreferences(agent)` proposes
+    // `{ defaultAgent: agent, enabledAgents: [agent], ... }` as the seed.
+    const loaded = (0, config_1.loadPreferences)(agent);
+    const nextPreferences = opts.agent === undefined
+        ? loaded.prefs
+        : (0, config_1.enableAgent)(loaded.prefs, agent);
+    // R19: Claude's baseline is read-only from every OTHER agent's init run —
+    // snapshotted before any write, compared after every step ran. Only meaningful
+    // when THIS run targets a different agent: a claude-code init run is expected
+    // to change claude-code's own managed paths (that's the point of running it),
+    // so the guard would otherwise misfire on the CLI's own default/most common
+    // path — every fresh `awm init` (no --agent) genuinely mutates its baseline
+    // and would incorrectly be flagged as a violation.
+    const beforeClaudeFacts = agent === 'claude-code' ? null : (0, provider_facts_1.gatherProviderFacts)('claude-code');
     let outcome;
     try {
         const mergedActions = {
             ...steps_1.defaultActions,
             ...(opts.actions ?? {}),
         };
-        (0, registries_1.seedBaselineRegistry)();
-        if ((0, registries_1.listRegistries)().some((r) => !fs_1.default.existsSync(r.contentRoot))) {
-            await mergedActions.syncCache();
-        }
-        const bundles = (0, bundles_1.discoverAllBundles)();
-        const ctx = (0, context_1.gatherContext)({ cwd, bundles, agent });
-        // In machineOnly mode, null out the project context so project steps are skipped
-        const effectiveCtx = opts.machineOnly
-            ? { ...ctx, project: null }
-            : ctx;
-        const confirmExtensions = makeConfirmExtensions(!!opts.yes);
-        outcome = await (0, orchestrator_1.runInitSteps)({
+        // Enumerate every path this run may write to and open one backup
+        // session covering the whole init (preferences + every machine/project
+        // step) BEFORE calling anything else — including `seedBaselineRegistry`,
+        // whose `resolveBaseRemote()` incidentally reads preferences.json and
+        // (on a machine with none yet) would otherwise auto-vivify it with
+        // stock defaults ahead of our own write, corrupting the "before"
+        // snapshot rollback restores to. Uses whatever bundle content already
+        // exists on disk right now (before this run's own registry sync).
+        // Known narrow gap: on a truly first-ever init (no prior registry
+        // clone at all), the bundle artifacts this SAME run freshly clones and
+        // installs can't be named yet at this point, so a failure later in
+        // that exact run won't roll those specific artifacts back — every
+        // other target (preferences, hook, injection, previously-installed
+        // bundle content) is covered.
+        const preSyncBundles = (0, bundles_1.discoverAllBundles)();
+        const mutationTargets = (0, mutation_targets_1.planInitMutationTargets)({
             cwd,
-            ctx: effectiveCtx,
-            bundles,
             agent,
-            installMethod: 'symlink',
-            registryRoot: (0, registries_1.capabilityRoot)('hooks') ?? '',
-            contentDir: (0, registries_1.contentRoots)()[0] ?? '',
-            sensorPacksRoot: (0, registries_1.capabilityRoot)('sensor-packs') ?? '',
-            confirmExtensions,
-            actions: mergedActions,
+            bundles: preSyncBundles,
         });
+        const backup = (0, install_transaction_1.beginBackupSession)(mutationTargets);
+        try {
+            (0, config_1.savePreferences)(nextPreferences);
+            (0, registries_1.seedBaselineRegistry)();
+            if ((0, registries_1.listRegistries)().some((r) => !fs_1.default.existsSync(r.contentRoot))) {
+                await mergedActions.syncCache();
+            }
+            const bundles = (0, bundles_1.discoverAllBundles)();
+            const ctx = (0, context_1.gatherContext)({ cwd, bundles, agent });
+            // In machineOnly mode, null out the project context so project steps are skipped
+            const effectiveCtx = opts.machineOnly
+                ? { ...ctx, project: null }
+                : ctx;
+            const confirmExtensions = makeConfirmExtensions(!!opts.yes);
+            outcome = await (0, orchestrator_1.runInitSteps)({
+                cwd,
+                ctx: effectiveCtx,
+                bundles,
+                agent,
+                enabledAgents: nextPreferences.enabledAgents,
+                installMethod: 'symlink',
+                registryRoot: (0, registries_1.capabilityRoot)('hooks') ?? '',
+                contentDir: (0, registries_1.contentRoots)()[0] ?? '',
+                sensorPacksRoot: (0, registries_1.capabilityRoot)('sensor-packs') ?? '',
+                confirmExtensions,
+                actions: mergedActions,
+            });
+            if (outcome.failed > 0) {
+                throw new Error('one or more init steps failed');
+            }
+            if (beforeClaudeFacts) {
+                (0, provider_facts_1.assertClaudeBaselinePreserved)(beforeClaudeFacts, (0, provider_facts_1.gatherProviderFacts)('claude-code'));
+            }
+            backup.commit();
+            outcome.transactionId = backup.transactionId;
+            outcome.modifiedFiles = backup.targetPaths;
+        }
+        catch (error) {
+            backup.rollback();
+            throw error;
+        }
     }
     catch (err) {
         process.stderr.write(`awm init: internal error: ${err.message}\n`);

package/dist/src/commands/registry/index.js

@@ -70,7 +70,7 @@ function registerRegistryCommand(program) {
                         const agentPick = await (0, prompts_1.select)({
                             message: 'Target agent',
                             initialValue: prefs.defaultAgent,
-                            options: Object.keys(providers_1.PROVIDERS).map((a) => ({ value: a, label: a })),
+                            options: providers_1.AGENT_TARGETS.map((a) => ({ value: a, label: a })),
                         });
                         if (!(0, prompts_1.isCancel)(agentPick))
                             agents = [agentPick];

package/dist/src/commands/sync.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSyncCore = runSyncCore;
+// src/commands/sync.ts
+//
+// `awm sync` — rebuilds local skill/workflow/agent symlinks from
+// `.awm/profile.json` for the resolved agent targets (R12/R13): defaults to
+// every enabled agent when `--agent` is absent, otherwise an explicit
+// comma-separated subset (validated against `enabledAgents`).
+// NOTE: deliberately no top-level `@clack/prompts` import here — this module
+// is `require()`d directly by tests exercising `runSyncCore`, and `@clack/prompts`
+// ships ESM-only, which the CommonJS ts-jest transform can't load. The
+// intro/outro chrome lives in `index.ts`'s Commander registration instead
+// (which already imports clack at the top and is never `require()`d by tests).
+const picocolors_1 = __importDefault(require("picocolors"));
+const profile_1 = require("../core/profile");
+const registries_1 = require("../core/registries");
+const bundles_1 = require("../core/bundles");
+const bundle_install_1 = require("../core/bundle-install");
+const profile_pins_1 = require("../core/profile-pins");
+const config_1 = require("../utils/config");
+const agent_targets_1 = require("../core/agent-targets");
+const defaultDeps = {
+    syncRegistries: registries_1.syncRegistries,
+    verifyMinCliVersions: registries_1.verifyMinCliVersions,
+    verifyProjectPins: profile_pins_1.verifyProjectPins,
+    syncProfile: bundle_install_1.syncProfile,
+};
+/** Core, UI-free `awm sync` logic — see `runSync` for the Commander-facing wrapper. */
+async function runSyncCore(options, deps = {}) {
+    const d = { ...defaultDeps, ...deps };
+    const cwd = options.cwd ?? process.cwd();
+    const projectRoot = (0, profile_1.findProjectRoot)(cwd);
+    if (!projectRoot) {
+        console.error(picocolors_1.default.red('No project root found (need a .git/, package.json, or .awm/profile.json here).'));
+        return { code: 1, selectedAgents: [] };
+    }
+    let profile;
+    try {
+        profile = (0, profile_1.readProfile)(projectRoot);
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red(e.message));
+        return { code: 1, selectedAgents: [] };
+    }
+    const prefs = (0, config_1.getPreferences)();
+    const resolved = (0, agent_targets_1.resolveAgentTargetsOrError)({ prefs, explicit: options.agent });
+    if (!resolved.ok) {
+        console.error(picocolors_1.default.red(resolved.error));
+        return { code: 1, selectedAgents: [] };
+    }
+    const selectedAgents = resolved.targets;
+    const syncResults = await d.syncRegistries();
+    for (const r of syncResults) {
+        if (r.action === 'error')
+            console.warn(picocolors_1.default.yellow(`  ⚠  registry ${r.name}: ${r.error}`));
+    }
+    // Gate minCliVersion (WS-4) before pins (contract gates first — CONSTITUTION).
+    try {
+        (0, registries_1.assertRegistryGates)(d.verifyMinCliVersions());
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red(e.message));
+        return { code: 1, selectedAgents };
+    }
+    const pins = profile.registries ?? {};
+    if (Object.keys(pins).length > 0) {
+        const failures = await d.verifyProjectPins(pins);
+        if (failures.length > 0) {
+            for (const f of failures) {
+                if (f.reason === 'missing-registry') {
+                    const registriesConfig = (0, registries_1.readRegistriesConfig)();
+                    const isConfigured = registriesConfig.some((r) => r.name === f.name);
+                    if (isConfigured) {
+                        console.error(picocolors_1.default.red(`The registry "${f.name}" is configured but not yet synced on this machine. Run: awm update`));
+                    }
+                    else {
+                        console.error(picocolors_1.default.red(`The registry "${f.name}" is not configured on this machine. Run: awm registry add <remote>`));
+                    }
+                }
+                else {
+                    console.error(picocolors_1.default.red(`This machine has ${f.name} @ ${f.actual ? `v${f.actual}` : 'HEAD (no tag)'} but the project requires v${f.required}.`));
+                    console.error(picocolors_1.default.red(`  Run: awm pin ${f.name} ${f.required} && awm update`));
+                }
+            }
+            return { code: 1, selectedAgents };
+        }
+    }
+    if (profile.extensions.length === 0) {
+        console.log(picocolors_1.default.yellow('No extensions in .awm/profile.json — nothing to sync. Use `awm add <bundle>` first.'));
+        return { code: 0, selectedAgents };
+    }
+    const method = options.method === 'copy' ? 'copy' : 'symlink';
+    let result;
+    try {
+        result = d.syncProfile({ projectRoot, bundles: (0, bundles_1.discoverAllBundles)(), agents: selectedAgents, method });
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red(e.message));
+        return { code: 1, selectedAgents };
+    }
+    if (result.skipped.length > 0) {
+        for (const sk of result.skipped)
+            console.log(picocolors_1.default.yellow(`  ⚠  Skipped: ${sk}`));
+    }
+    const lines = result.installed.map((n) => picocolors_1.default.green(n)).join('\n  ');
+    const installedNote = lines ? `\n  ${lines}` : picocolors_1.default.dim(' (all up to date)');
+    console.log(`✅ Synced extensions [${result.extensions.join(', ')}]:${installedNote}`);
+    return { code: 0, selectedAgents, result };
+}

package/dist/src/commands/update.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpdateCore = runUpdateCore;
+// src/commands/update.ts
+//
+// `awm update` — syncs configured registries, regenerates global context,
+// reconciles machine-scope artifacts (baseline/ambient bundles) against the
+// freshly synced content, and re-syncs the SessionStart hook's managed files
+// — all scoped to the resolved agent targets (R12/R13). Every stage after
+// the registry sync is a real gate: a failure in context regeneration,
+// artifact reconciliation, or hook resync reports the failing provider and
+// returns a non-zero exit code (no silent `catch {}` swallowing failures).
+// NOTE: deliberately no top-level `@clack/prompts` import here — this module
+// is `require()`d directly by tests exercising `runUpdateCore`, and
+// `@clack/prompts` ships ESM-only, which the CommonJS ts-jest transform can't
+// load. The intro/outro chrome lives in `index.ts`'s Commander registration
+// instead (which already imports clack at the top and is never `require()`d
+// by tests).
+const picocolors_1 = __importDefault(require("picocolors"));
+const config_1 = require("../utils/config");
+const agent_targets_1 = require("../core/agent-targets");
+const registries_1 = require("../core/registries");
+const regenerate_1 = require("../core/context/regenerate");
+const reconciliation_1 = require("../core/reconciliation");
+const install_transaction_1 = require("../core/install-transaction");
+const resync_1 = require("../commands/hooks/resync");
+const defaultDeps = {
+    syncRegistries: registries_1.syncRegistries,
+    verifyMinCliVersions: registries_1.verifyMinCliVersions,
+    regenerateGlobalContext: regenerate_1.regenerateGlobalContext,
+    planReconciliation: reconciliation_1.planReconciliation,
+    applyInstallPlan: install_transaction_1.applyInstallPlan,
+    resyncInstalledHooks: resync_1.resyncInstalledHooks,
+    offerSelfUpdate: async () => {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { offerSelfUpdate: real } = require('../core/update-check');
+        await real();
+    },
+};
+/**
+ * Core, UI-free `awm update` logic: resolves agent targets, runs every stage
+ * in order (registry sync → CLI-version gate → context regen → artifact
+ * reconciliation → hook resync → self-update offer), and returns the
+ * selected targets alongside an exit code so callers/tests don't need to
+ * scrape console output. `deps` is fully injectable for tests (mirrors
+ * `runInit`'s `actions` seam).
+ */
+async function runUpdateCore(options = {}, deps = {}) {
+    const d = { ...defaultDeps, ...deps };
+    const prefs = (0, config_1.getPreferences)();
+    const resolved = (0, agent_targets_1.resolveAgentTargetsOrError)({ prefs, explicit: options.agent });
+    if (!resolved.ok) {
+        console.error(picocolors_1.default.red(resolved.error));
+        return { code: 1, selectedAgents: [] };
+    }
+    const selectedAgents = resolved.targets;
+    const registryResults = await d.syncRegistries();
+    for (const r of registryResults) {
+        if (r.action === 'error')
+            console.warn(picocolors_1.default.yellow(`  ⚠  registry ${r.name}: ${r.error}`));
+        else
+            console.log(picocolors_1.default.green(`  ✓ Registry ${r.name} ${r.action === 'pulled' ? 'updated' : 're-cloned'} @ ${r.version}`));
+    }
+    try {
+        (0, registries_1.assertRegistryGates)(d.verifyMinCliVersions());
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red(e.message));
+        return { code: 1, selectedAgents };
+    }
+    const regen = d.regenerateGlobalContext(selectedAgents);
+    const refreshed = regen.filter((r) => r.action === 'refreshed').map((r) => r.agent);
+    if (refreshed.length > 0)
+        console.log(picocolors_1.default.green(`  ✓ Regenerated AWM context for: ${refreshed.join(', ')}`));
+    let artifactResult;
+    try {
+        const artifactPlan = d.planReconciliation({ targets: selectedAgents, roots: (0, registries_1.contentRoots)() });
+        artifactResult = d.applyInstallPlan(artifactPlan);
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red(`Artifact reconciliation failed: ${e.message}`));
+        return { code: 1, selectedAgents };
+    }
+    if (artifactResult.installed.length > 0) {
+        console.log(picocolors_1.default.green(`  ✓ Reconciled artifacts: ${artifactResult.installed.join(', ')}`));
+    }
+    const hooksRoot = (0, registries_1.capabilityRoot)('hooks');
+    if (hooksRoot) {
+        try {
+            for (const r of d.resyncInstalledHooks(hooksRoot, selectedAgents)) {
+                if (r.action === 'resynced')
+                    console.log(picocolors_1.default.green(`  ✓ Re-synced ${r.agent} hook scripts`));
+                else if (r.action === 'registry-missing')
+                    console.warn(picocolors_1.default.yellow(`  ⚠  ${r.agent} hook installed but registry hooks missing — run 'awm hooks install'`));
+            }
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`Hook resync failed: ${e.message}`));
+            return { code: 1, selectedAgents };
+        }
+    }
+    await d.offerSelfUpdate();
+    return { code: 0, selectedAgents };
+}

package/dist/src/core/agent-targets.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAgentTargets = resolveAgentTargets;
+exports.resolveAgentTargetsOrError = resolveAgentTargetsOrError;
+const providers_1 = require("../providers");
+function resolveAgentTargets(input) {
+    if (!input || typeof input !== 'object' ||
+        !input.prefs || !Array.isArray(input.prefs.enabledAgents) ||
+        !input.prefs.enabledAgents.every(providers_1.isAgentTarget)) {
+        throw new Error('resolveAgentTargets requires valid enabledAgents preferences');
+    }
+    if (input.explicit !== undefined && typeof input.explicit !== 'string') {
+        throw new Error('--agent must be a comma-separated provider list');
+    }
+    if (input.explicit === undefined)
+        return [...input.prefs.enabledAgents];
+    const raw = input.explicit
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (raw.length === 0)
+        throw new Error('--agent requires at least one provider');
+    const agents = Array.from(new Set(raw));
+    for (const agent of agents) {
+        if (!(0, providers_1.isAgentTarget)(agent))
+            throw new Error(`Invalid agent "${agent}".`);
+        if (!input.prefs.enabledAgents.includes(agent)) {
+            throw new Error(`${agent} is not enabled; run awm init --agent ${agent}`);
+        }
+    }
+    return agents;
+}
+/**
+ * Non-throwing wrapper over `resolveAgentTargets` — every one of `add`,
+ * `remove`, `sync`, `update` and `doctor` needs the exact same
+ * try/resolve/catch shape, but each has a different failure-handling style
+ * (`process.exit` in `index.ts`'s interactive Commander actions vs. returning
+ * `{ code: 1, ... }` from the testable `run*Core` functions). Keeping this
+ * wrapper pure (no logging, no process.exit) lets every call site reuse the
+ * SAME resolution logic while choosing its own way to report/exit on
+ * failure, rather than duplicating the try/catch at each of the 6+ sites.
+ */
+function resolveAgentTargetsOrError(input) {
+    try {
+        return { ok: true, targets: resolveAgentTargets(input) };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}

package/dist/src/core/artifact-state.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.artifactStateFile = artifactStateFile;
+exports.readArtifactState = readArtifactState;
+exports.writeArtifactState = writeArtifactState;
+exports.mergeArtifactRecords = mergeArtifactRecords;
+// src/core/artifact-state.ts
+//
+// Persistent ownership ledger for artifacts materialized by the planner
+// (install-planner.ts). One record per physical target path; `owners` tracks
+// which agent targets currently depend on that target so a later removal
+// (planRemoval) knows whether it's safe to delete (R16).
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
+const atomic_file_1 = require("./atomic-file");
+function artifactStateFile() {
+    return path_1.default.join((0, paths_1.awmHome)(), 'state', 'artifacts.json');
+}
+function readArtifactState(file = artifactStateFile()) {
+    if (!fs_1.default.existsSync(file))
+        return [];
+    let value;
+    try {
+        value = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new Error(`${file} is not valid JSON. Fix it manually, then re-run.`);
+    }
+    if (!Array.isArray(value))
+        throw new Error(`${file} must contain an array`);
+    return value;
+}
+function writeArtifactState(records, file = artifactStateFile()) {
+    const ordered = [...records].sort((a, b) => a.targetPath.localeCompare(b.targetPath));
+    (0, atomic_file_1.writeFileAtomic)(file, JSON.stringify(ordered, null, 2) + '\n', 0o600);
+}
+/**
+ * Upserts `incoming` records into `existing`, keyed by `targetPath` — the
+ * natural unique key for a ManagedArtifactRecord (see module docstring: "one
+ * record per physical target path"). For each `targetPath` present in
+ * `incoming`, the incoming record REPLACES any existing record for that same
+ * path (it reflects the current true ownership state for that target after
+ * the apply that produced it). Every existing record whose `targetPath` is
+ * NOT touched by `incoming` is preserved unchanged.
+ *
+ * This is what makes a sequence of `applyInstallPlan` calls (e.g. the several
+ * separate calls a real `awm init` run makes — one per bundle) additive
+ * instead of each one clobbering every earlier call's ownership records.
+ * `writeArtifactState` itself stays a low-level "write exactly this array"
+ * primitive; callers that already have the final desired record set (e.g. a
+ * future `planRemoval`-driven deletion) should keep calling it directly
+ * rather than through this merge.
+ */
+function mergeArtifactRecords(existing, incoming) {
+    const byTargetPath = new Map();
+    for (const record of existing)
+        byTargetPath.set(record.targetPath, record);
+    for (const record of incoming)
+        byTargetPath.set(record.targetPath, record);
+    return Array.from(byTargetPath.values());
+}

package/dist/src/core/atomic-file.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileAtomic = writeFileAtomic;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+function targetMode(file) {
+    try {
+        const stat = fs_1.default.lstatSync(file);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`refusing to replace symlink target: ${file}`);
+        }
+        return stat.isFile() ? stat.mode & 0o777 : undefined;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function writeFileAtomic(file, content, mode = 0o644) {
+    if (typeof file !== 'string' || file.length === 0) {
+        throw new Error('file must be a non-empty string');
+    }
+    if (typeof content !== 'string') {
+        throw new Error('content must be a string');
+    }
+    if (!Number.isInteger(mode) || mode < 0 || mode > 0o777) {
+        throw new Error('mode must be an integer between 0 and 0777');
+    }
+    const existingMode = targetMode(file);
+    const effectiveMode = existingMode ?? mode;
+    const directory = path_1.default.dirname(file);
+    const nonce = crypto_1.default.randomBytes(16).toString('hex');
+    const temporary = path_1.default.join(directory, `.${path_1.default.basename(file)}.${process.pid}.${nonce}.tmp`);
+    fs_1.default.mkdirSync(directory, { recursive: true });
+    let descriptor;
+    let ownsTemporary = false;
+    try {
+        descriptor = fs_1.default.openSync(temporary, 'wx', effectiveMode);
+        ownsTemporary = true;
+        fs_1.default.writeFileSync(descriptor, content, { encoding: 'utf8' });
+        fs_1.default.fchmodSync(descriptor, effectiveMode);
+        fs_1.default.fsyncSync(descriptor);
+        fs_1.default.closeSync(descriptor);
+        descriptor = undefined;
+        targetMode(file);
+        fs_1.default.renameSync(temporary, file);
+    }
+    catch (error) {
+        if (descriptor !== undefined) {
+            try {
+                fs_1.default.closeSync(descriptor);
+            }
+            catch {
+                // best-effort: preserve the original write error; the descriptor closes on process exit.
+            }
+        }
+        if (ownsTemporary) {
+            try {
+                fs_1.default.rmSync(temporary, { force: true });
+            }
+            catch {
+                // best-effort: preserve the original write error; a failed temp cleanup may leave one sibling file.
+            }
+        }
+        throw error;
+    }
+}