@agentxm/extension-authoring 0.28.4-bootstrap.0

package/dist/src/hooks/new-hook.js

@@ -0,0 +1,164 @@
+/**
+ * New hook operation — scaffolds a new hook directory with the manifest and a
+ * starter entrypoint.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import { AuthoringFailed } from "../errors.js";
+import { AuthoringFailureAdapter, withAdaptedStepFailures } from "../failure-adapter.js";
+import { createCanonicalDirectory, recoverCanonicalDirectory } from "@agentxm/extension-workspace";
+import { preflightCreateOnly } from "../create-preflight.js";
+import { decodeExtensionNameSync } from "@agentxm/extension-model/unstable/extensions";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { decodeVersionSync } from "@agentxm/extension-model/unstable/version-constraints";
+import { HOOK_EXTENSION_DIR, HOOK_MANIFEST_FILENAME, HOOK_MANIFEST_SCHEMA_URL, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+const INITIAL_HOOK_VERSION = decodeVersionSync("0.1.0");
+const entrypointFilename = (runtime) => {
+    switch (runtime) {
+        case "bash":
+            return "hook.sh";
+        case "node":
+            return "hook.js";
+        case "python":
+            return "hook.py";
+    }
+};
+const matcherForBinding = (event, matcher) => event === "tool.pre" || event === "tool.post" ? matcher : undefined;
+const makeEntrypoint = (runtime, fqn) => {
+    switch (runtime) {
+        case "bash":
+            return `#!/usr/bin/env bash
+# ${fqn}
+# Receives the agent hook event payload as JSON on stdin.
+set -euo pipefail
+
+payload="$(cat)"
+
+# TODO: inspect "$payload" and implement the hook.
+# Emit JSON on stdout or exit non-zero to influence the agent.
+exit 0
+`;
+        case "node":
+            return `#!/usr/bin/env node
+// ${fqn}
+// Receives the agent hook event payload as JSON on stdin.
+let raw = "";
+process.stdin.on("data", (chunk) => {
+  raw += chunk;
+});
+process.stdin.on("end", () => {
+  const payload = raw ? JSON.parse(raw) : {};
+
+  // TODO: inspect payload and implement the hook.
+  // Emit JSON on stdout or exit non-zero to influence the agent.
+  process.exit(0);
+});
+`;
+        case "python":
+            return `#!/usr/bin/env python3
+"""${fqn}
+
+Receives the agent hook event payload as JSON on stdin.
+"""
+import json
+import sys
+
+raw = sys.stdin.read()
+payload = json.loads(raw) if raw else {}
+
+# TODO: inspect payload and implement the hook.
+# Emit JSON on stdout or exit non-zero to influence the agent.
+sys.exit(0)
+`;
+    }
+};
+// -----------------------------------------------------------------------------
+// Public API
+// -----------------------------------------------------------------------------
+/**
+ * New-hook operation handler.
+ *
+ * 1. Compute managed extension directory path
+ * 2. Check if the hook already exists (directory or settings entry)
+ * 3. Create the managed extension + src directories
+ * 4. Write hook.json manifest
+ * 5. Write starter entrypoint in src/
+ */
+export const newHook = (op) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const ws = yield* WorkspaceMutations;
+    const base = ws.baseDir;
+    if (ws.layout.scope !== "project") {
+        return yield* new AuthoringFailed({
+            category: "validation",
+            detail: "New hooks can only be scaffolded in a project workspace",
+        });
+    }
+    const { name, owner, runtime, event, matcher } = op.args;
+    const fqn = `${owner}/${HOOK_EXTENSION_DIR}/${name}`;
+    const configuredHooks = yield* ws.getConfiguredHookEntries();
+    const canonicalPath = path.join(ws.layout.authoredRoot("hook"), name);
+    yield* recoverCanonicalDirectory({ baseDir: base, canonicalPath });
+    yield* preflightCreateOnly({
+        subject: "Hook",
+        name,
+        configured: Object.hasOwn(configuredHooks, name),
+        destinations: [canonicalPath],
+    });
+    const entrypointFile = entrypointFilename(runtime);
+    const bindingMatcher = matcherForBinding(event, matcher);
+    const manifest = {
+        $schema: HOOK_MANIFEST_SCHEMA_URL,
+        owner,
+        type: "hook",
+        name: decodeExtensionNameSync(name),
+        version: INITIAL_HOOK_VERSION,
+        runtime,
+        entrypoint: `src/${entrypointFile}`,
+        bindings: [
+            bindingMatcher === undefined ? { on: event } : { on: event, matcherRaw: bindingMatcher },
+        ],
+    };
+    yield* createCanonicalDirectory({
+        baseDir: base,
+        canonicalPath,
+        subject: "Hook",
+        requiredFiles: [HOOK_MANIFEST_FILENAME, `src/${entrypointFile}`],
+        populate: (stagingPath) => {
+            const srcDir = path.join(stagingPath, "src");
+            return Effect.gen(function* () {
+                yield* fs.makeDirectory(srcDir, { recursive: true }).pipe(Effect.mapError((e) => new AuthoringFailed({
+                    category: "validation",
+                    detail: `Failed to create hook directory: ${srcDir}`,
+                    cause: e,
+                })));
+                yield* fs
+                    .writeFileString(path.join(stagingPath, HOOK_MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + "\n")
+                    .pipe(Effect.mapError((e) => new AuthoringFailed({
+                    category: "validation",
+                    detail: "Hook manifest could not be written",
+                    cause: e,
+                })));
+                yield* fs
+                    .writeFileString(path.join(srcDir, entrypointFile), makeEntrypoint(runtime, fqn))
+                    .pipe(Effect.mapError((e) => new AuthoringFailed({
+                    category: "validation",
+                    detail: `Failed to write ${entrypointFile}`,
+                    cause: e,
+                })));
+            });
+        },
+    });
+    return {
+        result: "success",
+        message: `Created hook ${fqn}`,
+    };
+}).pipe(withAdaptedStepFailures);
+//# sourceMappingURL=new-hook.js.map

package/dist/src/import-native-package.d.ts

@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type { ExtensionFqnParts } from "@agentxm/extension-model/unstable/extensions/common";
+import { type FrontmatterParseFailure } from "@agentxm/registry-protocol/unstable/content/frontmatter";
+import { NativeImportConflict, NativeImportFailed, NativeImportInvalid, NativeImportUnsupported } from "@agentxm/extension-workspace";
+export interface ImportNativeExtensionPackageArgs {
+    readonly sourcePath: string;
+    readonly targetDir: string;
+    readonly target: ExtensionFqnParts;
+}
+export type NativeImportError = NativeImportConflict | NativeImportFailed | NativeImportInvalid | NativeImportUnsupported | FrontmatterParseFailure;
+export declare const importNativeExtensionPackage: (args: ImportNativeExtensionPackageArgs) => Effect.Effect<void, NativeImportError, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=import-native-package.d.ts.map

package/dist/src/import-native-package.js

@@ -0,0 +1,135 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import YAML from "yaml";
+import { manifestFilenameForType, manifestSchemaForType, } from "@agentxm/registry-protocol/unstable/publish/manifest-policy";
+import { parseFrontmatterEffect, } from "@agentxm/registry-protocol/unstable/content/frontmatter";
+import { copyExtensionDirectory } from "@agentxm/extension-workspace";
+import { NativeImportConflict, NativeImportFailed, NativeImportInvalid, NativeImportUnsupported, } from "@agentxm/extension-workspace";
+const NATIVE_IMPORT_VERSION = "0.1.0";
+const MANIFEST_FILENAMES = new Set([
+    "skill.json",
+    "mcp.json",
+    "subagent.json",
+    "rule.json",
+    "hook.json",
+    "knowledge.json",
+    "pack.json",
+]);
+const mapWriteError = (detail) => (cause) => new NativeImportFailed({ detail, cause });
+const rewriteFrontmatterName = (filePath, name) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const content = yield* fs
+        .readFileString(filePath)
+        .pipe(Effect.mapError(mapWriteError(`Native content could not be read: ${filePath}`)));
+    const parsed = yield* parseFrontmatterEffect(content);
+    if (typeof parsed.frontmatter !== "object" || parsed.frontmatter === null) {
+        return yield* new NativeImportInvalid({
+            detail: `Native content must contain YAML frontmatter: ${filePath}`,
+        });
+    }
+    const frontmatter = { ...parsed.frontmatter, name };
+    const yaml = YAML.stringify(frontmatter, { lineWidth: 0 }).trim();
+    const body = parsed.body.startsWith("\n") ? parsed.body : `\n${parsed.body}`;
+    yield* fs
+        .writeFileString(filePath, `---\n${yaml}\n---${body}`)
+        .pipe(Effect.mapError(mapWriteError(`Native content could not be normalized: ${filePath}`)));
+});
+const selectMarkdownFile = (sourcePath, preferredName) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const inspectionFailed = mapWriteError(`Native source could not be inspected: ${sourcePath}`);
+    const stat = yield* fs.stat(sourcePath).pipe(Effect.mapError(inspectionFailed));
+    if (stat.type === "File")
+        return sourcePath;
+    if (stat.type !== "Directory") {
+        return yield* new NativeImportInvalid({
+            detail: `Native source must be a Markdown file or directory: ${sourcePath}`,
+        });
+    }
+    const entries = yield* fs.readDirectory(sourcePath).pipe(Effect.mapError(inspectionFailed));
+    const preferred = [`${preferredName}.md`, preferredName, "SKILL.md", "RULE.md"]
+        .map((name) => entries.find((entry) => entry === name))
+        .find((entry) => entry !== undefined);
+    if (preferred !== undefined)
+        return path.join(sourcePath, preferred);
+    const markdown = entries.filter((entry) => entry.toLowerCase().endsWith(".md") && entry.toLowerCase() !== "readme.md");
+    if (markdown.length !== 1 || markdown[0] === undefined) {
+        return yield* new NativeImportInvalid({
+            detail: `Native source must contain exactly one unambiguous Markdown document: ${sourcePath}`,
+        });
+    }
+    return path.join(sourcePath, markdown[0]);
+});
+const rejectManagedPackage = (sourcePath) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const inspectionFailed = mapWriteError(`Native source could not be inspected: ${sourcePath}`);
+    const stat = yield* fs.stat(sourcePath).pipe(Effect.mapError(inspectionFailed));
+    const directory = stat.type === "Directory" ? sourcePath : path.dirname(sourcePath);
+    const entries = yield* fs.readDirectory(directory).pipe(Effect.mapError(inspectionFailed));
+    const manifest = entries.find((entry) => MANIFEST_FILENAMES.has(entry));
+    if (manifest !== undefined) {
+        return yield* new NativeImportInvalid({
+            detail: `Source is already a managed AXM package (${manifest}); use fork instead of import`,
+        });
+    }
+});
+export const importNativeExtensionPackage = (args) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const importFailed = mapWriteError(`Native import failed for ${args.sourcePath}`);
+    if (args.target.type !== "skill" && args.target.type !== "subagent") {
+        return yield* new NativeImportUnsupported({ type: args.target.type });
+    }
+    yield* rejectManagedPackage(args.sourcePath);
+    if (yield* fs.exists(args.targetDir).pipe(Effect.mapError(importFailed))) {
+        return yield* new NativeImportConflict({ targetDir: args.targetDir });
+    }
+    yield* fs
+        .makeDirectory(args.targetDir, { recursive: true })
+        .pipe(Effect.mapError(mapWriteError(`Import target could not be created: ${args.targetDir}`)));
+    switch (args.target.type) {
+        case "skill": {
+            const stat = yield* fs.stat(args.sourcePath).pipe(Effect.mapError(importFailed));
+            if (stat.type === "Directory") {
+                yield* copyExtensionDirectory(args.sourcePath, path.join(args.targetDir, "src")).pipe(Effect.mapError(mapWriteError("Native skill content could not be copied")));
+            }
+            else {
+                yield* fs
+                    .makeDirectory(path.join(args.targetDir, "src"), { recursive: true })
+                    .pipe(Effect.mapError(importFailed));
+                yield* fs
+                    .copyFile(args.sourcePath, path.join(args.targetDir, "src", "SKILL.md"))
+                    .pipe(Effect.mapError(mapWriteError("Native skill document could not be copied")));
+            }
+            yield* rewriteFrontmatterName(path.join(args.targetDir, "src", "SKILL.md"), args.target.name);
+            break;
+        }
+        case "subagent": {
+            yield* fs
+                .makeDirectory(path.join(args.targetDir, "src"), { recursive: true })
+                .pipe(Effect.mapError(importFailed));
+            const sourceFile = yield* selectMarkdownFile(args.sourcePath, args.target.name);
+            const targetFile = path.join(args.targetDir, "src", `${args.target.name}.md`);
+            yield* fs
+                .copyFile(sourceFile, targetFile)
+                .pipe(Effect.mapError(mapWriteError("Native subagent document could not be copied")));
+            yield* rewriteFrontmatterName(targetFile, args.target.name);
+            break;
+        }
+    }
+    const manifest = {
+        $schema: `https://axm.sh/schemas/${manifestFilenameForType(args.target.type).replace(".json", ".schema.json")}`,
+        owner: args.target.owner,
+        type: args.target.type,
+        name: args.target.name,
+        version: NATIVE_IMPORT_VERSION,
+    };
+    yield* Schema.decodeUnknownEffect(manifestSchemaForType(args.target.type))(manifest).pipe(Effect.mapError((cause) => new NativeImportInvalid({ detail: "Imported package manifest is invalid", cause })));
+    yield* fs
+        .writeFileString(path.join(args.targetDir, manifestFilenameForType(args.target.type)), `${JSON.stringify(manifest, null, 2)}\n`)
+        .pipe(Effect.mapError(mapWriteError("Imported package manifest could not be written")));
+});
+//# sourceMappingURL=import-native-package.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extension-authoring feature: new-extension scaffolding, fork, native
+ * import, authored identity decoding, and authored pack membership. The
+ * application supplies the failure adapter that serializes authoring
+ * failures into the plan-step vocabulary.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AuthoringFailed } from "./errors.js";
+export { AuthoringFailureAdapter, withAdaptedStepFailures, type AuthoringFailureAdapterService, } from "./failure-adapter.js";
+export { decodeDesiredExtensionIdentity, type DecodedDesiredExtensionIdentity, type DesiredPackageAuthority, } from "./desired-identity.js";
+export { forkExtensionPackage, type ForkExtensionPackageArgs } from "./fork-package.js";
+export { importNativeExtensionPackage, type ImportNativeExtensionPackageArgs, type NativeImportError, } from "./import-native-package.js";
+export { preflightCreateOnly, type CreateOnlyPreflightArgs } from "./create-preflight.js";
+export { markerFqnForRef, type MarkerFqnRef } from "./marker-fqn.js";
+export { newSkill, type NewSkillOperation, type NewSkillOperationArgs, } from "./skills/new-skill.js";
+export { newHook, type NewHookOperation, type NewHookOperationArgs } from "./hooks/new-hook.js";
+export { newPack, type NewPackOperation, type NewPackOperationArgs } from "./packs/new-pack.js";
+export { addToPack, type AddToPackOperation, type AddToPackOperationArgs, } from "./packs/add-to-pack.js";
+export { removeFromPack, type RemoveFromPackOperation, type RemoveFromPackOperationArgs, } from "./packs/remove-from-pack.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,24 @@
+/**
+ * Extension-authoring feature: new-extension scaffolding, fork, native
+ * import, authored identity decoding, and authored pack membership. The
+ * application supplies the failure adapter that serializes authoring
+ * failures into the plan-step vocabulary.
+ *
+ * @experimental All exports from this module are unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { AuthoringFailed } from "./errors.js";
+export { AuthoringFailureAdapter, withAdaptedStepFailures, } from "./failure-adapter.js";
+export { decodeDesiredExtensionIdentity, } from "./desired-identity.js";
+export { forkExtensionPackage } from "./fork-package.js";
+export { importNativeExtensionPackage, } from "./import-native-package.js";
+export { preflightCreateOnly } from "./create-preflight.js";
+export { markerFqnForRef } from "./marker-fqn.js";
+// Scaffolding operations
+export { newSkill, } from "./skills/new-skill.js";
+export { newHook } from "./hooks/new-hook.js";
+export { newPack } from "./packs/new-pack.js";
+// Authored pack membership operations
+export { addToPack, } from "./packs/add-to-pack.js";
+export { removeFromPack, } from "./packs/remove-from-pack.js";
+//# sourceMappingURL=index.js.map

package/dist/src/marker-fqn.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helpers for managed-region marker extension identifiers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { ExtensionName, ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+export type MarkerFqnRef = {
+    readonly refType: "registry" | "workspace";
+    readonly owner: Handle;
+} | {
+    readonly refType: "git-hosted" | "local";
+};
+export declare const markerFqnForRef: (args: {
+    readonly ref: MarkerFqnRef;
+    readonly manifest: {
+        readonly owner: Handle;
+        readonly name: ExtensionName;
+    };
+    readonly type: ExtensionType;
+    readonly name: ExtensionName;
+}) => string;
+//# sourceMappingURL=marker-fqn.d.ts.map

package/dist/src/marker-fqn.js

@@ -0,0 +1,10 @@
+/**
+ * Helpers for managed-region marker extension identifiers.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { formatFqn } from "@agentxm/extension-model/unstable/extensions/fqn";
+export const markerFqnForRef = (args) => args.ref.refType === "registry" || args.ref.refType === "workspace"
+    ? formatFqn({ owner: args.ref.owner, type: args.type, name: args.name })
+    : formatFqn({ owner: args.manifest.owner, type: args.type, name: args.manifest.name });
+//# sourceMappingURL=marker-fqn.js.map

package/dist/src/packs/add-to-pack.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Add-to-pack operation — applies a precomputed manifest-add delta to a pack manifest.
+ *
+ * Validates manifest precondition (stale check) before writing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import { AuthoringFailureAdapter } from "../failure-adapter.js";
+import type { Handle } from "@agentxm/extension-model/unstable/extensions";
+import type { OperationHandler } from "@agentxm/workspace-operations";
+import type { Operation } from "@agentxm/workspace-operations";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+/**
+ * Args for the add-to-pack operation.
+ */
+export interface AddToPackOperationArgs {
+    /** Pack name (without owner). */
+    readonly packName: string;
+    /** Pack owner (e.g., "@myorg"). */
+    readonly packOwner: Handle;
+    /** Precomputed manifest delta: FQN -> version range entries to add. */
+    readonly additions: Readonly<Record<string, string>>;
+    /** Manifest content hash at plan time for stale-check. */
+    readonly manifestHash: string;
+}
+/**
+ * Add extensions to a pack manifest.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type AddToPackOperation = Operation<"add-to-pack", AddToPackOperationArgs>;
+/**
+ * Add-to-pack operation handler.
+ *
+ * 1. Short-circuit if additions map is empty (no-op)
+ * 2. Read current manifest and compute hash
+ * 3. Compare hash with args.manifestHash (stale check)
+ * 4. Apply additions to manifest
+ * 5. Write updated manifest
+ */
+export declare const addToPack: OperationHandler<AddToPackOperation, FileSystem.FileSystem | Path.Path | WorkspaceMutations | AuthoringFailureAdapter>;
+//# sourceMappingURL=add-to-pack.d.ts.map

package/dist/src/packs/add-to-pack.js

@@ -0,0 +1,147 @@
+/**
+ * Add-to-pack operation — applies a precomputed manifest-add delta to a pack manifest.
+ *
+ * Validates manifest precondition (stale check) before writing.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { AuthoringFailed } from "../errors.js";
+import { AuthoringFailureAdapter, withAdaptedStepFailures } from "../failure-adapter.js";
+import { WorkspaceMutations } from "@agentxm/workspace-state";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { PACK_MANIFEST_FILENAME, PackManifestSchema, } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+import { packManifestArtifact } from "./artifact.js";
+import { hashContent } from "./hash-content.js";
+// -----------------------------------------------------------------------------
+// Public API
+// -----------------------------------------------------------------------------
+/**
+ * Add-to-pack operation handler.
+ *
+ * 1. Short-circuit if additions map is empty (no-op)
+ * 2. Read current manifest and compute hash
+ * 3. Compare hash with args.manifestHash (stale check)
+ * 4. Apply additions to manifest
+ * 5. Write updated manifest
+ */
+export const addToPack = (op) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const ws = yield* WorkspaceMutations;
+    if (ws.layout.scope !== "project") {
+        return yield* new AuthoringFailed({
+            category: "validation",
+            detail: "Authored packs can only be edited in a project workspace",
+        });
+    }
+    const { packName, packOwner, additions, manifestHash } = op.args;
+    const configured = (yield* ws.getConfiguredPackEntries())[packName];
+    if (configured === undefined || !isWorkspaceSourceLocator(configured.source)) {
+        return yield* new AuthoringFailed({
+            category: "conflict",
+            detail: `Pack "${packName}" is not an authored workspace pack`,
+            recover: "Only workspace-authored packs can be edited in place.",
+        });
+    }
+    // 1. Short-circuit if nothing to add
+    if (Object.keys(additions).length === 0) {
+        return { result: "success", message: "No pack entries added" };
+    }
+    const manifestPath = path.join(ws.layout.authoredRoot("pack"), packName, PACK_MANIFEST_FILENAME);
+    yield* ws.runTransaction({
+        targets: [manifestPath],
+        transition: Effect.gen(function* () {
+            // Read and stale-check under the workspace lock.
+            const manifestContent = yield* fs.readFileString(manifestPath).pipe(Effect.mapError((e) => new AuthoringFailed({
+                category: "not_found",
+                detail: `Pack manifest not found at ${manifestPath}`,
+                suggestions: [{ description: "Ensure the pack exists on disk" }],
+                cause: e,
+            })));
+            // 3. Stale-check: compare content hash
+            const currentHash = hashContent(manifestContent);
+            if (currentHash !== manifestHash) {
+                return yield* new AuthoringFailed({
+                    category: "conflict",
+                    detail: `Pack manifest is stale — it was modified since the plan was created`,
+                    suggestions: [{ description: "Re-run the command to create a fresh plan" }],
+                });
+            }
+            // 4. Parse and apply additions
+            const json = yield* Effect.try({
+                try: () => {
+                    const parsed = JSON.parse(manifestContent);
+                    return parsed;
+                },
+                catch: (e) => new AuthoringFailed({
+                    category: "validation",
+                    detail: `Failed to parse pack manifest: ${manifestPath}`,
+                    cause: e,
+                }),
+            });
+            const manifest = yield* Schema.decodeUnknownEffect(PackManifestSchema)(json).pipe(Effect.mapError((e) => new AuthoringFailed({
+                category: "validation",
+                detail: `Invalid pack manifest: ${manifestPath}`,
+                cause: e,
+            })));
+            const dependencies = { ...manifest.dependencies };
+            for (const [fqn, version] of Object.entries(additions)) {
+                dependencies[fqn] = version;
+            }
+            const updatedManifest = {
+                ...manifest,
+                owner: manifest.owner,
+                type: manifest.type,
+                name: manifest.name,
+                version: manifest.version,
+                dependencies,
+            };
+            const validatedUpdatedManifest = yield* Schema.decodeUnknownEffect(PackManifestSchema)(updatedManifest).pipe(Effect.mapError((cause) => new AuthoringFailed({
+                category: "validation",
+                detail: `Updated pack manifest is invalid: ${manifestPath}`,
+                cause,
+            })));
+            // 5. Write updated manifest
+            yield* fs
+                .writeFileString(manifestPath, JSON.stringify(validatedUpdatedManifest, null, 2) + "\n")
+                .pipe(Effect.mapError((e) => new AuthoringFailed({
+                category: "internal",
+                detail: `Failed to write pack manifest: ${manifestPath}`,
+                cause: e,
+            })));
+        }),
+        validate: () => fs.readFileString(manifestPath).pipe(Effect.flatMap((content) => Effect.try({
+            try: () => JSON.parse(content),
+            catch: (cause) => new AuthoringFailed({
+                category: "validation",
+                detail: `Updated pack manifest could not be parsed: ${manifestPath}`,
+                cause,
+            }),
+        })), Effect.flatMap(Schema.decodeUnknownEffect(PackManifestSchema)), Effect.flatMap((manifest) => Object.entries(additions).every(([fqn, constraint]) => manifest.dependencies[fqn] === constraint)
+            ? Effect.void
+            : new AuthoringFailed({
+                category: "internal",
+                detail: `Updated pack manifest did not retain the requested dependencies`,
+            })), Effect.mapError((cause) => new AuthoringFailed({
+            category: "validation",
+            detail: `Updated pack manifest failed postcondition validation`,
+            cause,
+        }))),
+    });
+    return {
+        result: "success",
+        message: `Added ${Object.keys(additions).length} extension${Object.keys(additions).length === 1 ? "" : "s"} to pack`,
+        artifact: packManifestArtifact({
+            owner: packOwner,
+            name: packName,
+            scope: ws.scope,
+            change: "updated",
+            fileCount: 1,
+        }),
+    };
+}).pipe(withAdaptedStepFailures);
+//# sourceMappingURL=add-to-pack.js.map

package/dist/src/packs/artifact.d.ts

@@ -0,0 +1,13 @@
+import type { Handle } from "@agentxm/extension-model/unstable/extensions";
+import type { JobStepArtifact, JobStepArtifactTarget } from "@agentxm/workspace-operations";
+export declare const packManifestPath: (scope: JobStepArtifact["scope"], owner: Handle, name: string) => string;
+export declare const packManifestTarget: (scope: JobStepArtifact["scope"], owner: Handle, name: string, change: JobStepArtifactTarget["change"]) => JobStepArtifactTarget;
+export declare const packManifestArtifact: (args: {
+    readonly owner: Handle;
+    readonly name: string;
+    readonly scope: JobStepArtifact["scope"];
+    readonly change: JobStepArtifact["change"];
+    readonly version?: string;
+    readonly fileCount?: number;
+}) => JobStepArtifact;
+//# sourceMappingURL=artifact.d.ts.map

package/dist/src/packs/artifact.js

@@ -0,0 +1,17 @@
+import { PACK_MANIFEST_FILENAME } from "@agentxm/extension-model/unstable/packs/manifest-schema";
+export const packManifestPath = (scope, owner, name) => scope === "project"
+    ? `packs/${name}/${PACK_MANIFEST_FILENAME}`
+    : `.axm/workspace/agent_extensions/${owner}/packs/${name}/${PACK_MANIFEST_FILENAME}`;
+export const packManifestTarget = (scope, owner, name, change) => ({
+    path: packManifestPath(scope, owner, name),
+    change,
+});
+export const packManifestArtifact = (args) => ({
+    path: packManifestPath(args.scope, args.owner, args.name),
+    scope: args.scope,
+    change: args.change,
+    ...(args.version === undefined ? {} : { version: args.version }),
+    ...(args.fileCount === undefined ? {} : { fileCount: args.fileCount }),
+    targets: [packManifestTarget(args.scope, args.owner, args.name, args.change)],
+});
+//# sourceMappingURL=artifact.js.map

package/dist/src/packs/hash-content.d.ts

@@ -0,0 +1,2 @@
+export declare const hashContent: (content: string) => string;
+//# sourceMappingURL=hash-content.d.ts.map

package/dist/src/packs/hash-content.js

@@ -0,0 +1,3 @@
+import * as crypto from "node:crypto";
+export const hashContent = (content) => crypto.createHash("sha256").update(content).digest("hex");
+//# sourceMappingURL=hash-content.js.map