agentic-workflow-manager 9.22.0 → 9.22.1

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

@@ -119,7 +119,7 @@ function changeNew(cwd, slug, rawOpts, deps) {
     if (!range.ok)
         return (0, command_1.failed)(range.failure);
     const { head } = range;
-    const derived = (0, derive_1.deriveFields)(root, range.mergeBase);
+    const derived = (0, derive_1.deriveFields)(root, range.mergeBase, head);
     if (!derived.ok)
         return (0, command_1.fail)(derived.diagnostic.code, derived.diagnostic.message);
     const movedAfterDerive = (0, range_1.headMovedFailure)(root, head);
@@ -255,7 +255,7 @@ function failure(json, code, message, remedy) {
         return (0, command_1.fail)(code, message, remedy);
     return render(true, 'invalid', [finish(types_1.RECORD_DIR, [{ code, message: remedy ? `${message}; ${remedy}` : message }])]);
 }
-const deriveOnce = (run) => (run.derived ??= (0, derive_1.deriveFields)(run.root, run.mergeBaseSha));
+const deriveOnce = (run) => (run.derived ??= (0, derive_1.deriveFields)(run.root, run.mergeBaseSha, run.head));
 function lateFiles(run, commit) {
     if (!run.late.has(commit)) {
         const raw = (0, git_1.changedFiles)(run.root, commit, run.head);

package/dist/src/commands/init.js

@@ -45,6 +45,7 @@ const doctor_1 = require("./doctor");
 const context_1 = require("../core/diagnostics/context");
 const bundles_1 = require("../core/bundles");
 const registries_1 = require("../core/registries");
+const registry_sync_report_1 = require("../core/registry-sync-report");
 const orchestrator_1 = require("../core/init/orchestrator");
 const steps_1 = require("../core/init/steps");
 const failure_1 = require("../core/init/failure");
@@ -210,10 +211,13 @@ async function runInit(opts = {}) {
             (0, registries_1.seedBaselineRegistry)();
             if ((0, registries_1.registriesNeedSync)()) {
                 // `syncRegistries()` reports per-registry failures as RESULTS,
-                // never as throws (core/registries.ts) — swallowing them here
-                // let an unavailable registry degrade silently into some later
-                // step's failure instead of being reported as its own cause.
-                (0, registries_1.assertSyncedRegistriesUsable)((await mergedActions.syncCache()) ?? []);
+                // never as throws (core/registries.ts). SG-7: init exits non-zero
+                // on any sync/clone failure (usable cache is not enough here).
+                const syncResults = (await mergedActions.syncCache()) ?? [];
+                if ((0, registry_sync_report_1.hardFailOnAnyRegistrySyncError)(syncResults)) {
+                    throw new Error(`registry sync failed — ${(0, registries_1.describeRegistrySyncErrors)((0, registries_1.registrySyncErrors)(syncResults))}`);
+                }
+                (0, registries_1.assertSyncedRegistriesUsable)(syncResults);
             }
             const bundles = (0, bundles_1.discoverAllBundles)(undefined, reporter);
             const ctx = (0, context_1.gatherContext)({ cwd, bundles, agent });

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

@@ -8,8 +8,9 @@ exports.addRegistry = addRegistry;
 // cli/src/commands/registry/add.ts
 // Logic for `awm registry add`, separated from commander wiring (testable without prompts).
 const fs_1 = __importDefault(require("fs"));
-const simple_git_1 = __importDefault(require("simple-git"));
 const registries_1 = require("../../core/registries");
+const registry_git_1 = require("../../core/registry-git");
+const registry_git_errors_1 = require("../../core/registry-git-errors");
 const discovery_1 = require("../../core/discovery");
 const bundles_1 = require("../../core/bundles");
 const orchestrators_1 = require("../../core/orchestrators");
@@ -40,12 +41,17 @@ async function addRegistry(remote, nameOverride, reporter) {
         return { ok: false, name, error: `Destination already exists on disk: ${dest}` };
     }
     fs_1.default.mkdirSync((0, registries_1.registriesDir)(), { recursive: true });
+    (0, registry_git_1.warnIgnoredGitEnvOnce)();
     try {
-        await (0, simple_git_1.default)().clone(remote, dest);
+        await (0, registry_git_1.createRegistryGit)().clone(remote, dest);
     }
     catch (e) {
         fs_1.default.rmSync(dest, { recursive: true, force: true });
-        return { ok: false, name, error: `Clone failed: ${e instanceof Error ? e.message : String(e)}` };
+        return {
+            ok: false,
+            name,
+            error: (0, registry_git_errors_1.formatClassifiedRegistryFailure)({ name, remote, err: e }),
+        };
     }
     if (!(0, registries_1.validateRegistryLayout)(dest)) {
         fs_1.default.rmSync(dest, { recursive: true, force: true });

package/dist/src/commands/sync.js

@@ -19,6 +19,7 @@ const picocolors_1 = __importDefault(require("picocolors"));
 const paths_1 = require("../core/paths");
 const profile_1 = require("../core/profile");
 const registries_1 = require("../core/registries");
+const registry_sync_report_1 = require("../core/registry-sync-report");
 const bundles_1 = require("../core/bundles");
 const bundle_install_1 = require("../core/bundle-install");
 const profile_pins_1 = require("../core/profile-pins");
@@ -74,9 +75,14 @@ async function runSyncCore(options, deps = {}) {
     }
     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}`));
+    // SG-7: any sync/clone failure → non-zero exit. Keep later profile sync / link
+    // repair when usable content remains (audit A1) — aborting here left healthy
+    // registries advanced on disk without reconciling the project tree.
+    const syncHadErrors = (0, registry_sync_report_1.hardFailOnAnyRegistrySyncError)(syncResults);
+    if (syncHadErrors) {
+        for (const e of (0, registries_1.registrySyncErrors)(syncResults)) {
+            console.error(picocolors_1.default.red(`  ✖  registry ${e.name}: ${e.error}`));
+        }
     }
     try {
         (0, registries_1.assertSyncedRegistriesUsable)(syncResults);
@@ -126,7 +132,7 @@ async function runSyncCore(options, deps = {}) {
     reportProjectLinkRepair(d.reconcileProjectSkillLinks(projectRoot, selectedAgents, (0, registries_2.contentRoots)()));
     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 };
+        return { code: syncHadErrors ? 1 : 0, selectedAgents };
     }
     const method = options.method === 'copy' ? 'copy' : 'symlink';
     let result;
@@ -150,5 +156,5 @@ async function runSyncCore(options, deps = {}) {
     for (const id of result.transactionIds) {
         console.log(picocolors_1.default.dim(`  transaction ${id} — undo with \`awm backup restore ${id}\``));
     }
-    return { code: 0, selectedAgents, result };
+    return { code: syncHadErrors ? 1 : 0, selectedAgents, result };
 }

package/dist/src/commands/update.js

@@ -26,6 +26,7 @@ const paths_1 = require("../core/paths");
 const config_1 = require("../utils/config");
 const agent_targets_1 = require("../core/agent-targets");
 const registries_1 = require("../core/registries");
+const registry_sync_report_1 = require("../core/registry-sync-report");
 const paths_2 = require("../core/paths");
 const regenerate_1 = require("../core/context/regenerate");
 const reconciliation_1 = require("../core/reconciliation");
@@ -59,11 +60,14 @@ function updateOutro(result) {
     const { registries: reg } = result;
     if (reg.configured === 0)
         return 'Nothing updated — no registries configured on this machine.';
-    if (result.code !== 0)
+    // SG-7: sync errors always yield code ≠ 0. When healthy registries still advanced,
+    // later stages ran — say so instead of the unreachable pre-SG-7 "stale content / exit 0".
+    if (result.code !== 0) {
+        if (reg.failed.length > 0 && reg.synced > 0) {
+            return (`⚠ Finished with registry sync errors — ${reg.synced}/${reg.configured} registries synced `
+                + `(failed: ${reg.failed.join(', ')}); see errors above.`);
+        }
         return 'Update failed — see errors above.';
-    if (reg.failed.length > 0) {
-        return `⚠ Updated with stale content — ${reg.synced}/${reg.configured} registries synced, `
-            + `kept on-disk content for: ${reg.failed.join(', ')}.`;
     }
     return `✅ ${reg.synced} ${reg.synced === 1 ? 'registry' : 'registries'}, skills and hooks updated.`;
 }
@@ -90,8 +94,10 @@ async function runUpdateCore(options = {}, deps = {}) {
     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}`));
+        if (r.action === 'error') {
+            // Printed below as a hard SG-7 failure — skip the stale warn path.
+            continue;
+        }
         else if (r.disposition === 'regressed') {
             const latest = r.availableVersion && r.availableVersion !== r.version
                 ? ` Latest available: ${r.availableVersion}.`
@@ -131,11 +137,16 @@ async function runUpdateCore(options = {}, deps = {}) {
         console.error(picocolors_1.default.dim("  This machine was never initialized: run 'awm init' first."));
         return { code: 1, selectedAgents, registries };
     }
-    // Falla CERRADO solo cuando el registry quedó sin contenido en disco: ahí lo que sigue
-    // leería un árbol inexistente y el fallo reaparecería más tarde, disfrazado de otra
-    // etapa. Un registry que falló pero conserva su contenido queda stale, no roto — se
-    // sigue (doctrina de `unusableSyncedRegistries`: un registry secundario flaky nunca
-    // aborta la corrida) y el cierre lo nombra en vez de declarar éxito parejo.
+    // SG-7: any sync/clone failure → non-zero exit with classified message.
+    // Do NOT abort the later stages early when healthy registries already advanced
+    // on disk (audit A1): reconcile / hooks / self-update still run against usable
+    // content, then the command exits ≠ 0 naming the failed registry.
+    const syncHadErrors = (0, registry_sync_report_1.hardFailOnAnyRegistrySyncError)(registryResults);
+    if (syncHadErrors) {
+        for (const e of (0, registries_1.registrySyncErrors)(registryResults)) {
+            console.error(picocolors_1.default.red(`  ✖  registry ${e.name}: ${e.error}`));
+        }
+    }
     try {
         (0, registries_1.assertSyncedRegistriesUsable)(registryResults);
     }
@@ -188,5 +199,5 @@ async function runUpdateCore(options = {}, deps = {}) {
     // pasa `undefined` a propósito, para que la decisión la tome `defaultSelfUpdateMode()`
     // según haya o no un humano en stdin — no este llamador.
     await d.offerSelfUpdate(options.yes === true ? 'assume-yes' : undefined);
-    return { code: 0, selectedAgents, registries };
+    return { code: syncHadErrors ? 1 : 0, selectedAgents, registries };
 }

package/dist/src/core/changes/derive.js

@@ -96,13 +96,16 @@ const fail = (code, message) => ({ ok: false, diagnostic: { code, message: (0, t
  * conventional commit does), while `semver` and `breaking` cover every commit.
  * `mergeBaseSha` must be a full commit id (the output of `mergeBase`); anything else is `invalid-input`.
  */
-function deriveFields(root, mergeBaseSha) {
+function deriveFields(root, mergeBaseSha, pinnedHead) {
     if (typeof root !== 'string' || root.length === 0)
         return fail('invalid-input', 'repository root must be a non-empty string');
     if (typeof mergeBaseSha !== 'string' || !types_1.COMMIT_ID.test(mergeBaseSha))
         return fail('invalid-input', `merge-base must be a full commit id, got "${(0, text_safety_1.esc)(mergeBaseSha)}"`);
-    // HEAD is read once: the log and the diff below both use this sha, so a HEAD that moves meanwhile cannot mix snapshots.
-    const head = (0, git_1.headSha)(root);
+    if (pinnedHead !== undefined && (typeof pinnedHead !== 'string' || !types_1.COMMIT_ID.test(pinnedHead)))
+        return fail('invalid-input', `pinned HEAD must be a full commit id, got "${(0, text_safety_1.esc)(pinnedHead)}"`);
+    // HEAD is read once: the log and the diff below both use this sha, so a HEAD that moves meanwhile cannot mix snapshots. A
+    // command that already pinned HEAD passes it (and checks `headMovedFailure` afterwards), saving one more `rev-parse`.
+    const head = pinnedHead ?? (0, git_1.headSha)(root);
     if (head === null)
         return fail('git-failed', 'git could not read HEAD');
     const range = `${mergeBaseSha}..${head}`;

package/dist/src/core/changes/git.js

@@ -171,8 +171,7 @@ function isCommittedClean(root, rel) {
  * Unknown state, or an unsafe exclusion, counts as dirty: an unreadable repository must never look clean.
  */
 function isDirtyOutside(root, extraExcludes) {
-    const state = (0, worktree_1.gitState)(root, true, extraExcludes);
-    return state.kind !== 'ok' || state.dirty;
+    return (0, worktree_1.treeDirty)(root, true, extraExcludes) !== false;
 }
 /** Repository root with native separators; null outside a repository. Only `rev-parse`: never a (slow, refreshing) `status`. */
 function repoRoot(cwd) {

package/dist/src/core/changes/worktree.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REASON_GIT_FAILED = exports.REASON_NOT_REPO = exports.RUNTIME_STATE_EXCLUDES = void 0;
 exports.gitState = gitState;
+exports.treeDirty = treeDirty;
 const path_1 = __importDefault(require("path"));
 const git_env_1 = require("./git-env");
 const text_safety_1 = require("./text-safety");
@@ -39,15 +40,26 @@ function gitState(cwd, untracked, extraExcludes = []) {
     catch (error) {
         return gitFailure(error);
     }
+    const dirty = treeDirty(root, untracked, extraExcludes);
+    return dirty === null ? { kind: 'failed' } : { kind: 'ok', root, commit, dirty };
+}
+/**
+ * Only the dirty measure of `gitState`, for a caller that already knows the repository root and does not need HEAD: one
+ * `status` instead of three git processes. Null when git fails or an exclusion is unsafe (the caller fails closed). Never throws.
+ */
+function treeDirty(root, untracked, extraExcludes = []) {
+    if (typeof root !== 'string' || root.length === 0)
+        return null;
+    if (!Array.isArray(extraExcludes) || extraExcludes.length > MAX_EXTRA_EXCLUDES || !extraExcludes.every(text_safety_1.isSafeRelativePath))
+        return null;
     try {
         // Submodules are never hidden by config (`.gitmodules` ignore=all, diff.ignoreSubmodules). The pre-run measure counts everything
         // (`none`); the post-run recheck is about tracked files only, so it also ignores untracked content inside a submodule
         // (sensor build/coverage output) while still seeing a moved checkout or modified tracked content (`untracked`).
         const args = ['status', '--porcelain', untracked ? '--untracked-files=normal' : '--untracked-files=no', untracked ? '--ignore-submodules=none' : '--ignore-submodules=untracked', '--', '.', ...exports.RUNTIME_STATE_EXCLUDES.map((p) => `:(exclude)${p}`), ...extraExcludes.map((p) => `:(exclude,literal)${p}`)];
-        const status = (0, git_env_1.execGit)(root, args, { stderr: 'ignore', maxBuffer: MAX_GIT_OUTPUT });
-        return { kind: 'ok', root, commit, dirty: status.trim().length > 0 };
+        return (0, git_env_1.execGit)(root, args, { stderr: 'ignore', maxBuffer: MAX_GIT_OUTPUT }).trim().length > 0;
     }
     catch {
-        return { kind: 'failed' };
+        return null;
     }
 }

package/dist/src/core/init/steps.js

@@ -162,21 +162,16 @@ async function stepCache(d) {
         return failed('machine.cache', 'machine', msg);
     }
     // `syncRegistries()` reports per-registry failures as RESULTS, not throws
-    // (registries.ts), so the `try` above catches none of them. Ignoring them
-    // is what let an unavailable base registry degrade silently into some
-    // later step's failure — with its own cause already gone.
+    // (registries.ts), so the `try` above catches none of them. SG-7: init must
+    // fail closed on ANY sync/clone failure (usable on-disk cache is not enough).
     const errors = (0, registries_1.registrySyncErrors)(results);
     if (errors.length === 0)
         return ok('machine.cache', 'machine', 'applied');
-    // A registry that errored and has no content on disk is unusable, and every
-    // later step that reads it will fail for a reason that no longer names this
-    // cause — so machine.cache owns it here. One that errored but still has
-    // content is stale, not broken: record it and carry on.
     const unusable = (0, registries_1.unusableSyncedRegistries)(results);
     if (unusable.length > 0) {
         return failed('machine.cache', 'machine', `registry unavailable — ${(0, registries_1.describeRegistrySyncErrors)(unusable)}`);
     }
-    return ok('machine.cache', 'machine', 'applied', `stale registries — ${(0, registries_1.describeRegistrySyncErrors)(errors)}`);
+    return failed('machine.cache', 'machine', `registry sync failed — ${(0, registries_1.describeRegistrySyncErrors)(errors)}`);
 }
 /** Step 2 – Install the session-start hook for the target agent. */
 function stepHook(d) {

package/dist/src/core/registries.js

@@ -30,8 +30,9 @@ exports.assertRegistryGates = assertRegistryGates;
 // src/core/registries.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const simple_git_1 = __importDefault(require("simple-git"));
 const registry_1 = require("./registry");
+const registry_git_1 = require("./registry-git");
+const registry_git_errors_1 = require("./registry-git-errors");
 const versioning_1 = require("./versioning");
 const cli_version_1 = require("./cli-version");
 const paths_1 = require("./paths");
@@ -229,8 +230,10 @@ function registriesNeedSync() {
     return listRegistries().some((registry) => !validateRegistryLayout(registry.contentRoot));
 }
 /** Sincroniza cada registry configurado al ref resuelto (pin > último tag > HEAD);
- *  re-clona si falta el dir. Errores por-registry NO fatales: se reportan en el resultado. */
+ *  re-clona si falta el dir. Errores por-registry se reportan en el resultado (clasificados SG-6);
+ *  si el llamador debe abortar lo decide la política SG-7 del comando. */
 async function syncRegistries() {
+    (0, registry_git_1.warnIgnoredGitEnvOnce)();
     const results = [];
     for (const reg of listRegistries()) {
         try {
@@ -241,7 +244,7 @@ async function syncRegistries() {
             if (freshClone) {
                 fs_1.default.mkdirSync(registriesDir(), { recursive: true });
                 try {
-                    await (0, simple_git_1.default)().clone(reg.remote, reg.contentRoot);
+                    await (0, registry_git_1.createRegistryGit)().clone(reg.remote, reg.contentRoot);
                 }
                 catch (e) {
                     fs_1.default.rmSync(reg.contentRoot, { recursive: true, force: true });
@@ -249,9 +252,9 @@ async function syncRegistries() {
                 }
             }
             else {
-                await (0, simple_git_1.default)(reg.contentRoot).reset(['--hard']);
+                await (0, registry_git_1.createRegistryGit)(reg.contentRoot).reset(['--hard']);
             }
-            const git = (0, simple_git_1.default)(reg.contentRoot);
+            const git = (0, registry_git_1.createRegistryGit)(reg.contentRoot);
             const previousVersion = freshClone ? null : await (0, versioning_1.currentVersion)(reg.contentRoot);
             const versionOpts = (0, versioning_1.machineVersionOpts)(reg.name);
             let resolved;
@@ -290,7 +293,11 @@ async function syncRegistries() {
             });
         }
         catch (e) {
-            results.push({ name: reg.name, action: 'error', error: e instanceof Error ? e.message : String(e) });
+            results.push({
+                name: reg.name,
+                action: 'error',
+                error: (0, registry_git_errors_1.formatClassifiedRegistryFailure)({ name: reg.name, remote: reg.remote, err: e }),
+            });
         }
     }
     return results;
@@ -309,15 +316,13 @@ function describeRegistrySyncErrors(errors) {
  * Registries that both errored during sync AND no longer have a usable content
  * layout afterwards — i.e. genuinely unusable, as opposed to merely stale.
  *
- * `syncRegistries()` deliberately reports per-registry failures as results
- * rather than throwing, so a flaky secondary registry never aborts a whole
- * run. Callers that go on to READ registry content (init) still need to know
- * whether what they are about to read remains usable: otherwise a missing,
- * empty, or unsafe registry
- * resurfaces much later as an unrelated step's failure, with its real cause
- * already discarded. Note that "usable" is deliberately about content on disk,
- * not about being a healthy git clone — a seeded content root with no `.git`
- * fails to sync every time and is still perfectly readable.
+ * `syncRegistries()` still reports per-registry failures as results rather than
+ * throwing (so callers can classify/format each one). Under SG-7, init / update /
+ * sync / registry add exit non-zero on ANY sync error; add / list may continue
+ * only when cached content remains usable — and this helper is what those soft
+ * paths consult. "Usable" is about content on disk, not a healthy git clone —
+ * a seeded content root with no `.git` fails to sync every time and is still
+ * readable.
  */
 function unusableSyncedRegistries(results) {
     const errors = registrySyncErrors(results);

package/dist/src/core/registry-git-errors.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactRemoteForDisplay = redactRemoteForDisplay;
+exports.extractFatalLine = extractFatalLine;
+exports.classifyRegistryGitError = classifyRegistryGitError;
+exports.formatClassifiedRegistryFailure = formatClassifiedRegistryFailure;
+const registry_git_1 = require("./registry-git");
+const text_safety_1 = require("./changes/text-safety");
+const REMEDIES = {
+    authentication: 'configure credential.helper (awm ignores ambient GIT_ASKPASS)',
+    tls: 'git config --global http.sslCAInfo <path> or http.sslCAPath (awm ignores ambient GIT_SSL_*)',
+    network: 'check connectivity / proxy via git config --global http.proxy (awm does not pass ambient GIT_* proxy vars)',
+    ssh: 'set core.sshCommand or ~/.ssh/config (awm ignores ambient GIT_SSH_COMMAND)',
+    'not-found': 'verify the remote URL and that the repository exists and is reachable',
+    // simple-git `timeout.block` resets on stdout/stderr activity — idle bound, not wall-clock.
+    // Only the plugin's "block timeout reached" is this class (audit M1); git/curl "timed out" → network.
+    timeout: `check network connectivity; registry git children are killed after ${registry_git_1.REGISTRY_GIT_TIMEOUT_MS / 1000}s `
+        + 'without stdout/stderr activity',
+};
+/**
+ * Strip credential-bearing userinfo from a remote URL (or URL-shaped substring) before
+ * echoing it to operators. HTTPS `user:token@host` / `user@host` → scheme://host… only.
+ * Does not JSON-escape or clip — callers run `cleanText`/`clipMessage`/`esc` for echo safety.
+ */
+function redactRemoteForDisplay(remote) {
+    if (typeof remote !== 'string' || !remote)
+        return '';
+    // https://user:pass@host/... or https://user@host/...
+    return remote.replace(/\b([a-z][a-z0-9+.-]*:\/\/)([^/@\s]+)@/gi, '$1');
+}
+function errorText(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+/** Extract the last line that looks like git's `fatal: …` diagnostic. */
+function extractFatalLine(text) {
+    const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (/^fatal:/i.test(lines[i]))
+            return lines[i];
+    }
+    return null;
+}
+/**
+ * Map a registry git failure to a stable class + file-based remedy (SG-6).
+ * Heuristics are substring-based on message/stderr; never includes env values.
+ */
+function classifyRegistryGitError(err) {
+    const message = errorText(err);
+    const fatalLine = extractFatalLine(message);
+    let errorClass;
+    // Audit M1: only simple-git's idle-block plugin text is `timeout`. Git/curl
+    // "Connection timed out" / "timed out" are connectivity → `network`.
+    if (/block timeout reached/i.test(message)) {
+        errorClass = 'timeout';
+    }
+    else if (/ssl|tls|certificate|unable to get local issuer|certificate verify failed/i.test(message)) {
+        errorClass = 'tls';
+    }
+    else if (
+    // Score repository-shaped not-found BEFORE broad SSH wording — GitHub SSH
+    // often pairs "Repository not found" with "Could not read from remote repository".
+    /repository not found|remote:\s*.*not found|fatal:\s*repository .+ not found|404\b/i.test(message)) {
+        errorClass = 'not-found';
+    }
+    else if (/host key verification|permission denied \(publickey\)/i.test(message)) {
+        errorClass = 'ssh';
+    }
+    else if (
+    // Remaining SSH transport wording — but DNS/timeout under ssh: belongs to network.
+    /\bssh\b/i.test(message)
+        && !/could not resolve|name or service not known|timed?\s*out|connection timed out|terminal prompts disabled|authentication failed|could not read username/i.test(message)) {
+        errorClass = 'ssh';
+    }
+    else if (/terminal prompts disabled|authentication failed|could not read username|auth(entication)? (fail|required)|401\b|403\b|invalid credentials/i.test(message)) {
+        errorClass = 'authentication';
+    }
+    else if (/could not resolve host|could not resolve hostname|failed to connect|connection refused|network is unreachable|unable to connect|proxy|name or service not known|timed?\s*out|connection timed out/i.test(message)) {
+        errorClass = 'network';
+    }
+    else {
+        // Default: treat unknown transport failures as network.
+        errorClass = 'network';
+    }
+    const rawFatal = fatalLine ?? (message.trim() ? message.trim().split(/\r?\n/).pop().slice(0, 240) : null);
+    return {
+        class: errorClass,
+        fatalLine: rawFatal === null ? null : redactRemoteForDisplay(rawFatal),
+        remedy: REMEDIES[errorClass],
+    };
+}
+/**
+ * Operator-facing SG-6 line: registry name, remote when known, class, fatal, remedy.
+ * Never includes ambient env values or URL userinfo credentials.
+ */
+function formatClassifiedRegistryFailure(opts) {
+    const classified = classifyRegistryGitError(opts.err);
+    const remotePart = opts.remote
+        ? `; remote=${(0, text_safety_1.clipMessage)((0, text_safety_1.cleanText)(redactRemoteForDisplay(opts.remote)))}`
+        : '';
+    const fatalPart = classified.fatalLine
+        ? `; fatal: ${(0, text_safety_1.clipMessage)((0, text_safety_1.cleanText)(classified.fatalLine.replace(/^fatal:\s*/i, '')))}`
+        : '';
+    return (`registry ${(0, text_safety_1.esc)(opts.name)} sync failed (class=${classified.class}${remotePart}${fatalPart}); `
+        + `remedy: ${classified.remedy}`);
+}

package/dist/src/core/registry-git.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRY_GIT_TIMEOUT_MS = void 0;
+exports.buildRegistryGitEnv = buildRegistryGitEnv;
+exports.listIgnoredGuardedGitEnvNames = listIgnoredGuardedGitEnvNames;
+exports.formatIgnoredGitEnvNotice = formatIgnoredGitEnvNotice;
+exports.resetIgnoredGitEnvNoticeForTests = resetIgnoredGitEnvNoticeForTests;
+exports.warnIgnoredGitEnvOnce = warnIgnoredGitEnvOnce;
+exports.createRegistryGit = createRegistryGit;
+const simple_git_1 = require("simple-git");
+exports.REGISTRY_GIT_TIMEOUT_MS = 60_000;
+/**
+ * Non-`GIT_*` keys that simple-git 4 treats as guarded when supplied via `.env()`.
+ * Omit them from the copy so `.env(copy)` does not reject (editor/pager/visual family).
+ * Kept in sync with `@simple-git/argv-parser` GitEnvKeys non-prefix entries.
+ */
+const NON_PREFIX_GUARDED_ENV = new Set(['editor', 'pager', 'prefix', 'ssh_askpass', 'visual']);
+/**
+ * Ambient names that affect registry transport/auth and are stripped by the factory.
+ * SG-5 warns only for these (audit M2) — not GIT_EDITOR / GIT_PAGER / GIT_AUTHOR_*.
+ * Includes SSH_ASKPASS (audit B2), which simple-git also guards without a GIT_ prefix.
+ */
+function isTransportRelevantIgnoredEnv(key) {
+    const lower = key.toLowerCase();
+    if (lower === 'ssh_askpass')
+        return true;
+    if (!lower.startsWith('git_'))
+        return false;
+    if (lower === 'git_terminal_prompt')
+        return false;
+    return (lower.startsWith('git_ssl_')
+        || lower === 'git_askpass'
+        || lower.startsWith('git_ssh')
+        || lower.startsWith('git_proxy')
+        || lower.startsWith('git_http_')
+        || lower.startsWith('git_curl_')
+        || lower.startsWith('git_config'));
+}
+/** Copy parent env without guarded GIT_* / editor keys, then force non-interactive prompts. */
+function buildRegistryGitEnv(parent = process.env) {
+    const env = {};
+    for (const [key, value] of Object.entries(parent)) {
+        if (value === undefined)
+            continue;
+        const lower = key.toLowerCase();
+        if (lower.startsWith('git_'))
+            continue;
+        if (NON_PREFIX_GUARDED_ENV.has(lower))
+            continue;
+        env[key] = value;
+    }
+    env.GIT_TERMINAL_PROMPT = '0';
+    return env;
+}
+/** Names of stripped transport/auth vars worth warning about (SG-5) — never values. */
+function listIgnoredGuardedGitEnvNames(parent = process.env) {
+    return Object.keys(parent)
+        .filter((key) => isTransportRelevantIgnoredEnv(key))
+        .sort((a, b) => a.localeCompare(b));
+}
+/** Operator notice for SG-5 — names only, never values. */
+function formatIgnoredGitEnvNotice(names) {
+    const listed = names.join(', ');
+    return (`⚠ Ignoring ambient transport/auth env vars: ${listed}. `
+        + 'Use file-based git config instead '
+        + '(e.g. git config --global http.sslCAInfo <path>, credential.helper, core.sshCommand / ~/.ssh/config).');
+}
+let ignoredGitEnvWarned = false;
+/** Test seam: clear the once-per-process SG-5 flag. */
+function resetIgnoredGitEnvNoticeForTests() {
+    ignoredGitEnvWarned = false;
+}
+/**
+ * Before the first network registry git op: warn once listing ignored ambient
+ * transport/auth env names (except GIT_TERMINAL_PROMPT) and point at file-based remedies (SG-5).
+ */
+function warnIgnoredGitEnvOnce(log = (message) => console.warn(message), parent = process.env) {
+    if (ignoredGitEnvWarned)
+        return;
+    const names = listIgnoredGuardedGitEnvNames(parent);
+    if (names.length === 0)
+        return;
+    ignoredGitEnvWarned = true;
+    log(formatIgnoredGitEnvNotice(names));
+}
+function createRegistryGit(baseDir) {
+    const git = (0, simple_git_1.simpleGit)({
+        ...(baseDir !== undefined ? { baseDir } : {}),
+        allowEnvironment: ['GIT_TERMINAL_PROMPT'],
+        timeout: { block: exports.REGISTRY_GIT_TIMEOUT_MS },
+    });
+    return git.env(buildRegistryGitEnv());
+}

package/dist/src/core/registry-sync-report.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatClassifiedRegistryFailure = void 0;
+exports.formatRegistrySyncSoftFailure = formatRegistrySyncSoftFailure;
+exports.hardFailOnAnyRegistrySyncError = hardFailOnAnyRegistrySyncError;
+exports.formatSoftRegistrySyncFailures = formatSoftRegistrySyncFailures;
+exports.reportRegistrySyncSoftFailures = reportRegistrySyncSoftFailures;
+const registries_1 = require("./registries");
+const registry_git_errors_1 = require("./registry-git-errors");
+Object.defineProperty(exports, "formatClassifiedRegistryFailure", { enumerable: true, get: function () { return registry_git_errors_1.formatClassifiedRegistryFailure; } });
+const text_safety_1 = require("./changes/text-safety");
+const versioning_1 = require("./versioning");
+/**
+ * Soft path for `awm add` / `awm list` (SG-7): continue on usable cache only after
+ * stating the cached version plus the classified cause/remedy.
+ * Avoids duplicating "registry X … sync failed" (audit B3); escapes the name like SG-6.
+ */
+function formatRegistrySyncSoftFailure(input) {
+    const versionLabel = input.cachedVersion ? `v${input.cachedVersion}` : 'unknown';
+    return (`⚠ Continuing with cached version ${versionLabel} for registry ${(0, text_safety_1.esc)(input.name)}. `
+        + input.classifiedMessage);
+}
+/** True when any per-registry sync result is an error (SG-7 hard-fail gate). */
+function hardFailOnAnyRegistrySyncError(results) {
+    return results.some((r) => r.action === 'error');
+}
+/**
+ * Soft-failure lines for add/list: one per errored registry that still has usable
+ * on-disk content. Callers print these then continue (or hard-fail via
+ * assertSyncedRegistriesUsable when nothing usable remains).
+ */
+async function formatSoftRegistrySyncFailures(results, opts) {
+    const lines = [];
+    for (const r of results) {
+        if (r.action !== 'error')
+            continue;
+        if (!opts.isUsable(r.name))
+            continue;
+        lines.push(formatRegistrySyncSoftFailure({
+            name: r.name,
+            cachedVersion: await opts.cachedVersion(r.name),
+            classifiedMessage: r.error,
+        }));
+    }
+    return lines;
+}
+/**
+ * SG-7 soft path for `awm add` / `awm list`: warn with cached version + SG-6 text
+ * for each failed-but-usable registry; warn with the classified error for
+ * unusable ones (caller still runs assertSyncedRegistriesUsable for hard fail).
+ */
+async function reportRegistrySyncSoftFailures(results, log = (m) => console.warn(m)) {
+    const roots = new Map((0, registries_1.listRegistries)().map((r) => [r.name, r.contentRoot]));
+    const soft = await formatSoftRegistrySyncFailures(results, {
+        isUsable: (name) => {
+            const root = roots.get(name);
+            return root !== undefined && (0, registries_1.validateRegistryLayout)(root);
+        },
+        cachedVersion: async (name) => {
+            const root = roots.get(name);
+            return root ? (0, versioning_1.currentVersion)(root) : null;
+        },
+    });
+    for (const line of soft)
+        log(line);
+    for (const r of results) {
+        if (r.action !== 'error')
+            continue;
+        const root = roots.get(r.name);
+        if (root !== undefined && (0, registries_1.validateRegistryLayout)(root))
+            continue;
+        log(`  ⚠  registry ${r.name}: ${r.error}`);
+    }
+}