loadout-ai 0.9.0 → 0.9.2

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

@@ -260,7 +260,7 @@ export function formatPreparedCatalogInstall(prepared, options = {}) {
     if (directoriesPerAgent > DEFAULT_ACTIVE_SKILL_LIMIT)
         lines.push(`Capacity notice: about ${directoriesPerAgent} skill directories per agent exceeds Stable's ${DEFAULT_ACTIVE_SKILL_LIMIT}-skill bound.${prepared.selection.mode === "maximum" ? " Maximum stores them in the disabled library; optimize or activate a project-relevant working set." : prepared.selection.mode === "power" ? " Power is the explicit larger active mode; choose Stable or project optimization when lower context use matters." : " Use project-aware activation for a smaller working set."}`);
     if (failures.length)
-        lines.push(`Preparation failures (installation will remain blocked): ${failures.map((item) => item.packageId).join(", ")}`);
+        lines.push(`Preparation failures (${prepared.selection.mode === "maximum" ? "will be skipped; remaining library can install" : "installation will remain blocked"}): ${failures.map((item) => item.packageId).join(", ")}`);
     if (quarantined.length)
         lines.push(`Quarantined invalid skill units: ${quarantined.length} (safe siblings remain available)`);
     if (explicit.length)
@@ -292,8 +292,14 @@ export async function applyPreparedCatalogInstall(prepared, options = {}) {
     if (!prepared.entries.length)
         throw new Error("No reviewed skill packages could be prepared for installation");
     const failures = prepared.skipped.filter((item) => item.kind === "preparation-failed");
-    if (failures.length)
+    if (failures.length && prepared.selection.mode !== "maximum") {
         throw new Error(`Setup is incomplete because reviewed packages failed to prepare: ${failures.map((item) => item.packageId).join(", ")}. Retry when GitHub is reachable; no partial loadout was installed.`);
+    }
+    if (failures.length) {
+        for (const fail of failures) {
+            console.error(`Warning: skipping ${fail.packageId} (preparation failed). The remaining library will install without it.`);
+        }
+    }
     const risky = prepared.entries.filter((entry) => entry.safety.approvalRequired);
     if (risky.length && !options.approveRisk)
         throw new Error(`Additional risk approval is required for: ${risky.map((entry) => entry.package.id).join(", ")}. Review the plan, then use --approve-risk.`);

package/dist/src/core/install/snapshot.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { readFile, writeFile, mkdir, readdir, rename, rm, lstat, } from "node:fs/promises";
+import { readFile, writeFile, mkdir, readdir, rename, rm, lstat, chmod, } from "node:fs/promises";
 import { dirname, join, resolve, sep } from "node:path";
 import { loadoutHome, ensureDirectory, userHome } from "../agents/paths.js";
 export async function createSnapshot(paths, options = {}) {
@@ -36,12 +36,18 @@ export async function createSnapshot(paths, options = {}) {
                 existed: true,
                 content: (await readFile(path)).toString("base64"),
                 encoding: "base64",
+                mode: info.mode & 0o777,
             });
             return;
         }
         if (!info.isDirectory())
             throw new Error(`Refusing unsupported snapshot target: ${path}`);
-        snapshot.files.push({ path, existed: true, directory: true });
+        snapshot.files.push({
+            path,
+            existed: true,
+            directory: true,
+            mode: info.mode & 0o777,
+        });
         const entries = (await readdir(path, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
         for (const entry of entries) {
             const child = join(path, entry.name);
@@ -49,13 +55,16 @@ export async function createSnapshot(paths, options = {}) {
                 throw new Error(`Refusing to snapshot symlink: ${child}`);
             if (entry.isDirectory())
                 await capture(child);
-            else if (entry.isFile())
+            else if (entry.isFile()) {
+                const childInfo = await lstat(child);
                 snapshot.files.push({
                     path: child,
                     existed: true,
                     content: (await readFile(child)).toString("base64"),
                     encoding: "base64",
+                    mode: childInfo.mode & 0o777,
                 });
+            }
             else
                 throw new Error(`Refusing unsupported snapshot target: ${child}`);
         }
@@ -74,12 +83,15 @@ export async function restoreSnapshot(snapshot, options = {}) {
     validateSnapshot(snapshot);
     if (options.requireUnchangedPostMutationState)
         await assertUnchangedPostMutationState(snapshot);
-    for (const root of snapshot.roots)
+    for (const root of snapshot.roots) {
+        await makeTreeRemovable(root);
         await rm(root, { recursive: true, force: true });
+    }
     for (const directory of snapshot.files
         .filter((file) => file.existed && file.directory)
-        .sort((a, b) => a.path.length - b.path.length))
+        .sort((a, b) => a.path.length - b.path.length)) {
         await mkdir(directory.path, { recursive: true });
+    }
     for (const file of snapshot.files) {
         if (!file.existed || file.directory)
             continue;
@@ -87,6 +99,32 @@ export async function restoreSnapshot(snapshot, options = {}) {
         await writeFile(file.path, file.encoding === "base64"
             ? Buffer.from(file.content ?? "", "base64")
             : (file.content ?? ""));
+        if (file.mode !== undefined)
+            await chmod(file.path, file.mode);
+    }
+    for (const directory of snapshot.files
+        .filter((file) => file.existed && file.directory)
+        .sort((a, b) => b.path.length - a.path.length)) {
+        if (directory.mode !== undefined)
+            await chmod(directory.path, directory.mode);
+    }
+}
+async function makeTreeRemovable(path) {
+    let info;
+    try {
+        info = await lstat(path);
+    }
+    catch (error) {
+        if (isFileError(error, "ENOENT"))
+            return;
+        throw error;
+    }
+    if (!info.isDirectory() || info.isSymbolicLink())
+        return;
+    await chmod(path, (info.mode & 0o777) | 0o700);
+    for (const entry of await readdir(path, { withFileTypes: true })) {
+        if (entry.isDirectory() && !entry.isSymbolicLink())
+            await makeTreeRemovable(join(path, entry.name));
     }
 }
 /** Attach the committed state used to make later user-requested rollback safe. */
@@ -240,7 +278,12 @@ function validateSnapshotFiles(files, roots, label) {
             typeof file.existed !== "boolean" ||
             (file.directory !== undefined && typeof file.directory !== "boolean") ||
             (file.content !== undefined && typeof file.content !== "string") ||
-            (file.encoding !== undefined && file.encoding !== "base64"))
+            (file.encoding !== undefined && file.encoding !== "base64") ||
+            (file.mode !== undefined &&
+                (typeof file.mode !== "number" ||
+                    !Number.isInteger(file.mode) ||
+                    file.mode < 0 ||
+                    file.mode > 0o777)))
             throw new Error(`${label} file ${index} is invalid`);
         const filePath = file.path;
         if (resolve(filePath) !== filePath)

package/dist/src/core/install/source.js

@@ -17,7 +17,7 @@ export const REPOSITORY_FETCH_DEFAULTS = {
     maxBytes: 256 * 1024 * 1024,
     maxFiles: 20_000,
 };
-function withFetchDefaults(options) {
+export function withFetchDefaults(options) {
     return {
         ...options,
         timeoutMs: options.timeoutMs ?? REPOSITORY_FETCH_DEFAULTS.timeoutMs,
@@ -320,24 +320,26 @@ export async function fetchGitSnapshot(input, options = {}) {
     // checked before fetching the way the GitHub path does. Enforce a bound
     // AFTER a shallow clone instead of refusing bounded requests, giving parity
     // with the catalog path and a default ceiling against an adversarial repo.
-    const boundedOptions = {
+    const boundedOptions = withFetchDefaults({
         ...options,
         maxBytes: options.maxBytes ?? 128 * 1024 * 1024,
         maxFiles: options.maxFiles ?? 20_000,
-    };
+    });
     const url = normalizeGitUrl(input);
     const temporary = await mkdtemp(join(tmpdir(), "loadout-git-"));
     try {
         const gitEnvironment = await isolatedGitEnvironment(loadoutHome());
-        const refArgs = options.ref ? ["--branch", normalizeRef(options.ref)] : [];
+        const refArgs = boundedOptions.ref
+            ? ["--branch", normalizeRef(boundedOptions.ref)]
+            : [];
         await execFileAsync("git", ["clone", "--depth", "1", ...refArgs, "--", url, temporary], {
             maxBuffer: 10 * 1024 * 1024,
-            timeout: options.timeoutMs,
+            timeout: boundedOptions.timeoutMs,
             env: {
                 ...gitEnvironment,
             },
         });
-        const { stdout } = await execFileAsync("git", ["-C", temporary, "rev-parse", "HEAD"], { timeout: options.timeoutMs, env: gitEnvironment });
+        const { stdout } = await execFileAsync("git", ["-C", temporary, "rev-parse", "HEAD"], { timeout: boundedOptions.timeoutMs, env: gitEnvironment });
         const commit = stdout.trim();
         if (!/^[0-9a-f]{40}$/i.test(commit))
             throw new Error("Git returned an invalid commit");

package/dist/src/core/install/update.js

@@ -8,6 +8,7 @@ import { analyzeUpdateSafety } from "../catalog/safety.js";
 import { detectAgents, loadoutHome } from "../agents/paths.js";
 import { applySkillInstall, buildSkillPlan, installedAgents, } from "./install.js";
 import { discoverSkillDirectories, validateSkillDirectory, } from "../catalog/skills.js";
+import { loadEffectiveCatalog } from "../catalog/catalog.js";
 function managedUnitIds(state, packageId) {
     return [
         ...new Set((state.activations ?? [])
@@ -84,6 +85,22 @@ async function analyzeManagedUpdate(oldRoot, newRoot, unitIds) {
         approvalRequired: safetyFindings.some((finding) => finding.severity === "blocking"),
     };
 }
+/**
+ * Index catalog-pinned commits by repository for O(1) lookup during update.
+ * A commit matches if the catalog's source evidence references the same SHA.
+ */
+function buildCatalogCommitIndex(catalog) {
+    const index = new Map();
+    for (const pkg of catalog) {
+        if (pkg.source?.commit && pkg.repository) {
+            const repository = pkg.repository.toLowerCase();
+            const commits = index.get(repository) ?? new Set();
+            commits.add(pkg.source.commit.toLowerCase());
+            index.set(repository, commits);
+        }
+    }
+    return index;
+}
 /** Builds a read-only update plan from persisted installs and live GitHub snapshots. */
 export async function buildUpdatePlan(resolver, options = {}) {
     const state = await readInstallState();
@@ -91,6 +108,18 @@ export async function buildUpdatePlan(resolver, options = {}) {
         ? state.installs.filter((record) => record.packageId === options.packageId)
         : state.installs;
     const results = new Array(records.length);
+    // Load catalog commit pins so we can flag updates that diverge from
+    // the last reviewed snapshot. This is a read-only safety check — it
+    // does not prevent the update, but adds a blocking safety finding
+    // when the upstream HEAD has moved past the catalog-pinned commit.
+    let catalogIndex;
+    try {
+        const catalog = options.catalog ?? (await loadEffectiveCatalog());
+        catalogIndex = buildCatalogCommitIndex(catalog);
+    }
+    catch {
+        catalogIndex = new Map();
+    }
     const lightweightResolver = resolver ??
         options.resolveHead ??
         ((repository) => resolveRepositoryHead(repository, { timeoutMs: 30_000 }));
@@ -164,12 +193,36 @@ export async function buildUpdatePlan(resolver, options = {}) {
                             throw new Error(`Resolved ${current.commit}, but fetched ${fetched.commit} for safety review`);
                         currentPath = fetched.path;
                     }
+                    // Check whether the upstream HEAD matches the catalog-pinned
+                    // commit. A mismatch means the repository has changed since the
+                    // catalog was last reviewed — the content may be fine, but it
+                    // hasn't been vetted, so flag it for human review.
+                    let catalogDrift = false;
+                    if (!same && record.repository) {
+                        const pinnedCommits = catalogIndex.get(record.repository.toLowerCase());
+                        if (pinnedCommits &&
+                            !pinnedCommits.has(current.commit.toLowerCase())) {
+                            catalogDrift = true;
+                        }
+                    }
                     if (!same && currentPath) {
                         const oldPath = repositoryCachePath(record.repository, record.resolvedCommit);
                         const analysis = await analyzeManagedUpdate(oldPath, currentPath, managedUnitIds(state, record.packageId));
                         diff = analysis.diff;
-                        safetyFindings = analysis.safetyFindings;
+                        safetyFindings = analysis.safetyFindings ?? [];
                         approvalRequired = analysis.approvalRequired;
+                        if (catalogDrift) {
+                            safetyFindings.push({
+                                severity: "blocking",
+                                category: "instruction",
+                                message: "Upstream HEAD has moved past the catalog-reviewed commit. " +
+                                    "The new content has not been verified by the catalog maintainer. " +
+                                    "Review the diff carefully before approving.",
+                                paths: [],
+                                names: ["catalog-drift"],
+                            });
+                            approvalRequired = true;
+                        }
                     }
                     return {
                         ...base,
@@ -185,6 +238,7 @@ export async function buildUpdatePlan(resolver, options = {}) {
                         ...(approvalRequired ? { approvalRequired: true } : {}),
                         ...(safetyFindings?.length ? { safetyFindings } : {}),
                         ...(diff ? { diff } : {}),
+                        ...(catalogDrift ? { catalogDrift: true } : {}),
                     };
                 }
                 catch (error) {