@oomerevren/tryforge 0.1.2 → 0.1.3

package/dist/cli/src/commands/add-external.js

@@ -0,0 +1,111 @@
+// cli/src/commands/add-external.ts — Install from decentralized sources (Phase 3).
+//
+// Handles github:/git-URL/local-path packages: resolve → stage → security
+// gate → copy into the forge store → install to adapters → record links.
+// Fail-closed: HIGH scan findings refuse the install (exit 1) unless the
+// package comes from the verified registry path (which only warns).
+import { resolveExternalSource, } from "../core/sources.js";
+import { copyDirRecursive } from "../core/fsutil.js";
+import { ensureForgeDirs, readLinks, writeLinks, packageDir, toSlug, } from "../core/store.js";
+import { detectAdapters } from "../adapters/index.js";
+import { scanPackageDir } from "../core/scan.js";
+import { findProjectToml, loadProjectToml } from "../core/project.js";
+/**
+ * Copy staged external content into the forge store (adapters symlink the
+ * store, never tmp). Returns the store dir. Always cleans the stage dir.
+ */
+export function storeExternal(staged) {
+    const dest = packageDir(toSlug(staged.name), staged.version);
+    try {
+        ensureForgeDirs();
+        // NOTE: raw fs.cpSync silently yields empty dirs under non-ASCII
+        // Windows home paths — always use copyDirRecursive (see fsutil.ts).
+        copyDirRecursive(staged.dir, dest);
+        return dest;
+    }
+    finally {
+        staged.cleanup();
+    }
+}
+export async function installExternal(spec, opts = {}) {
+    console.log(`[forge] resolving external source ${spec.source}...`);
+    let staged;
+    try {
+        staged = resolveExternalSource(spec);
+    }
+    catch (e) {
+        console.error(e.message);
+        process.exitCode = 1;
+        return;
+    }
+    const slug = toSlug(staged.name);
+    console.log(`[forge] found ${staged.name}@${staged.version} [${staged.type}] — ${staged.description}`);
+    console.log(`[forge] source: ${staged.source} (external — no registry pin)`);
+    if (opts.dryRun) {
+        console.log(`[forge] (dry-run) would install to ~/.forge/packages/${slug}@${staged.version}/`);
+        staged.cleanup();
+        return;
+    }
+    // Security gate: HIGH findings refuse external installs (fail-closed).
+    if (!opts.skipScan) {
+        let permissions;
+        try {
+            const tomlPath = findProjectToml(process.cwd());
+            if (tomlPath)
+                permissions = loadProjectToml(tomlPath).permissions;
+        }
+        catch { /* project parse is best-effort; scan still runs */ }
+        const findings = scanPackageDir(staged.dir, { permissions });
+        const highs = findings.filter((f) => f.severity === "high");
+        const mediums = findings.filter((f) => f.severity === "medium");
+        for (const f of mediums.slice(0, 10)) {
+            console.warn(`[forge] scan warn [${f.rule}] ${f.file}${f.line > 0 ? `:${f.line}` : ""} — ${f.message}`);
+        }
+        if (highs.length > 0) {
+            console.error(`[forge] ✗ security scan FAILED for ${staged.name}: ${highs.length} high-severity finding(s)`);
+            for (const f of highs.slice(0, 10)) {
+                console.error(`[forge]   [high] [${f.rule}] ${f.file}${f.line > 0 ? `:${f.line}` : ""} — ${f.message}`);
+            }
+            console.error(`[forge] Refusing to install. Re-run with --skip-scan only if you trust this source.`);
+            staged.cleanup();
+            process.exitCode = 1;
+            return;
+        }
+        console.log(`[forge] scan clean (${findings.length} finding(s), 0 high)`);
+    }
+    // Copy staged content into the store (adapters symlink the store, never tmp).
+    const dest = storeExternal(staged);
+    console.log(`[forge] package content ready: ${dest}`);
+    const adapters = detectAdapters();
+    console.log(`[forge] detected harnesses: ${adapters.map((a) => `${a.displayName} (${a.name})`).join(", ")}`);
+    let failed = 0;
+    for (const adapter of adapters) {
+        try {
+            await adapter.install(slug, dest, staged.type, { version: staged.version, description: staged.description });
+            console.log(`  ✓ ${adapter.displayName} → ${adapter.skillDir(slug)}`);
+        }
+        catch (e) {
+            console.warn(`  ✗ ${adapter.displayName} failed: ${e.message}`);
+            failed++;
+        }
+    }
+    if (failed > 0) {
+        console.log(`\n[forge] ✗ ${failed} harness(es) failed — installed on ${adapters.length - failed}/${adapters.length}`);
+        process.exitCode = 1;
+    }
+    else {
+        console.log(`\n[forge] ✓ installed ${staged.name}@${staged.version} on ${adapters.length} harness(es)`);
+    }
+    ensureForgeDirs();
+    const links = readLinks();
+    links[staged.name] = {
+        pkg: staged.name,
+        version: staged.version,
+        slug,
+        type: staged.type,
+        adapters: adapters.map((a) => a.name),
+        installedAt: new Date().toISOString(),
+        source: staged.source,
+    };
+    writeLinks(links);
+}

package/dist/cli/src/commands/audit.js

@@ -1,53 +1,85 @@
-// cli/src/commands/audit.ts — trust-tier audit (verified vs community vs mock).
-// Full vulnerability DB in Faz 22; tier flags are accurate as of the verified-core sprint.
+// cli/src/commands/audit.ts — trust-tier audit + static security scan (Phase 3).
+//
+// Two layers:
+//   1. Trust tier per installed package (verified vs community vs mock).
+//   2. Static scan of on-disk package content (shell-danger, prompt-inject,
+//      perm-violation — see core/scan.ts).
+// Any HIGH-severity scan finding fails the audit (exit 1, fail-closed).
 import { existsSync } from "fs";
 import { join } from "path";
 import { readLinks, packageDir } from "../core/store.js";
 import { loadPackageDetail } from "../core/registry.js";
 import { isPlaceholderSha } from "../core/installer.js";
+import { scanPackageDir } from "../core/scan.js";
+import { findProjectToml, loadProjectToml } from "../core/project.js";
 export async function runAudit(opts = {}) {
-    const links = readLinks();
-    const entries = Object.values(links);
+    // opts.dirs overrides the links store (tests + `forge audit <path>` flows).
+    const entries = opts.dirs
+        ? Object.entries(opts.dirs).map(([pkg, dir]) => ({ pkg, dir, version: "scan", slug: pkg }))
+        : Object.values(readLinks()).map((rec) => ({ pkg: rec.pkg, dir: packageDir(rec.slug, rec.version), version: rec.version, slug: rec.slug }));
     const findings = [];
     if (entries.length === 0) {
         console.log("[forge] audit: no installed packages — nothing to check");
-        console.log("[forge] audit: full vulnerability DB in Faz 22");
         return;
     }
+    // Project permission boundaries apply to content checks when present.
+    let permissions;
+    try {
+        const tomlPath = findProjectToml(process.cwd());
+        if (tomlPath)
+            permissions = loadProjectToml(tomlPath).permissions;
+    }
+    catch { /* project parse is best-effort here; tier checks still run */ }
     for (const rec of entries) {
-        try {
-            const detail = await loadPackageDetail(rec.pkg);
-            const meta = detail.versions[rec.version];
-            if (!meta) {
-                findings.push({ pkg: rec.pkg, level: "warn", message: `version ${rec.version} not in registry` });
-                continue;
-            }
-            if (meta.sha256 && isPlaceholderSha(meta.sha256)) {
-                findings.push({ pkg: rec.pkg, level: 'info', message: 'community tier (unverified tarball) — install needs --mock' });
-            }
-            else if (!meta.verified) {
-                findings.push({ pkg: rec.pkg, level: 'warn', message: 'sha256 not verified against tarball content' });
-            }
-            if (!meta.tarball || meta.tarball.includes("placeholder")) {
-                findings.push({ pkg: rec.pkg, level: "warn", message: `tarball URL placeholder` });
-            }
-            // On-disk truth: .forge-mock marker means this install is mock content (--mock).
+        if (!opts.dirs) {
             try {
-                if (existsSync(join(packageDir(rec.slug, rec.version), ".forge-mock"))) {
-                    findings.push({ pkg: rec.pkg, level: "info", message: `installed from MOCK content (--mock was used)` });
+                const detail = await loadPackageDetail(rec.pkg);
+                const meta = detail.versions[rec.version];
+                if (!meta) {
+                    findings.push({ pkg: rec.pkg, level: "warn", message: `version ${rec.version} not in registry` });
+                    continue;
+                }
+                if (meta.sha256 && isPlaceholderSha(meta.sha256)) {
+                    findings.push({ pkg: rec.pkg, level: "info", message: "community tier (unverified tarball) — install needs --mock" });
+                }
+                else if (!meta.verified) {
+                    findings.push({ pkg: rec.pkg, level: "warn", message: "sha256 not verified against tarball content" });
                 }
+                if (!meta.tarball || meta.tarball.includes("placeholder")) {
+                    findings.push({ pkg: rec.pkg, level: "warn", message: `tarball URL placeholder` });
+                }
+                // On-disk truth: .forge-mock marker means this install is mock content (--mock).
+                try {
+                    if (existsSync(join(packageDir(rec.slug, rec.version), ".forge-mock"))) {
+                        findings.push({ pkg: rec.pkg, level: "info", message: `installed from MOCK content (--mock was used)` });
+                    }
+                }
+                catch { /* marker check is best-effort; unreadable dir simply means "not mock" */ }
+            }
+            catch (e) {
+                findings.push({ pkg: rec.pkg, level: "warn", message: `registry read failed: ${e.message}` });
             }
-            catch { }
         }
-        catch (e) {
-            findings.push({ pkg: rec.pkg, level: "warn", message: `registry read failed: ${e.message}` });
+        // Static scan of on-disk content (always runs when the dir exists).
+        if (existsSync(rec.dir)) {
+            const scan = scanPackageDir(rec.dir, { permissions });
+            for (const f of scan) {
+                findings.push({
+                    pkg: rec.pkg,
+                    level: f.severity === "high" ? "high" : f.severity === "medium" ? "warn" : "info",
+                    message: `[${f.rule}] ${f.file}${f.line > 0 ? `:${f.line}` : ""} — ${f.message}`,
+                });
+            }
         }
     }
+    const highs = findings.filter((f) => f.level === "high").length;
     if (opts.json) {
-        console.log(JSON.stringify({ packages: entries.length, findings }, null, 2));
+        console.log(JSON.stringify({ packages: entries.length, findings, highs }, null, 2));
+        if (highs > 0)
+            process.exitCode = 1;
         return;
     }
-    console.log(`[forge] audit — ${entries.length} package(s) checked (skeleton, full DB Faz 22):\n`);
+    console.log(`[forge] audit — ${entries.length} package(s) checked:\n`);
     if (findings.length === 0) {
         console.log("[forge] ✓ no issues");
     }
@@ -58,5 +90,11 @@ export async function runAudit(opts = {}) {
         if (findings.length > 30)
             console.log(`  ... and ${findings.length - 30} more`);
     }
-    console.log(`\n[forge] audit done: ${findings.length} finding(s)`);
+    if (highs > 0) {
+        console.log(`\n[forge] ✗ audit FAILED: ${highs} high-severity finding(s) — refusing to pass`);
+        process.exitCode = 1;
+    }
+    else {
+        console.log(`\n[forge] audit done: ${findings.length} finding(s)`);
+    }
 }

package/dist/cli/src/commands/init.js

@@ -82,11 +82,11 @@ export async function runInit(opts) {
         if (!existsSync(full) || opts.force)
             writeFileSync(full, content);
     }
-    const relDir = targetDir === cwd ? "." : opts.name;
+    const relDir = targetDir === cwd ? "." : (opts.name ?? rawName);
     console.log(`[forge] ✓ created ${relDir}/forge.toml [${type}]`);
     if (Object.keys(extras).length)
         console.log(`[forge]   + ${Object.keys(extras).join(", ")}`);
-    console.log(`[forge] next: edit forge.toml & SKILL.md, then 'forge publish' (Faz 8)`);
+    console.log(`[forge] next: edit forge.toml & SKILL.md, then 'forge publish' (Phase 8)`);
 }
 function normalizeName(input) {
     // allow my-skill -> my-skill/my-skill ? We expect scope/name

package/dist/cli/src/commands/install.js

@@ -6,8 +6,12 @@ import { ensurePackageContent } from "../core/installer.js";
 import { ensureForgeDirs, readLinks, writeLinks, toSlug } from "../core/store.js";
 import { allAdapters, detectAdapters, addMcpServerToConfig } from "../adapters/index.js";
 import { findProjectToml, loadProjectToml, validateProjectToml } from "../core/project.js";
-import { readLock, writeLock } from "../core/lock.js";
+import { readLock, writeLock, verifyLockIntegrity, lockEntryFor } from "../core/lock.js";
 import { loadConfig } from "../core/config.js";
+import { scanPackageDir } from "../core/scan.js";
+import { parseSourceArg, resolveExternalSource } from "../core/sources.js";
+import { storeExternal } from "./add-external.js";
+import { injectMcpServers } from "./sync.js";
 function pickAdapters(projectHarnesses) {
     if (projectHarnesses && projectHarnesses.length > 0) {
         const filtered = allAdapters.filter((a) => projectHarnesses.includes(a.name));
@@ -41,14 +45,15 @@ export async function runInstall(opts = {}) {
         console.error(`[forge] ${e.message}`);
         process.exit(1);
     }
-    const errs = validateProjectToml(project, tomlPath);
+    const errs = validateProjectToml(project);
     if (errs.length > 0) {
         for (const er of errs)
             console.error(`[forge] ${er}`);
         process.exit(1);
     }
     const deps = project.dependencies;
-    if (Object.keys(deps).length === 0) {
+    const hasSkills = Object.keys(project.skills ?? {}).length > 0;
+    if (Object.keys(deps).length === 0 && !hasSkills) {
         console.log(`[forge] no dependencies in ${tomlPath}`);
         return;
     }
@@ -75,6 +80,13 @@ export async function runInstall(opts = {}) {
             }
         }
         console.log(`[forge] installing ${lock.packages.length} package(s) from forge.lock (frozen)...`);
+        // Security barrier: yanked versions and hash drift refuse the install.
+        const integrityIssues = await verifyLockIntegrity(lock, { allowMock: opts.mock });
+        if (integrityIssues.length > 0) {
+            for (const issue of integrityIssues)
+                console.error(`[forge] ✗ ${issue.message}`);
+            process.exit(1);
+        }
         const adapters = pickAdapters(project.forge?.harnesses);
         console.log(`[forge] harnesses: ${adapters.map((a) => a.displayName).join(", ")}`);
         const t0 = Date.now();
@@ -84,7 +96,10 @@ export async function runInstall(opts = {}) {
                 const { detail, version, versionMeta } = await resolveVersion(entry.name, entry.version);
                 const src = await ensurePackageContent(entry.name, version, detail, versionMeta, { allowMock: opts.mock });
                 for (const adapter of adapters) {
-                    await adapter.install(toSlug(entry.name), src, detail.type);
+                    await adapter.install(toSlug(entry.name), src, detail.type, {
+                        version,
+                        description: detail.description,
+                    });
                     if (detail.type === "mcp" && versionMeta.mcp) {
                         const cfgPath = adapter.mcpConfigPath();
                         if (cfgPath)
@@ -113,17 +128,71 @@ export async function runInstall(opts = {}) {
         console.log(`\n[forge] ✓ installed ${ok}/${lock.packages.length} from lock in ${dt}s`);
         return;
     }
-    // Normal: resolve from dependencies
-    console.log(`[forge] installing ${Object.keys(deps).length} package(s) from ${tomlPath}...`);
+    // Normal: resolve from dependencies (+ [skills] from the universal manifest)
+    const skillEntries = Object.entries(project.skills ?? {});
+    const totalWork = Object.keys(deps).length + skillEntries.length;
+    console.log(`[forge] installing ${totalWork} package(s) from ${tomlPath}...`);
     const adapters = pickAdapters(project.forge?.harnesses);
     console.log(`[forge] harnesses: ${adapters.map((a) => a.displayName).join(", ")}`);
     const t0 = Date.now();
     const lockEntries = [];
     let ok = 0;
     let skipped = 0;
+    // External [skills] (github:/URL/local) resolve outside the registry loop.
+    for (const [skillName, ref] of skillEntries) {
+        const source = ref.source ?? "registry";
+        if (source === "registry")
+            continue; // handled in the registry loop below
+        try {
+            const spec = parseSourceArg(ref.ref ? `${source}#${ref.ref}` : source);
+            const staged = resolveExternalSource(spec);
+            try {
+                const highs = scanPackageDir(staged.dir).filter((f) => f.severity === "high");
+                if (highs.length > 0) {
+                    throw new Error(`security scan FAILED (${highs.length} high): ${highs[0].rule} ${highs[0].file} — refusing install`);
+                }
+                const srcDir = storeExternal(staged);
+                for (const adapter of adapters) {
+                    await adapter.install(toSlug(skillName), srcDir, staged.type, { version: staged.version, description: staged.description });
+                }
+                ensureForgeDirs();
+                const links = readLinks();
+                links[skillName] = {
+                    pkg: skillName,
+                    version: staged.version,
+                    slug: toSlug(skillName),
+                    type: staged.type,
+                    adapters: adapters.map((a) => a.name),
+                    installedAt: new Date().toISOString(),
+                    source: staged.source,
+                };
+                writeLinks(links);
+                lockEntries.push(lockEntryFor(skillName, staged.version, staged.type, {}, staged.source));
+                ok++;
+                console.log(`  ✓ ${skillName}@${staged.version} (from ${staged.source})`);
+            }
+            catch (e) {
+                try {
+                    staged.cleanup();
+                }
+                catch { /* best-effort */ }
+                throw e;
+            }
+        }
+        catch (e) {
+            console.error(`  ✗ ${skillName} failed: ${e.message}`);
+        }
+    }
+    // Registry skills without explicit source join the semver loop.
+    const mergedDeps = { ...deps };
+    for (const [skillName, ref] of skillEntries) {
+        if ((ref.source ?? "registry") === "registry" && ref.version && mergedDeps[skillName] === undefined) {
+            mergedDeps[skillName] = ref.version;
+        }
+    }
     // Check existing links to skip already-installed exact version? We reinstall if range resolves same version already installed? For idempotency allow skip? We'll still ensure content but count skipped.
     const existingLinks = readLinks();
-    for (const [depName, depRange] of Object.entries(deps)) {
+    for (const [depName, depRange] of Object.entries(mergedDeps)) {
         try {
             const { detail, version, versionMeta } = await resolveVersion(depName, depRange);
             const already = existingLinks[depName];
@@ -132,7 +201,7 @@ export async function runInstall(opts = {}) {
                 // verify adapters still have it? For speed skip re-install? But ensure adapters have it
                 // For mcp packages isInstalled checks skillDir which is not created — treat store existence as enough
                 if (detail.type === "mcp") {
-                    lockEntries.push({ name: depName, version, type: detail.type });
+                    lockEntries.push(lockEntryFor(depName, version, detail.type, versionMeta));
                     skipped++;
                     console.log(`  = ${depName}@${version} already installed`);
                     continue;
@@ -144,7 +213,7 @@ export async function runInstall(opts = {}) {
                         allPresent = false;
                 }
                 if (allPresent) {
-                    lockEntries.push({ name: depName, version, type: detail.type });
+                    lockEntries.push(lockEntryFor(depName, version, detail.type, versionMeta));
                     skipped++;
                     console.log(`  = ${depName}@${version} already installed`);
                     continue;
@@ -152,7 +221,7 @@ export async function runInstall(opts = {}) {
             }
             const src = await ensurePackageContent(depName, version, detail, versionMeta, { allowMock: opts.mock });
             for (const adapter of adapters) {
-                await adapter.install(toSlug(depName), src, detail.type);
+                await adapter.install(toSlug(depName), src, detail.type, { version, description: detail.description });
                 if (detail.type === "mcp" && versionMeta.mcp) {
                     const cfgPath = adapter.mcpConfigPath();
                     if (cfgPath)
@@ -166,7 +235,7 @@ export async function runInstall(opts = {}) {
                     const sub = await resolveVersion(subName, subRange);
                     const subSrc = await ensurePackageContent(subName, sub.version, sub.detail, sub.versionMeta, { allowMock: opts.mock });
                     for (const adapter of adapters)
-                        await adapter.install(toSlug(subName), subSrc, sub.detail.type);
+                        await adapter.install(toSlug(subName), subSrc, sub.detail.type, { version: sub.version, description: sub.detail.description });
                     console.log(`    dep ${subName}@${sub.version}`);
                 }
                 catch (e) {
@@ -184,7 +253,7 @@ export async function runInstall(opts = {}) {
                 installedAt: new Date().toISOString(),
             };
             writeLinks(links);
-            lockEntries.push({ name: depName, version, type: detail.type });
+            lockEntries.push(lockEntryFor(depName, version, detail.type, versionMeta));
             ok++;
             console.log(`  ✓ ${depName}@${version}`);
         }
@@ -195,15 +264,21 @@ export async function runInstall(opts = {}) {
     // Write lock (deterministic order)
     lockEntries.sort((a, b) => a.name.localeCompare(b.name));
     writeLock(lockEntries, cwd);
+    // Project MCP servers → every adapter config.
+    const mcpServers = project.mcp?.servers ?? {};
+    if (Object.keys(mcpServers).length > 0) {
+        const writes = injectMcpServers(adapters, mcpServers);
+        console.log(`[forge] ✓ ${Object.keys(mcpServers).length} MCP server(s) injected (${writes} config writes)`);
+    }
     const dt = ((Date.now() - t0) / 1000).toFixed(1);
     const total = ok + skipped;
-    const failed = Object.keys(deps).length - total;
+    const failed = totalWork - total;
     if (failed > 0) {
-        console.log(`\n[forge] ✗ ${failed} package(s) failed — installed ${ok} new, ${skipped} cached (${total}/${Object.keys(deps).length}) on ${adapters.length} harness(es) in ${dt}s`);
+        console.log(`\n[forge] ✗ ${failed} package(s) failed — installed ${ok} new, ${skipped} cached (${total}/${totalWork}) on ${adapters.length} harness(es) in ${dt}s`);
         process.exitCode = 1;
     }
     else {
-        console.log(`\n[forge] ✓ installed ${ok} new, ${skipped} cached (${total}/${Object.keys(deps).length}) on ${adapters.length} harness(es) in ${dt}s`);
+        console.log(`\n[forge] ✓ installed ${ok} new, ${skipped} cached (${total}/${totalWork}) on ${adapters.length} harness(es) in ${dt}s`);
     }
     console.log(`[forge] lock written to ${cwd}/forge.lock`);
 }

package/dist/cli/src/commands/pack.js

@@ -0,0 +1,119 @@
+// cli/src/commands/pack.ts — Package the current directory into a verified tarball.
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
+import { join } from "path";
+import { createHash } from "crypto";
+import { execFileSync } from "child_process";
+import { findProjectToml, loadProjectToml } from "../core/project.js";
+import { scanPackageDir, countBySeverity } from "../core/scan.js";
+const SKIP_DIRS = new Set(["node_modules", ".git", ".hg", ".svn", "__pycache__", "dist", "build", ".cache", ".forge"]);
+async function listFiles(dir, out = []) {
+    const { readdirSync, statSync: stat } = await import("fs");
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (SKIP_DIRS.has(e.name) || e.name.startsWith(".forge-"))
+            continue;
+        const full = join(dir, e.name);
+        try {
+            const st = stat(full);
+            if (st.isDirectory())
+                await listFiles(full, out);
+            else if (st.isFile())
+                out.push(full);
+        }
+        catch { /* skip */ }
+    }
+    return out;
+}
+export async function runPack(opts = {}) {
+    const cwd = process.cwd();
+    const tomlPath = findProjectToml(cwd);
+    if (!tomlPath) {
+        console.error("[forge] pack requires a forge.toml in the current directory");
+        process.exit(1);
+    }
+    let name, version;
+    try {
+        const parsed = loadProjectToml(tomlPath);
+        if (!parsed.package) {
+            console.error("[forge] pack requires [package] table in forge.toml");
+            process.exit(1);
+        }
+        name = parsed.package.name;
+        version = parsed.package.version;
+        if (!name || !version) {
+            console.error("[forge] [package] must have name and version");
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        console.error(`[forge] forge.toml parse error: ${e.message}`);
+        process.exit(1);
+    }
+    console.log(`[forge] packing ${name}@${version}...`);
+    const findings = scanPackageDir(cwd);
+    const counts = countBySeverity(findings);
+    console.log(`[forge] security: ${counts.high} high, ${counts.medium} medium, ${counts.low} low`);
+    if (counts.high > 0) {
+        console.log("[forge] pack FAILED — high-severity findings must be resolved first");
+        for (const f of findings.filter((x) => x.severity === "high")) {
+            console.log(`  [high] ${f.rule}: ${f.file} — ${f.message}`);
+        }
+        process.exit(1);
+    }
+    if (opts.check) {
+        console.log("[forge] check passed");
+        return;
+    }
+    const files = (await listFiles(cwd)).sort();
+    if (files.length === 0) {
+        console.error("[forge] pack: no files to pack (empty directory?)");
+        process.exit(1);
+    }
+    const outDir = join(cwd, "dist");
+    if (!existsSync(outDir))
+        mkdirSync(outDir, { recursive: true });
+    const slug = name.replace("/", "-");
+    const tarball = join(outDir, `${slug}-${version}.tgz`);
+    try {
+        const fileList = files.map((f) => `"${f}"`).join("\n");
+        const listPath = join(cwd, ".forge-pack-list.txt");
+        writeFileSync(listPath, fileList + "\n");
+        execFileSync("python", ["-c", `
+import tarfile, sys, os
+cwd = os.getcwd()
+with tarfile.open(sys.argv[1], 'w:gz') as tf:
+    for line in open('.forge-pack-list.txt'):
+        f = line.strip().strip('"')
+        if f and os.path.isfile(f):
+            tf.add(f, arcname=os.path.relpath(f, cwd))
+`], { stdio: "pipe" });
+        const { unlinkSync } = await import("fs");
+        try {
+            unlinkSync(listPath);
+        }
+        catch { /* best-effort */ }
+    }
+    catch (e) {
+        console.error(`[forge] tarball creation failed: ${e.message}`);
+        process.exit(1);
+    }
+    let sha256;
+    try {
+        const buf = readFileSync(tarball);
+        sha256 = createHash("sha256").update(buf).digest("hex");
+    }
+    catch (e) {
+        console.error(`[forge] sha256 failed: ${e.message}`);
+        process.exit(1);
+    }
+    console.log(`[forge] packed ${tarball}`);
+    console.log(`[forge] sha256: ${sha256}`);
+    console.log(`[forge] files: ${files.length}`);
+    console.log(`[forge] size: ${statSync(tarball).size} bytes`);
+}