@codai/axiom-mcp 2.1.0 → 2.2.0

package/dist/axm-lazy.js

@@ -5809,18 +5809,26 @@ const ERROR_CODES = [
 	"ERR_PROVIDER_FAILED",
 	"ERR_GUARD_TIMEOUT",
 	"ERR_GUARD_OUTPUT",
+	"ERR_FACT_DISABLED",
 	"ERR_SIGNATURE_MISSING",
 	"ERR_SIGNATURE_INVALID",
+	"ERR_TRUST_STATE_CORRUPT",
 	"ERR_ROLLBACK",
 	"ERR_EMITTER_UNKNOWN",
 	"ERR_TEMPLATE_UNKNOWN",
 	"ERR_TEMPLATE_PARAMS",
+	"ERR_PATCH_FORMAT",
+	"ERR_PATCH_PREIMAGE",
+	"ERR_PATCH_NO_MATCH",
 	"ERR_GIT_NOT_FOUND",
 	"ERR_GIT_NOT_REPO",
 	"ERR_GIT_DIRTY",
 	"ERR_GIT_BRANCH_EXISTS",
 	"ERR_GIT_BRANCH_INVALID",
 	"ERR_GIT_FAILED",
+	"ERR_TASK_NOT_FOUND",
+	"ERR_TASK_CANCELLED",
+	"ERR_PLAN_SESSION_STATE",
 	"ERR_REF_OFFLINE",
 	"ERR_NET_DISABLED",
 	"ERR_NET_DENIED",
@@ -5919,7 +5927,18 @@ object({
 	/** sha256(JCS(all facts)) → replayable. */
 	factsDigest: DigestRefSchema,
 	durationMs: int().nonnegative(),
-	providers: array(ProviderStatusSchema)
+	providers: array(ProviderStatusSchema),
+	/**
+	* S-402: how the manifest's `preImage` related to the tree at check time.
+	* `verified` = every entry matched; `drifted` = at least one differed (an `error`
+	* finding `ERR_PREIMAGE_CHANGED` is also emitted); `unverified` = no root, or the
+	* manifest carries no `preImage`.
+	*/
+	preImage: _enum([
+		"verified",
+		"drifted",
+		"unverified"
+	]).optional()
 }).strict();
 const ApiVersionSchema = literal("axiom.dev/v2");
 /** Per-blob inline limit: 256 KiB of string content (≈192 KiB decoded when base64). */
@@ -5959,7 +5978,18 @@ const PlanArtifactSourceSchema = discriminatedUnion("type", [
 		emitter: string().min(1),
 		template: string().min(1),
 		params: record(string(), json()).default({})
-	}).strict().describe("v2.1")
+	}).strict().describe("template source rendered by a registered emitter at compile time"),
+	object({
+		type: literal("patch"),
+		format: _enum([
+			"unified",
+			"v4a",
+			"search-replace"
+		]),
+		/** sha256 of the file the patch was authored against, or `absent` for a new file. */
+		preImage: union([DigestRefSchema, literal("absent")]),
+		body: string().max(INLINE_CONTENT_MAX)
+	}).strict().describe("patch applied at compile time to the pre-image named by its digest")
 ]);
 const PlanArtifactSchema = object({
 	path: RelPathSchema,
@@ -6039,6 +6069,11 @@ object({
 	/** Path of `.axiom/journal/<digest>.json`. */
 	journal: string().optional(),
 	git: GitResultSchema.optional(),
+	/**
+	* Re-apply of an already-applied digest whose files no longer matched on disk:
+	* the artifacts listed here were re-written over foreign changes (design §apply).
+	*/
+	drifted: array(RelPathSchema).optional(),
 	error: ApplyErrorSchema.optional()
 }).strict().superRefine((r, ctx) => {
 	if (r.status === "failed" && r.error === void 0) ctx.addIssue({
@@ -6105,7 +6140,8 @@ const ManifestArtifactSchema = object({
 		"inline",
 		"template",
 		"cas",
-		"ref"
+		"ref",
+		"patch"
 	]).optional()
 }).strict().superRefine((a, ctx) => {
 	if (a.op !== "delete" && a.digest === void 0) ctx.addIssue({
@@ -6119,6 +6155,15 @@ const ToolchainSchema = object({
 	axiom: string().min(1),
 	emitters: record(string(), string())
 }).strict();
+/**
+* What compile saw on disk for one artifact path (S-402): the sha256 of the existing file
+* or `absent`. Binds a manifest — and every CheckReport/attestation over it — to the tree
+* it was produced against; `apply` refuses a different tree with `ERR_PREIMAGE_CHANGED`.
+*/
+const PreImageEntrySchema = object({
+	path: RelPathSchema,
+	sha256: union([Sha256HexSchema, literal("absent")])
+}).strict();
 /** The exact object that is JCS-canonicalised and sha256-hashed into `manifestDigest`. */
 const ManifestBodySchema = object({
 	apiVersion: ApiVersionSchema,
@@ -6136,8 +6181,20 @@ const ManifestBodySchema = object({
 	* Anti-rollback counter (D-16): monotonic per root, part of the canonical body so a
 	* signature binds it. Verified by `manifest.requireSigned { antiRollback: true }`.
 	*/
-	counter: int().nonnegative().optional()
+	counter: int().nonnegative().optional(),
+	/**
+	* Pre-image of every artifact path at compile time (S-402), sorted by path, unique;
+	* present when compile had a root (or a pre-image reader). Part of the canonical body:
+	* the same Plan compiled against a different tree is a different manifest.
+	*/
+	preImage: array(PreImageEntrySchema).optional()
 }).strict().superRefine((m, ctx) => {
+	if (m.preImage !== void 0 && !isSortedUnique(m.preImage.map((p) => p.path))) ctx.addIssue({
+		code: "custom",
+		path: ["preImage"],
+		message: "preImage must be sorted by path (UTF-8 byte order) and unique",
+		params: { code: "ERR_NOT_CANONICAL" }
+	});
 	if (!isSortedUnique(m.artifacts.map((a) => a.path))) ctx.addIssue({
 		code: "custom",
 		path: ["artifacts"],
@@ -6180,12 +6237,24 @@ const DsseEnvelopeSchema = object({
 		sig: base64()
 	}).strict())
 }).strict();
+/** DSSE payloadType of a signed `ManifestBody` (D-16). */
+const AXIOM_MANIFEST_PAYLOAD_TYPE = "application/vnd.axiom.manifest+json";
+/**
+* DSSE payloadType of a **root-bound** signature (S-409): the payload is
+* `JCS({ manifest, rootId })`, so the same key's signature over the same manifest is not
+* valid for a root whose trust store declares a different `rootId`.
+*/
+const AXIOM_MANIFEST_BOUND_PAYLOAD_TYPE = "application/vnd.axiom.manifest-bound+json";
+/** Operator-chosen root identity, e.g. `github:dragoscv/brivio` or a UUID. */
+const RootIdSchema = string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/@-]*$/, "rootId: letters, digits, . _ : / @ - only");
 /**
 * DSSE envelope whose payload is `base64(JCS(manifest))`, signed with Ed25519 (D-16).
 * Lives outside the canonical body: `manifestDigest` is unchanged whether signed or not.
+* With `payloadType` = `AXIOM_MANIFEST_BOUND_PAYLOAD_TYPE` the payload is
+* `base64(JCS({ manifest, rootId }))` (S-409).
 */
 const ManifestSignatureSchema = object({
-	payloadType: literal("application/vnd.axiom.manifest+json"),
+	payloadType: union([literal(AXIOM_MANIFEST_PAYLOAD_TYPE), literal(AXIOM_MANIFEST_BOUND_PAYLOAD_TYPE)]),
 	payload: base64(),
 	signatures: array(object({
 		keyid: string().optional(),
@@ -6207,13 +6276,24 @@ object({
 	version: literal(1),
 	keys: array(TrustedKeySchema),
 	/** Floor for `counter` when no state has been recorded yet. */
-	minCounter: int().nonnegative().optional()
+	minCounter: int().nonnegative().optional(),
+	/**
+	* When set, only root-bound signatures carrying this exact id count (S-409): an
+	* unbound or differently-bound envelope is `signature.unbound`. Absent → both accepted.
+	*/
+	rootId: RootIdSchema.optional()
 }).strict();
 object({
 	version: literal(1),
 	lastCounter: int().nonnegative(),
 	/** Digest of the manifest that advanced `lastCounter` (informational). */
-	manifestDigest: DigestRefSchema.optional()
+	manifestDigest: DigestRefSchema.optional(),
+	/**
+	* HMAC-SHA256 (hex) over `JCS(state without mac)` keyed by `.axiom/trust/state.key`
+	* (S-409). Written by every `advanceTrustState`; a state with a key on disk but a
+	* missing/wrong mac is `ERR_TRUST_STATE_CORRUPT`.
+	*/
+	mac: string().regex(/^[0-9a-f]{64}$/).optional()
 }).strict();
 object({
 	manifest: ManifestBodySchema,
@@ -12146,6 +12226,7 @@ const ModeKw = keyword("ModeKw", "mode");
 const OpKw = keyword("OpKw", "op");
 const Inline = keyword("Inline", "inline");
 const Template = keyword("Template", "template");
+const Patch = keyword("Patch", "patch");
 const Cas = keyword("Cas", "cas");
 const Ref = keyword("Ref", "ref");
 const Check = keyword("Check", "check");
@@ -12322,6 +12403,7 @@ const allTokens = [
 	OpKw,
 	Inline,
 	Template,
+	Patch,
 	Cas,
 	Ref,
 	Check,
@@ -12594,6 +12676,26 @@ var Compiler = class {
 				params: params ?? {}
 			};
 		}
+		const patch = first(nodes(ctx, "patchSource"));
+		if (patch !== void 0) {
+			const pc = patch.children;
+			const f = first(tokens(pc, "format"));
+			const d = first(tokens(pc, "preImage"));
+			const ab = first(tokens(pc, "absent"));
+			const h = first(tokens(pc, "body"));
+			this.at(`${path}.format`, tokenRange(f));
+			this.at(`${path}.preImage`, tokenRange(d ?? ab ?? f));
+			this.at(`${path}.body`, tokenRange(h));
+			if (ab !== void 0 && ab.image !== "absent") this.error("patch pre-image must be a \"sha256:…\" digest or the word absent", tokenRange(ab));
+			const payload = h?.payload;
+			const body = payload === void 0 ? "" : `${payload.content}\n`;
+			return {
+				type: "patch",
+				format: f?.image ?? "",
+				preImage: d !== void 0 ? decodeString(d.image) : "absent",
+				body
+			};
+		}
 	}
 	check(n, path) {
 		const ctx = n.children;
@@ -12667,7 +12769,8 @@ function compileCst(file) {
 *   PlanItem    = "intent" String | "profile" Ident | "capabilities" "[" [Cap {"," Cap}] "]"
 *               | "artifact" String ArtifactBody | "check" Ident "using" QualIdent [Json] | "meta" Json ;
 *   ArtifactBody= "{", { "mode" Mode | "op" Op | Source }, "}" ;
-*   Source      = "inline" HereDoc | "template" QualIdent String [Json] | "cas" Digest | "ref" String Digest ;
+*   Source      = "inline" HereDoc | "template" QualIdent String [Json] | "cas" Digest | "ref" String Digest
+*               | "patch" Format ( Digest | "absent" ) HereDoc ;      Format = unified | v4a | search-replace
 *   QualIdent   = Ident, { ".", Ident } ;
 */
 var AxmParser = class extends CstParser {
@@ -12749,9 +12852,16 @@ var AxmParser = class extends CstParser {
 			{ ALT: () => this.SUBRULE(this.inlineSource) },
 			{ ALT: () => this.SUBRULE(this.templateSource) },
 			{ ALT: () => this.SUBRULE(this.casSource) },
-			{ ALT: () => this.SUBRULE(this.refSource) }
+			{ ALT: () => this.SUBRULE(this.refSource) },
+			{ ALT: () => this.SUBRULE(this.patchSource) }
 		]);
 	});
+	patchSource = this.RULE("patchSource", () => {
+		this.CONSUME(Patch);
+		this.CONSUME(IdentLike, { LABEL: "format" });
+		this.OR([{ ALT: () => this.CONSUME(Digest, { LABEL: "preImage" }) }, { ALT: () => this.CONSUME2(IdentLike, { LABEL: "absent" }) }]);
+		this.CONSUME(HereDoc, { LABEL: "body" });
+	});
 	inlineSource = this.RULE("inlineSource", () => {
 		this.CONSUME(Inline);
 		this.CONSUME(HereDoc, { LABEL: "content" });