agentic-workflow-manager 3.12.0 → 3.13.1

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

@@ -29,7 +29,20 @@ function syncExecutable(source, dest, method) {
     catch { /* not exists, fine */ }
     fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
     if (method === 'symlink') {
-        fs_1.default.symlinkSync(source, dest);
+        try {
+            fs_1.default.symlinkSync(source, dest);
+        }
+        catch {
+            // best-effort: a FILE symlink needs SeCreateSymbolicLinkPrivilege on
+            // Windows, denied by default on unprivileged accounts (incl. GitHub
+            // Actions' windows-latest runner) — fall back to a plain copy, same
+            // as the bootstrap skill file's own fallback (hooks/claude.ts) and
+            // executor.ts's stageArtifact for file artifacts. 'awm update' will
+            // not auto-propagate for this file until re-synced, same tradeoff.
+            fs_1.default.copyFileSync(source, dest);
+            const srcMode = fs_1.default.statSync(source).mode;
+            fs_1.default.chmodSync(dest, srcMode);
+        }
     }
     else {
         fs_1.default.copyFileSync(source, dest);

package/dist/src/commands/preflight/checks.js

@@ -9,6 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const status_1 = require("../sensors/status");
 const init_1 = require("../sensors/init");
+const baseline_1 = require("../sensors/baseline");
 const paths_1 = require("../../core/paths");
 const MANIFEST = path_1.default.join('.awm', 'sensors.json');
 /**
@@ -36,6 +37,18 @@ function readManifest(cwd) {
         return null;
     }
 }
+/**
+ * Total sensor entries and how many are enabled (`enabled !== false`, so a missing
+ * `enabled` field defaults to counted-as-enabled). Shared by `checkManifest` and
+ * `checkSensorsBaseline` — they were previously two copies of the identical
+ * predicate, which post-implementation-qa flagged: a hardening applied to one (e.g.
+ * guarding a malformed sensor entry) would silently NOT apply to the other unless
+ * someone remembered to edit both. One function, two callers, one place to harden.
+ */
+function countEnabledSensors(manifest) {
+    const entries = Object.values(manifest.sensors ?? {});
+    return { total: entries.length, enabled: entries.filter(s => s.enabled !== false).length };
+}
 /**
  * A repo may legitimately have no sensors — but it has to SAY so, in a committed file.
  *
@@ -62,8 +75,7 @@ function checkManifest(cwd, manifest) {
             remedy: 'fix or regenerate it with `awm sensors init`',
         };
     }
-    const total = Object.keys(manifest.sensors ?? {}).length;
-    const enabled = Object.values(manifest.sensors ?? {}).filter(s => s.enabled !== false).length;
+    const { total, enabled } = countEnabledSensors(manifest);
     // total === 0 is NOT an opt-out: a deliberate opt-out lists every known sensor NAME
     // explicitly with `enabled: false` (total > 0, enabled === 0). Zero entries means
     // nothing was ever configured — most commonly because the registry had no pack.json
@@ -135,6 +147,51 @@ function checkPack(cwd, manifest) {
     }
     return { id: 'pack', ok: true, detail: `${manifest.pack} matches the detected stack` };
 }
+/**
+ * Advisory only — `ok` is ALWAYS `true`, same contract as `checkHost` below. A team
+ * adopting AWM on a legacy repo starts with pre-existing sensor findings; the ratchet
+ * (`awm sensors baseline`, `.awm/sensors.baseline.json`) exists precisely to snapshot
+ * those as accepted debt so the gate only fails on genuinely NEW findings. But nothing
+ * today surfaces that the mechanism exists — the team discovers it only after hitting a
+ * wall of red findings and going looking. This nudges them toward it before that
+ * happens. It never blocks preflight: a repo can legitimately have zero debt to
+ * snapshot (sensors enabled from day one), and "no baseline yet" is not itself a
+ * failure — only the operator's lack of awareness that baselining is an option is the
+ * problem this addresses.
+ *
+ * Only called when a manifest exists (see the conditional spread in `preflight()`) —
+ * there is nothing to baseline without sensors configured in the first place, so this
+ * mirrors how `checkTools`/`checkPack` are skipped entirely rather than reported on a
+ * repo that was never set up.
+ *
+ * Also requires at least one ENABLED sensor, via the same `countEnabledSensors` helper
+ * `checkManifest` uses — a deliberate opt-out (every sensor `enabled: false`) or an
+ * unparseable/empty manifest has nothing to baseline either, and nudging "run `awm
+ * sensors baseline`" there would be actively misleading rather than merely unnecessary.
+ *
+ * Presence is checked via `readBaseline` (same function `partition()` uses at gate time
+ * to decide suppression), not a raw `fs.existsSync` — a baseline PATH that exists but
+ * isn't a readable JSON file (e.g. a stray directory at that path) is treated by the
+ * real gate as "no baseline, nothing suppressed"; `existsSync` alone would have reported
+ * "baseline present" for that same case, reassuring the operator that debt is being
+ * suppressed when it silently is not.
+ */
+function checkSensorsBaseline(cwd, manifest) {
+    const enabled = manifest ? countEnabledSensors(manifest).enabled : 0;
+    if (enabled === 0) {
+        return { id: 'sensors-baseline', ok: true, detail: 'no enabled sensors — nothing to baseline' };
+    }
+    if ((0, baseline_1.readBaseline)(cwd) !== null) {
+        return { id: 'sensors-baseline', ok: true, detail: 'baseline present' };
+    }
+    return {
+        id: 'sensors-baseline',
+        ok: true,
+        detail: 'sensors configured, no baseline yet — awm sensors baseline',
+        remedy: 'run `awm sensors baseline` to snapshot pre-existing findings as accepted debt, '
+            + 'so the gate only chases new problems',
+    };
+}
 /**
  * Extract just the hostname portion of a git remote URL — never match against the
  * full URL string. A bare substring check against the whole remote (`remote.includes
@@ -224,9 +281,10 @@ function preflight(cwd = process.cwd()) {
     const checks = [
         checkContext(cwd),
         checkManifest(cwd, manifest),
-        // Skipped when there is no manifest: reporting "tools broken" on a repo that was
-        // never set up buries the one thing the operator needs to read.
-        ...(manifestExists ? [checkTools(cwd), checkPack(cwd, manifest)] : []),
+        // Skipped when there is no manifest: reporting "tools broken" (or nudging toward
+        // a baseline that has nothing to snapshot) on a repo that was never set up
+        // buries the one thing the operator needs to read.
+        ...(manifestExists ? [checkTools(cwd), checkPack(cwd, manifest), checkSensorsBaseline(cwd, manifest)] : []),
         // Runs unconditionally — orthogonal to sensor configuration entirely, this is
         // about PR/MR tooling, not sensors.
         checkHost(cwd),

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

@@ -20,7 +20,12 @@ function exitCodeFor(report) {
     return report.status === 'ready' ? 0 : 1;
 }
 function formatReport(report) {
-    const lines = report.checks.map(c => `  ${c.ok ? picocolors_1.default.green('✔') : picocolors_1.default.red('✘')}  ${c.id.padEnd(9)} ${c.detail}`
+    // Computed from the actual ids present, not hardcoded to the widest id THIS
+    // report happens to have — a fixed literal here silently misaligns the moment a
+    // longer `PreflightCheck['id']` is added (confirmed: 'sensors-baseline', at 16
+    // chars, broke a hardcoded 9-char pad).
+    const idWidth = Math.max(0, ...report.checks.map(c => c.id.length));
+    const lines = report.checks.map(c => `  ${c.ok ? picocolors_1.default.green('✔') : picocolors_1.default.red('✘')}  ${c.id.padEnd(idWidth)} ${c.detail}`
         + (c.remedy ? `\n       ${picocolors_1.default.dim('→ ' + c.remedy)}` : ''));
     if (report.status === 'ready') {
         return `${picocolors_1.default.green('✔')}  Harness ready — this project can be gated.\n${lines.join('\n')}\n`;

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

@@ -13,7 +13,16 @@ const registries_1 = require("../../core/registries");
 const discovery_1 = require("../../core/discovery");
 const bundles_1 = require("../../core/bundles");
 function deriveRegistryName(remote) {
-    const base = remote.replace(/\/+$/, '').split(/[/:]/).pop() ?? '';
+    // Split on '/', '\' and ':' — not just '/' and ':'. A git remote URL
+    // (https://…/repo.git, git@host:org/repo.git) only ever uses the first
+    // two, but `remote` here can also be a plain local filesystem path (e.g.
+    // a `awm registry add <local-repo>` clone source, or this repo's own
+    // tests), and on native Windows that path is backslash-separated
+    // (`C:\Users\...\src-alpha`). Splitting on `[/:]` alone leaves the whole
+    // backslash-joined tail as one segment (`\Users\...\src-alpha`), which
+    // then fails the caller's `/[/\\]/.test(name)` invalid-name check and
+    // makes every local-path `addRegistry` call fail on Windows.
+    const base = remote.replace(/[/\\]+$/, '').split(/[/\\:]/).pop() ?? '';
     return base.replace(/\.git$/, '');
 }
 async function addRegistry(remote, nameOverride) {

package/dist/src/commands/sensors/baseline.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASELINE_FILE = void 0;
 exports.fingerprint = fingerprint;
 exports.readBaseline = readBaseline;
 exports.writeBaseline = writeBaseline;
@@ -11,7 +12,7 @@ exports.buildBaseline = buildBaseline;
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const BASELINE_FILE = path_1.default.join('.awm', 'sensors.baseline.json');
+exports.BASELINE_FILE = path_1.default.join('.awm', 'sensors.baseline.json');
 /**
  * Mask runs of digits so location noise embedded in messages (e.g. the tsc
  * formatter writes "... line 199 ...") doesn't change the fingerprint when code
@@ -43,7 +44,7 @@ function fingerprint(sensor, e) {
     return crypto_1.default.createHash('sha1').update(basis).digest('hex');
 }
 function readBaseline(cwd) {
-    const p = path_1.default.join(cwd, BASELINE_FILE);
+    const p = path_1.default.join(cwd, exports.BASELINE_FILE);
     if (!fs_1.default.existsSync(p))
         return null;
     try {
@@ -55,7 +56,7 @@ function readBaseline(cwd) {
 }
 function writeBaseline(cwd, baseline) {
     fs_1.default.mkdirSync(path_1.default.join(cwd, '.awm'), { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(cwd, BASELINE_FILE), JSON.stringify(baseline, null, 2), 'utf-8');
+    fs_1.default.writeFileSync(path_1.default.join(cwd, exports.BASELINE_FILE), JSON.stringify(baseline, null, 2), 'utf-8');
 }
 /**
  * Split a sensor's findings into new vs baseline-suppressed. With no accepted

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

@@ -75,12 +75,34 @@ function writeFileAtomic(file, content, mode = 0o644) {
 /** fsync del directorio contenedor: garantiza que una ENTRADA creada/renombrada
  *  sobrevive un crash del OS. Falla LANZANDO — la durabilidad de la transición
  *  es parte del contrato, nunca un best-effort silencioso (design R1.2,
- *  bloqueador 4 de la review del plan). */
+ *  bloqueador 4 de la review del plan) — EXCEPTO en Windows, donde fsync-ear un
+ *  file descriptor de directorio no es una operacion que el SO soporte en
+ *  absoluto (no es una falla de durabilidad real: no existe el mecanismo
+ *  POSIX que esta funcion intenta invocar). Confirmado via R6 CI (2026-08-08,
+ *  primera corrida real en windows-latest): `fs.openSync(dir, 'r')` tiene
+ *  exito, pero el `fsyncSync` subsiguiente sobre ese fd siempre falla con
+ *  EPERM — libuv mapea asi el resultado de `FlushFileBuffers` sobre un handle
+ *  de directorio en Win32, que Windows rechaza categoricamente (no es un
+ *  fallo intermitente de hardware/permisos, es ausencia de la capacidad).
+ *  NTFS ya registra los renames/creates en su propio journal transaccional,
+ *  asi que la garantia de durabilidad de la ENTRADA sigue sostenida por el
+ *  filesystem — solo el mecanismo explicito para pedirla no existe ahi.
+ *  Por eso, y solo para esta combinacion exacta (win32 + EPERM en el fsync,
+ *  nunca en el open), esta funcion degrada a no-op en vez de lanzar; culquier
+ *  otra plataforma, o cualquier otro código de error incluso en Windows
+ *  (el open fallando, ENOENT, EACCES por permisos reales), sigue lanzando. */
 function fsyncDirSync(dir) {
     let dirFd;
     try {
         dirFd = fs_1.default.openSync(dir, 'r');
-        fs_1.default.fsyncSync(dirFd);
+        try {
+            fs_1.default.fsyncSync(dirFd);
+        }
+        catch (error) {
+            if (process.platform === 'win32' && error.code === 'EPERM')
+                return;
+            throw error;
+        }
     }
     catch (error) {
         throw new Error(`fsync de directorio fallo para ${dir}: ${error.message}`);

package/dist/src/core/executor.js

@@ -10,6 +10,7 @@ exports.installArtifact = installArtifact;
 // src/core/executor.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
 function removeArtifact(targetPath) {
     let exists = false;
     try {
@@ -39,7 +40,45 @@ function stageArtifact(sourcePath, targetPath, method) {
     const staged = path_1.default.join(parent, `.${path_1.default.basename(targetPath)}.${process.pid}.staged`);
     fs_1.default.rmSync(staged, { recursive: true, force: true });
     if (method === 'symlink') {
-        fs_1.default.symlinkSync(sourcePath, staged, 'dir');
+        const sourceIsDirectory = fs_1.default.statSync(sourcePath).isDirectory();
+        if (sourceIsDirectory) {
+            // A directory *symlink* ('dir') needs SeCreateSymbolicLinkPrivilege on
+            // Windows — denied by default on unprivileged accounts, including
+            // GitHub Actions' windows-latest runner, so every install here would
+            // throw EPERM. A *junction* is a different NTFS reparse-point kind
+            // that Windows lets any account create, and Node/libuv report it the
+            // same way a symlink is reported (`lstat().isSymbolicLink()` is true,
+            // `readlinkSync()` resolves it) — so every downstream consumer
+            // (verify(), R19's provider-facts hashing, doctor's symlink checks)
+            // keeps working unmodified. Junctions require an absolute target,
+            // which `sourcePath` always is here (registry content roots are
+            // resolved under `awmHome()`). POSIX platforms are unaffected: 'dir'
+            // is a plain no-op hint there.
+            fs_1.default.symlinkSync(sourcePath, staged, (0, paths_1.isWindowsNative)() ? 'junction' : 'dir');
+        }
+        else {
+            // A junction is an NTFS *directory* reparse point — it has no
+            // equivalent for an individual FILE artifact (agent .md, workflow
+            // .md, ...), so a file source must never be passed to it (it was,
+            // before this branch existed, and that silently produced a
+            // reparse point that could not resolve back to the file — see
+            // tests/core/bundle-install.test.ts's "claude-code agents" case).
+            // A 'file'-type symlink is the correct primitive here, but it
+            // needs the same SeCreateSymbolicLinkPrivilege a directory symlink
+            // does, and Windows has no privilege-free substitute for files the
+            // way junctions are for directories. So: attempt the real symlink
+            // (works, and keeps `awm update` propagation, whenever the
+            // privilege IS available — e.g. Developer Mode) and fall back to a
+            // plain copy otherwise, mirroring the established fallback already
+            // used for the bootstrap skill file (hooks/claude.ts,
+            // tests/commands/hooks/install-symlink-fallback.test.ts).
+            try {
+                fs_1.default.symlinkSync(sourcePath, staged, 'file');
+            }
+            catch {
+                fs_1.default.copyFileSync(sourcePath, staged);
+            }
+        }
     }
     else {
         fs_1.default.cpSync(sourcePath, staged, { recursive: true });

package/dist/src/core/install-transaction.js

@@ -339,7 +339,19 @@ function defaultTransactionDeps() {
                 return;
             }
             if (op.method === 'symlink' && !stat.isSymbolicLink()) {
-                throw new Error(`verification failed: ${op.targetPath} is not a symlink`);
+                // executor.ts's stageArtifact falls back to a plain copy for a
+                // FILE source when the real 'file'-type symlink throws (no
+                // privilege-free equivalent to a directory junction exists for
+                // individual files on Windows) — accept that fallback here
+                // rather than failing verification for an install that landed
+                // correctly, just not as a symlink. A directory source always
+                // gets a privilege-free junction and should never legitimately
+                // reach this branch, so this stays scoped to files only.
+                const sourceIsDirectory = fs_1.default.existsSync(op.sourcePath) && fs_1.default.statSync(op.sourcePath).isDirectory();
+                const acceptableFileFallback = !sourceIsDirectory && stat.isFile();
+                if (!acceptableFileFallback) {
+                    throw new Error(`verification failed: ${op.targetPath} is not a symlink`);
+                }
             }
             if (op.method === 'copy' && stat.isSymbolicLink()) {
                 throw new Error(`verification failed: ${op.targetPath} is unexpectedly a symlink`);