@x12i/memorix-service 3.0.6 → 3.2.0

package/dist/routes/metadata.js

@@ -2,6 +2,127 @@ import { METADATA_KIND_IDS, METADATA_KIND_REGISTRY, validateMetadataPack, } from
 import { resolveScope } from "../request-scope.js";
 import { ServiceError } from "../errors.js";
 import { listKnownPackIds, loadKnownMetadataPack } from "../known-packs.js";
+import { stripOrgRuntimeSourcesFromPack } from "../org-sources.js";
+import { PACKAGE_CATALOG_ORG, associationsFromPack, buildPackagePayload, catalogAgentId, discoverPackageCatalog, packageVersionMessage, parsePackageMessage, releaseAssociations, resolveOwnerAgent, } from "../magit/package-catalog-bridge.js";
+function requireMagit(platform) {
+    if (!platform.magit) {
+        throw new ServiceError("MAGIT_UNAVAILABLE", "metadata versioning requires a durable Mongo connection (set METADATA_MAGIT=0 to disable)", 503);
+    }
+    return platform.magit;
+}
+function lineageFromAgent(platform, agentId) {
+    const ledger = platform.metadata.getLedger();
+    const latest = [...ledger].reverse().find((e) => e.agentId === agentId);
+    if (!latest)
+        return null;
+    return {
+        checksum: latest.checksum,
+        installedAt: latest.installedAt,
+        magitCommit: latest.magitCommit ?? null,
+        magitRelease: latest.magitRelease ?? null,
+        source: latest.source,
+        message: latest.message,
+        environment: latest.environment,
+    };
+}
+/**
+ * Install packs for multiple agents from one Magit commit.
+ * On failure, restore already-applied agents to their prior state.
+ */
+async function installAgentsAtomically(platform, magit, opts) {
+    const priors = [];
+    for (const agentId of opts.agentIds) {
+        const lineage = lineageFromAgent(platform, agentId);
+        const exported = platform.metadata.exportMetadata([agentId]);
+        priors.push({
+            agentId,
+            magitCommit: lineage?.magitCommit ?? null,
+            pack: exported.packs[agentId] ?? null,
+        });
+    }
+    const ledgerEntries = [];
+    const applied = [];
+    try {
+        for (const agentId of opts.agentIds) {
+            const loaded = await magit.packAtCommit(opts.orgId, agentId, opts.commit);
+            const validation = validateMetadataPack(loaded.pack);
+            if (!validation.ok) {
+                throw new ServiceError("VALIDATION", `pack at commit failed validation for ${agentId}: ${validation.issues
+                    .map((i) => i.message)
+                    .join("; ")}`, 400, { issues: validation.issues, agentId });
+            }
+            const result = platform.metadata.install(loaded.pack, {
+                reinstall: true,
+                magitCommit: opts.commit,
+                ...(opts.magitRelease ? { magitRelease: opts.magitRelease } : {}),
+                source: opts.source,
+                message: opts.message,
+                environment: "live",
+            });
+            if (!result.ok || !result.ledgerEntry) {
+                throw new ServiceError("VALIDATION", result.issues.map((i) => i.message).join("; ") ||
+                    `bundle install failed for ${agentId}`, 400);
+            }
+            ledgerEntries.push(result.ledgerEntry);
+            applied.push(agentId);
+        }
+        return {
+            installed: true,
+            rolledBack: false,
+            commit: opts.commit,
+            ledgerEntries,
+            restoredAgentIds: [],
+        };
+    }
+    catch (err) {
+        const restoredAgentIds = [];
+        for (const agentId of [...applied].reverse()) {
+            const prior = priors.find((p) => p.agentId === agentId);
+            if (!prior)
+                continue;
+            try {
+                if (prior.magitCommit) {
+                    const loaded = await magit.packAtCommit(opts.orgId, agentId, prior.magitCommit);
+                    platform.metadata.install(loaded.pack, {
+                        reinstall: true,
+                        magitCommit: prior.magitCommit,
+                        source: "rollback",
+                        message: `Rollback after failed bundle install (${agentId})`,
+                        environment: "live",
+                    });
+                    restoredAgentIds.push(agentId);
+                }
+                else if (prior.pack) {
+                    platform.metadata.install(prior.pack, {
+                        reinstall: true,
+                        source: "rollback",
+                        message: `Rollback after failed bundle install (${agentId})`,
+                        environment: "live",
+                    });
+                    restoredAgentIds.push(agentId);
+                }
+            }
+            catch {
+                /* best-effort restore */
+            }
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        if (err instanceof ServiceError) {
+            throw new ServiceError(err.code, `${message} (rolled back: ${restoredAgentIds.join(",") || "none"})`, err.statusCode, {
+                rolledBack: true,
+                restoredAgentIds,
+            });
+        }
+        return {
+            installed: false,
+            rolledBack: restoredAgentIds.length > 0,
+            commit: opts.commit,
+            ledgerEntries: [],
+            restoredAgentIds,
+            error: message,
+        };
+    }
+}
 export async function registerMetadataRoutes(app, platform) {
     app.get("/api/metadata/packs", async (req) => {
         const scope = resolveScope(req);
@@ -15,13 +136,15 @@ export async function registerMetadataRoutes(app, platform) {
         const scope = resolveScope(req);
         const q = req.query;
         const agentId = (q.agentId?.trim() || scope.agentIds[0]);
-        return { scope, agentId, raw: platform.metadata.getRaw(agentId) };
+        const raw = platform.metadata.getRaw(agentId);
+        const lineage = lineageFromAgent(platform, agentId);
+        const exported = platform.metadata.exportMetadata([agentId]);
+        const pack = exported.packs[agentId] ?? null;
+        return { scope, agentId, raw, lineage, pack };
     });
     app.get("/api/metadata/effective", async (req) => {
         const scope = resolveScope(req);
         const resolved = platform.metadata.resolveEffective(scope.agentIds);
-        // Contract: `effective` is always the EffectiveDefinition[] array.
-        // Inheritance / resolve diagnostics live beside it (never nested as the array).
         return {
             scope,
             ok: resolved.ok,
@@ -36,7 +159,6 @@ export async function registerMetadataRoutes(app, platform) {
             note: "agentIds select effective metadata only; effective is the resolved definition array",
         };
     });
-    /** List built-in kinds + effective custom kind-declarations for the scope. */
     app.get("/api/metadata/kinds", async (req) => {
         const scope = resolveScope(req);
         const effective = platform.metadata.resolveEffective(scope.agentIds);
@@ -70,6 +192,18 @@ export async function registerMetadataRoutes(app, platform) {
         const scope = resolveScope(req);
         return { scope, result: platform.metadata.resolveAbstracts(scope.agentIds) };
     });
+    app.get("/api/metadata/topology", async (req) => {
+        const scope = resolveScope(req);
+        const topology = platform.metadata.buildTopology(scope.agentIds);
+        return {
+            scope,
+            ok: topology.ok,
+            nodes: topology.nodes,
+            edges: topology.edges,
+            issues: topology.issues,
+            note: "Projected concrete topology from effective metadata; author relationships on abstracts",
+        };
+    });
     app.post("/api/metadata/validate", async (req) => {
         const scope = resolveScope(req);
         const body = req.body;
@@ -84,17 +218,68 @@ export async function registerMetadataRoutes(app, platform) {
         if (!body?.confirm) {
             throw new ServiceError("CONFIRMATION_REQUIRED", "explicit confirm:true required for metadata install", 400);
         }
-        const pack = body.pack ?? (body.packId ? loadKnownMetadataPack(body.packId) : undefined);
+        const agentHint = body.pack?.agentId?.trim() ||
+            body.packId?.trim() ||
+            scope.agentIds[0] ||
+            "";
+        let pack = body.pack;
+        let magitCommit = body.commit?.trim() || undefined;
+        const proposalId = body.proposalId?.trim();
+        if (magitCommit) {
+            const magit = requireMagit(platform);
+            if (!agentHint) {
+                throw new ServiceError("VALIDATION", "agentId required with commit", 400);
+            }
+            const loaded = await magit.packAtCommit(scope.orgId, agentHint, magitCommit);
+            pack = loaded.pack;
+            magitCommit = loaded.commit;
+        }
+        else if (!pack && body.packId) {
+            pack = loadKnownMetadataPack(body.packId);
+        }
         if (!pack)
-            throw new ServiceError("VALIDATION", "pack or packId required", 400);
+            throw new ServiceError("VALIDATION", "pack, packId, or commit required", 400);
+        // Org folder sources are never pack/Magit content — strip before save/install.
+        pack = stripOrgRuntimeSourcesFromPack(pack);
         const validation = validateMetadataPack(pack);
         if (!validation.ok) {
             return { scope, result: validation, installed: false, published: false };
         }
-        const result = platform.metadata.install(pack, { reinstall: body.reinstall });
+        const versionMessage = body.versionMessage?.trim() ||
+            (proposalId
+                ? `Install proposal ${proposalId}`
+                : magitCommit
+                    ? `Install ${pack.agentId} @ ${magitCommit.slice(0, 12)}`
+                    : `Install ${pack.agentId}`);
+        if (!magitCommit && platform.magit) {
+            try {
+                const saved = await platform.magit.saveVersion(scope.orgId, pack, {
+                    message: versionMessage,
+                });
+                magitCommit = saved.commit;
+            }
+            catch (err) {
+                // Fail closed when Magit is enabled — never silent checksum-only install.
+                throw err instanceof ServiceError
+                    ? err
+                    : new ServiceError("MAGIT_UNAVAILABLE", err instanceof Error ? err.message : String(err), 503);
+            }
+        }
+        const source = proposalId
+            ? "proposal-install"
+            : "install";
+        const result = platform.metadata.install(pack, {
+            reinstall: body.reinstall,
+            source,
+            message: versionMessage,
+            environment: "live",
+            ...(magitCommit ? { magitCommit } : {}),
+        });
         return {
             scope,
             packId: body.packId ?? pack.agentId,
+            proposalId: proposalId || undefined,
+            commit: magitCommit,
             result,
             installed: Boolean(result.ok),
             published: false,
@@ -107,24 +292,221 @@ export async function registerMetadataRoutes(app, platform) {
             note: "intelligence proposals are never auto-installed",
         };
     });
+    app.post("/api/metadata/proposals/:id/stage", async (req) => {
+        const scope = resolveScope(req);
+        const magit = requireMagit(platform);
+        const { id: proposalId } = req.params;
+        const body = (req.body ?? {});
+        let proposal = body.proposal
+            ? {
+                proposalId: body.proposal.proposalId?.trim() || proposalId,
+                metadataKind: body.proposal.metadataKind,
+                metadataId: body.proposal.metadataId,
+                draft: body.proposal.draft,
+                scope: body.proposal.scope,
+            }
+            : null;
+        if (!proposal) {
+            if (!platform.client) {
+                throw new ServiceError("DURABLE_STORE_REQUIRED", "proposal staging requires durable intelligence store or body.proposal", 503);
+            }
+            try {
+                const stored = await platform
+                    .intelligenceArtifactsFor(scope.orgId)
+                    .getProposal(proposalId);
+                if (!stored) {
+                    throw new ServiceError("NOT_FOUND", `proposal not found: ${proposalId}`, 404);
+                }
+                proposal = {
+                    proposalId: stored.proposalId,
+                    metadataKind: stored.metadataKind,
+                    metadataId: stored.metadataId,
+                    draft: stored.draft,
+                    scope: stored.scope,
+                };
+            }
+            catch (err) {
+                if (err instanceof ServiceError)
+                    throw err;
+                throw new ServiceError("VALIDATION", `failed to load proposal ${proposalId}: ${err instanceof Error ? err.message : String(err)}`, 400);
+            }
+        }
+        const agentId = body.agentId?.trim() ||
+            proposal.scope?.agentIds?.[0]?.trim() ||
+            scope.agentIds[0] ||
+            "";
+        if (!agentId)
+            throw new ServiceError("VALIDATION", "agentId required", 400);
+        const exported = platform.metadata.exportMetadata([agentId]);
+        const basePack = exported.packs[agentId] ?? null;
+        const staged = await magit.importProposal(scope.orgId, {
+            agentId,
+            proposal,
+            basePack,
+        });
+        const validation = validateMetadataPack(staged.pack);
+        return {
+            scope,
+            proposalId: proposal.proposalId,
+            agentId,
+            commit: staged.commit,
+            checksum: staged.checksum,
+            reused: staged.reused,
+            pack: staged.pack,
+            validation,
+            installed: false,
+            note: "stage saves a Magit version only — live metadata unchanged until explicit install",
+        };
+    });
+    app.post("/api/metadata/install/bundle", async (req) => {
+        const scope = resolveScope(req);
+        const magit = requireMagit(platform);
+        const body = req.body;
+        if (!body?.confirm) {
+            throw new ServiceError("CONFIRMATION_REQUIRED", "explicit confirm:true required for bundle install", 400);
+        }
+        const commit = body.commit?.trim();
+        if (!commit)
+            throw new ServiceError("VALIDATION", "commit required", 400);
+        const agentIds = body.agentIds?.map((a) => a.trim()).filter(Boolean) ?? [...scope.agentIds];
+        if (!agentIds.length) {
+            throw new ServiceError("VALIDATION", "agentIds required", 400);
+        }
+        const message = body.message?.trim() ||
+            `Bundle install ${agentIds.join("+")} @ ${commit.slice(0, 12)}`;
+        const release = body.release?.trim();
+        const result = await installAgentsAtomically(platform, magit, {
+            orgId: scope.orgId,
+            agentIds,
+            commit,
+            message,
+            source: release ? "publish" : "bundle-install",
+            magitRelease: release,
+        });
+        return { scope, ...result };
+    });
+    app.post("/api/metadata/publish/plan", async (req) => {
+        const scope = resolveScope(req);
+        const magit = requireMagit(platform);
+        const body = req.body;
+        const release = body.release?.trim();
+        const commit = body.commit?.trim();
+        if (!release)
+            throw new ServiceError("VALIDATION", "release required", 400);
+        if (!commit)
+            throw new ServiceError("VALIDATION", "commit required", 400);
+        const agentIds = body.agentIds?.map((a) => a.trim()).filter(Boolean) ??
+            (body.agentId?.trim() ? [body.agentId.trim()] : scope.agentIds);
+        const plan = await magit.publishPlan(scope.orgId, {
+            release,
+            commit,
+            agentIds,
+        });
+        return { scope, plan, note: "publish plan is read-only; confirm via POST /api/metadata/publish" };
+    });
     app.post("/api/metadata/publish", async (req) => {
         const scope = resolveScope(req);
         const body = req.body;
         if (!body?.confirm) {
             throw new ServiceError("CONFIRMATION_REQUIRED", "explicit confirm:true required for metadata publish", 400);
         }
-        return { scope, published: true, note: "publish is explicit" };
+        const magit = requireMagit(platform);
+        const release = body.release?.trim();
+        const commit = body.commit?.trim();
+        if (!release)
+            throw new ServiceError("VALIDATION", "release required", 400);
+        if (!commit)
+            throw new ServiceError("VALIDATION", "commit required", 400);
+        const agentIds = body.agentIds?.map((a) => a.trim()).filter(Boolean) ??
+            (body.agentId?.trim() ? [body.agentId.trim()] : scope.agentIds);
+        if (!agentIds.length) {
+            throw new ServiceError("VALIDATION", "agentIds required", 400);
+        }
+        const plan = await magit.publishPlan(scope.orgId, { release, commit, agentIds });
+        if (body.planHash?.trim() && body.planHash.trim() !== plan.planHash) {
+            throw new ServiceError("VALIDATION", "planHash mismatch — re-run publish plan", 409);
+        }
+        const now = new Date().toISOString();
+        const message = body.message?.trim() || `Publish ${release}`;
+        const applied = await installAgentsAtomically(platform, magit, {
+            orgId: scope.orgId,
+            agentIds,
+            commit,
+            message,
+            source: agentIds.length > 1 ? "bundle-install" : "publish",
+            magitRelease: release,
+        });
+        if (!applied.installed) {
+            throw new ServiceError("VALIDATION", applied.error || "publish install failed", 400, { restoredAgentIds: applied.restoredAgentIds });
+        }
+        await magit.recordRelease(scope.orgId, {
+            name: release,
+            commit,
+            agentIds,
+            createdAt: now,
+            message,
+        });
+        return {
+            scope,
+            published: true,
+            release,
+            commit,
+            planHash: plan.planHash,
+            ledgerEntries: applied.ledgerEntries,
+            note: "publish installed packs reconstructed from Magit commit",
+        };
     });
-    /** Save a pack version (Magit proposePatchset) — not live. Requires METADATA_MAGIT=1 + isolation. */
-    app.post("/api/metadata/versions", async (req) => {
+    app.post("/api/metadata/rollback", async (req) => {
         const scope = resolveScope(req);
-        if (!platform.magit) {
-            throw new ServiceError("MAGIT_UNAVAILABLE", "metadata versioning requires METADATA_MAGIT=1 and org isolation", 503);
+        const magit = requireMagit(platform);
+        const body = req.body;
+        if (!body?.confirm) {
+            throw new ServiceError("CONFIRMATION_REQUIRED", "explicit confirm:true required for metadata rollback", 400);
         }
+        const agentId = (body.agentId?.trim() || scope.agentIds[0]);
+        const commit = body.commit?.trim();
+        if (!commit)
+            throw new ServiceError("VALIDATION", "commit required", 400);
+        const integrity = await magit.diff(scope.orgId, agentId, {
+            from: "live",
+            to: commit,
+        });
+        const loaded = await magit.packAtCommit(scope.orgId, agentId, commit);
+        const restoredPack = stripOrgRuntimeSourcesFromPack(loaded.pack);
+        const validation = validateMetadataPack(restoredPack);
+        if (!validation.ok) {
+            throw new ServiceError("VALIDATION", "pack at commit failed validation", 400, { issues: validation.issues });
+        }
+        const message = body.message?.trim() || `Restore ${agentId} to ${commit.slice(0, 12)}`;
+        const result = platform.metadata.install(restoredPack, {
+            reinstall: true,
+            magitCommit: commit,
+            magitRelease: undefined,
+            source: "rollback",
+            message,
+            environment: "live",
+        });
+        if (!result.ok) {
+            throw new ServiceError("VALIDATION", result.issues.map((i) => i.message).join("; ") || "restore install failed", 400);
+        }
+        return {
+            scope,
+            restored: true,
+            agentId,
+            commit,
+            integrity,
+            result,
+            note: "restore installed pack reconstructed from Magit commit",
+        };
+    });
+    app.post("/api/metadata/versions", async (req) => {
+        const scope = resolveScope(req);
+        const magit = requireMagit(platform);
         const body = req.body;
-        const pack = body.pack ?? (body.packId ? loadKnownMetadataPack(body.packId) : undefined);
-        if (!pack)
+        const rawPack = body.pack ?? (body.packId ? loadKnownMetadataPack(body.packId) : undefined);
+        if (!rawPack)
             throw new ServiceError("VALIDATION", "pack or packId required", 400);
+        const pack = stripOrgRuntimeSourcesFromPack(rawPack);
         const message = body.message?.trim();
         if (!message) {
             throw new ServiceError("VALIDATION", "message required", 400);
@@ -133,7 +515,7 @@ export async function registerMetadataRoutes(app, platform) {
         if (!validation.ok) {
             return { scope, result: validation, saved: false };
         }
-        const saved = await platform.magit.saveVersion(scope.orgId, pack, { message });
+        const saved = await magit.saveVersion(scope.orgId, pack, { message });
         return {
             scope,
             saved: true,
@@ -141,23 +523,69 @@ export async function registerMetadataRoutes(app, platform) {
             checksum: saved.checksum,
             reused: saved.reused,
             agentId: pack.agentId,
-            note: "save version is not install; live metadata unchanged",
+            note: "save version is not install; live metadata unchanged; org folder sources stripped",
         };
     });
-    /** List saved pack versions for an agent (Magit proposal ledger + HEAD). */
     app.get("/api/metadata/versions", async (req) => {
         const scope = resolveScope(req);
-        if (!platform.magit) {
-            throw new ServiceError("MAGIT_UNAVAILABLE", "metadata versioning requires METADATA_MAGIT=1 and org isolation", 503);
-        }
+        const magit = requireMagit(platform);
         const q = req.query;
         const agentId = (q.agentId?.trim() || scope.agentIds[0]);
+        // Lazy backfill: checksum-only installs get an initial Magit snapshot once.
+        const lineage = lineageFromAgent(platform, agentId);
+        if (lineage && !lineage.magitCommit) {
+            const pack = platform.metadata.exportMetadata([agentId]).packs[agentId];
+            if (pack) {
+                const saved = await magit.backfillLineage(scope.orgId, pack);
+                platform.stampAgentLineage(agentId, { magitCommit: saved.commit });
+                platform.appendInstallLedger({
+                    agentId,
+                    checksum: lineage.checksum,
+                    installedAt: new Date().toISOString(),
+                    definitionCount: 0,
+                    noop: true,
+                    magitCommit: saved.commit,
+                    source: "install",
+                    message: "backfill: initial snapshot",
+                    environment: "live",
+                    previousChecksum: lineage.checksum,
+                });
+            }
+        }
         const maxCount = q.maxCount ? Number(q.maxCount) : undefined;
-        const versions = await platform.magit.history(scope.orgId, agentId, {
+        const versions = await magit.history(scope.orgId, agentId, {
             maxCount: Number.isFinite(maxCount) ? maxCount : undefined,
         });
         return { scope, agentId, versions };
     });
+    app.get("/api/metadata/versions/:commit", async (req) => {
+        const scope = resolveScope(req);
+        const magit = requireMagit(platform);
+        const { commit } = req.params;
+        const q = req.query;
+        const agentId = (q.agentId?.trim() || scope.agentIds[0]);
+        const loaded = await magit.packAtCommit(scope.orgId, agentId, commit);
+        return {
+            scope,
+            agentId,
+            commit: loaded.commit,
+            checksum: loaded.checksum,
+            pack: loaded.pack,
+        };
+    });
+    app.post("/api/metadata/diff", async (req) => {
+        const scope = resolveScope(req);
+        const magit = requireMagit(platform);
+        const body = req.body;
+        const agentId = (body.agentId?.trim() || scope.agentIds[0]);
+        const from = body.from?.trim();
+        const to = body.to?.trim();
+        if (!from || !to) {
+            throw new ServiceError("VALIDATION", "from and to required", 400);
+        }
+        const diff = await magit.diff(scope.orgId, agentId, { from, to });
+        return { scope, ...diff };
+    });
     app.get("/api/metadata/definition", async (req) => {
         const scope = resolveScope(req);
         const q = req.query;
@@ -167,5 +595,326 @@ export async function registerMetadataRoutes(app, platform) {
         const def = platform.metadata.getDefinition(scope.agentIds, q.kind, q.id);
         return { scope, definition: def };
     });
+    // ---------------------------------------------------------------------------
+    // Package catalog bridge (FR-CPS interim — org-free Pack; org required on Restore)
+    // Spec: .operational/magit-central-package-storage-FR.md
+    // ---------------------------------------------------------------------------
+    function installedPacks() {
+        return platform.metadata.exportMetadata().packs;
+    }
+    function parseKind(raw) {
+        const k = typeof raw === "string" ? raw.trim() : "";
+        if (k === "agent" || k === "connector" || k === "service")
+            return k;
+        throw new ServiceError("VALIDATION", "kind must be agent | connector | service", 400);
+    }
+    app.get("/api/metadata/packages", async (req) => {
+        requireMagit(platform);
+        const q = req.query;
+        const kindFilter = q.kind?.trim() && q.kind.trim() !== "all"
+            ? parseKind(q.kind)
+            : undefined;
+        const catalog = discoverPackageCatalog(installedPacks()).filter((e) => kindFilter ? e.kind === kindFilter : true);
+        return {
+            packages: catalog,
+            interim: true,
+            catalogOrg: PACKAGE_CATALOG_ORG,
+            note: "Interim local catalog from installed packs. Central org-free Magit storage: FR-CPS.",
+        };
+    });
+    app.get("/api/metadata/packages/:kind/:id/associations", async (req) => {
+        requireMagit(platform);
+        const kind = parseKind(req.params.kind);
+        const id = String(req.params.id ?? "").trim();
+        if (!id)
+            throw new ServiceError("VALIDATION", "id required", 400);
+        const packs = installedPacks();
+        const q = req.query;
+        const agentId = resolveOwnerAgent(packs, kind, id, q.agentId);
+        const pack = packs[agentId];
+        if (!pack) {
+            throw new ServiceError("NOT_FOUND", `No installed pack for agent ${agentId}`, 404);
+        }
+        return {
+            kind,
+            id,
+            agentId,
+            associations: associationsFromPack(pack),
+            interim: true,
+        };
+    });
+    app.get("/api/metadata/packages/:kind/:id/versions", async (req) => {
+        const magit = requireMagit(platform);
+        const kind = parseKind(req.params.kind);
+        const id = String(req.params.id ?? "").trim();
+        if (!id)
+            throw new ServiceError("VALIDATION", "id required", 400);
+        const q = req.query;
+        const packs = installedPacks();
+        let ownerAgentId;
+        try {
+            ownerAgentId = resolveOwnerAgent(packs, kind, id, q.agentId);
+        }
+        catch {
+            ownerAgentId = kind === "agent" ? id : q.agentId?.trim() || "";
+        }
+        const sliceAgentId = catalogAgentId(kind, id, ownerAgentId || undefined);
+        const maxCount = q.maxCount ? Number(q.maxCount) : 50;
+        const versions = await magit.history(PACKAGE_CATALOG_ORG, sliceAgentId, {
+            maxCount: Number.isFinite(maxCount) ? maxCount : 50,
+        });
+        const filtered = versions.map((v) => {
+            const parsed = parsePackageMessage(v.message);
+            return {
+                ...v,
+                packageKind: parsed.kind ?? kind,
+                packageId: parsed.id ?? id,
+                mode: parsed.mode,
+                displayMessage: parsed.message || v.message,
+            };
+        });
+        return {
+            kind,
+            id,
+            agentId: ownerAgentId || id,
+            catalogAgentId: sliceAgentId,
+            versions: filtered,
+            interim: true,
+            catalogOrg: PACKAGE_CATALOG_ORG,
+            note: "Versions from interim package catalog Magit repo (not runtime org).",
+        };
+    });
+    app.post("/api/metadata/packages/pack", async (req) => {
+        const magit = requireMagit(platform);
+        const body = req.body;
+        const kind = parseKind(body.kind);
+        const id = body.id?.trim();
+        if (!id)
+            throw new ServiceError("VALIDATION", "id required", 400);
+        const message = body.message?.trim();
+        if (!message)
+            throw new ServiceError("VALIDATION", "message required", 400);
+        const packs = installedPacks();
+        let agentId;
+        try {
+            agentId = resolveOwnerAgent(packs, kind, id, body.agentId);
+        }
+        catch (e) {
+            throw new ServiceError("NOT_FOUND", e instanceof Error ? e.message : String(e), 404);
+        }
+        const live = packs[agentId];
+        if (!live) {
+            throw new ServiceError("NOT_FOUND", `No installed pack for agent ${agentId}`, 404);
+        }
+        const mode = kind === "agent" ? (body.mode === "narrow" ? "narrow" : "full") : undefined;
+        const payload = buildPackagePayload(live, {
+            kind,
+            id,
+            mode,
+            includeConnectorIds: body.includeConnectorIds,
+            includeServiceIds: body.includeServiceIds,
+        });
+        const validation = validateMetadataPack(payload);
+        if (!validation.ok) {
+            return { packed: false, result: validation, interim: true };
+        }
+        const saved = await magit.saveVersion(PACKAGE_CATALOG_ORG, payload, {
+            message: packageVersionMessage(kind, id, message, mode),
+        });
+        const associations = kind === "agent" && mode
+            ? releaseAssociations(live, mode, body.includeConnectorIds, body.includeServiceIds)
+            : undefined;
+        // Full agent pack also snapshots selected connector/service packages.
+        const bundled = [];
+        if (kind === "agent" && mode === "full" && associations) {
+            for (const connectorId of associations.connectorIds) {
+                const slice = buildPackagePayload(live, { kind: "connector", id: connectorId });
+                const ok = validateMetadataPack(slice);
+                if (!ok.ok)
+                    continue;
+                const b = await magit.saveVersion(PACKAGE_CATALOG_ORG, slice, {
+                    message: packageVersionMessage("connector", connectorId, `bundled with agent ${id}: ${message}`),
+                });
+                bundled.push({ kind: "connector", id: connectorId, commit: b.commit });
+            }
+            for (const serviceId of associations.serviceIds) {
+                const slice = buildPackagePayload(live, { kind: "service", id: serviceId });
+                const ok = validateMetadataPack(slice);
+                if (!ok.ok)
+                    continue;
+                const b = await magit.saveVersion(PACKAGE_CATALOG_ORG, slice, {
+                    message: packageVersionMessage("service", serviceId, `bundled with agent ${id}: ${message}`),
+                });
+                bundled.push({ kind: "service", id: serviceId, commit: b.commit });
+            }
+        }
+        return {
+            packed: true,
+            kind,
+            id,
+            agentId,
+            mode: mode ?? null,
+            associations,
+            bundled,
+            commit: saved.commit,
+            version: saved.commit,
+            checksum: saved.checksum,
+            reused: saved.reused,
+            interim: true,
+            catalogOrg: PACKAGE_CATALOG_ORG,
+            note: "Pack stored in interim Magit catalog (not live). Central storage: FR-CPS.",
+        };
+    });
+    app.post("/api/metadata/packages/restore", async (req) => {
+        const scope = resolveScope(req);
+        const magit = requireMagit(platform);
+        const body = req.body;
+        if (!body?.confirm) {
+            throw new ServiceError("CONFIRMATION_REQUIRED", "explicit confirm:true required for package restore", 400);
+        }
+        if (!scope.orgId?.trim()) {
+            throw new ServiceError("VALIDATION", "x-memorix-org-id required — org is the restore target, not package identity", 400);
+        }
+        const kind = parseKind(body.kind);
+        const id = body.id?.trim();
+        if (!id)
+            throw new ServiceError("VALIDATION", "id required", 400);
+        const version = (body.version ?? body.commit)?.trim();
+        if (!version)
+            throw new ServiceError("VALIDATION", "version required", 400);
+        const packs = installedPacks();
+        let agentId;
+        try {
+            agentId = resolveOwnerAgent(packs, kind, id, body.agentId);
+        }
+        catch {
+            agentId = kind === "agent" ? id : body.agentId?.trim() || "";
+        }
+        if (!agentId) {
+            throw new ServiceError("VALIDATION", "agentId required to restore connector/service into an agent pack", 400);
+        }
+        const sliceAgentId = catalogAgentId(kind, id, agentId);
+        const loaded = await magit.packAtCommit(PACKAGE_CATALOG_ORG, sliceAgentId, version);
+        let installPack = loaded.pack;
+        // Connector/service restore merges slice into current live agent pack.
+        if (kind === "connector" || kind === "service") {
+            const live = packs[agentId] ?? emptyPackForRestore(agentId);
+            if (kind === "connector") {
+                const keepRefs = new Set((loaded.pack.sources ?? [])
+                    .map((s) => s && typeof s === "object" && "connectorRef" in s
+                    ? String(s.connectorRef ?? "")
+                    : "")
+                    .filter(Boolean));
+                const otherSources = (live.sources ?? []).filter((s) => {
+                    const ref = s && typeof s === "object" && "connectorRef" in s
+                        ? String(s.connectorRef ?? "")
+                        : "";
+                    return !keepRefs.has(ref);
+                });
+                installPack = {
+                    ...live,
+                    agentId,
+                    sources: [...otherSources, ...(loaded.pack.sources ?? [])],
+                };
+            }
+            else {
+                const svcId = id;
+                const otherServices = (live.services ?? []).filter((s) => !(s && typeof s === "object" && "id" in s && String(s.id) === svcId));
+                installPack = {
+                    ...live,
+                    agentId,
+                    services: [...otherServices, ...(loaded.pack.services ?? [])],
+                };
+            }
+        }
+        installPack = stripOrgRuntimeSourcesFromPack(installPack);
+        const validation = validateMetadataPack(installPack);
+        if (!validation.ok) {
+            throw new ServiceError("VALIDATION", "pack at version failed validation", 400, { issues: validation.issues });
+        }
+        const message = body.message?.trim() ||
+            `Restore ${kind}:${id} @ ${version.slice(0, 12)} into org ${scope.orgId}`;
+        const result = platform.metadata.install(installPack, {
+            reinstall: true,
+            magitCommit: version,
+            magitRelease: undefined,
+            source: "rollback",
+            message,
+            environment: "live",
+        });
+        if (!result.ok) {
+            throw new ServiceError("VALIDATION", result.issues.map((i) => i.message).join("; ") || "restore install failed", 400);
+        }
+        return {
+            restored: true,
+            kind,
+            id,
+            agentId,
+            version,
+            targetOrgId: scope.orgId,
+            result,
+            interim: true,
+            catalogOrg: PACKAGE_CATALOG_ORG,
+            note: "Restored from interim Magit catalog into this environment. Org is restore target only.",
+        };
+    });
+    app.post("/api/metadata/packages/diff", async (req) => {
+        const magit = requireMagit(platform);
+        const body = req.body;
+        const kind = parseKind(body.kind);
+        const id = body.id?.trim();
+        if (!id)
+            throw new ServiceError("VALIDATION", "id required", 400);
+        const from = body.from?.trim();
+        const to = body.to?.trim();
+        if (!from || !to) {
+            throw new ServiceError("VALIDATION", "from and to required", 400);
+        }
+        const packs = installedPacks();
+        let agentId;
+        try {
+            agentId = resolveOwnerAgent(packs, kind, id, body.agentId);
+        }
+        catch {
+            agentId = kind === "agent" ? id : body.agentId?.trim() || id;
+        }
+        const sliceAgentId = catalogAgentId(kind, id, agentId);
+        // "installed" sentinel → live for Magit diff (same Mongo metadata DB)
+        const fromRef = from === "installed" ? "live" : from;
+        const toRef = to === "installed" ? "live" : to;
+        const diff = await magit.diff(PACKAGE_CATALOG_ORG, sliceAgentId, {
+            from: fromRef,
+            to: toRef,
+        });
+        return {
+            ...diff,
+            kind,
+            id,
+            agentId,
+            catalogAgentId: sliceAgentId,
+            interim: true,
+            note: "Compare package versions or version vs installed. Not env→env copy.",
+        };
+    });
+}
+function emptyPackForRestore(agentId) {
+    return {
+        format: "memorix-metadata/1",
+        agentId,
+        agents: [],
+        objectTypes: [],
+        abstractTypes: [],
+        abstractBindings: [],
+        relationshipDefinitions: [],
+        mappings: [],
+        views: [],
+        writes: [],
+        sources: [],
+        services: [],
+        pipelines: [],
+        schedules: [],
+        kindDeclarations: [],
+        extensions: {},
+    };
 }
 //# sourceMappingURL=metadata.js.map