archctx 0.4.0 → 0.4.1

package/assets/catalog.yaml

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "archcontext.practice-catalog-manifest/v1",
   "catalogVersion": "2026.06.0",
-  "productVersion": "0.4.0",
+  "productVersion": "0.4.1",
   "generatedAt": "1970-01-01T00:00:00.000Z",
   "entries": [
     {
@@ -389,5 +389,5 @@
     "structurizr.dsl",
     "twelve-factor"
   ],
-  "catalogDigest": "sha256:61835a0efb9c5a19cb4fd16482026918785d01b94b6e60f2c2a06b64a4c713be"
+  "catalogDigest": "sha256:4d9f972043884502bdfc43a81b7f351df59a5f2af0231529fcdb49490bbf25d7"
 }

package/bin/archctx.mjs

@@ -783,7 +783,11 @@ function archctxCapabilities(packageVersion) {
 function projectionRequestInvariantIssues(input) {
   const issues = [
     ...sortedUniqueIssues("targets", input.targets),
-    ...sortedUniqueIssues("changedPaths", input.changedPaths)
+    ...sortedUniqueIssues("changedPaths", input.changedPaths),
+    ...input.acceptedChange ? [
+      ...sortedUniqueIssues("acceptedChange.reasonCodes", input.acceptedChange.reasonCodes),
+      ...sortedUniqueIssues("acceptedChange.affectedNodeIds", input.acceptedChange.affectedNodeIds)
+    ] : []
   ];
   if (input.targets.length === 0)
     issues.push("targets must contain at least one projection target");
@@ -793,6 +797,25 @@ function projectionRequestInvariantIssues(input) {
     issues.push("adoptionPlanId is required when mode=adopt");
   if (input.mode !== "adopt" && input.adoptionPlanId !== undefined)
     issues.push("adoptionPlanId is only allowed when mode=adopt");
+  if (input.acceptedChange) {
+    if (input.acceptedChange.changeSetId.trim() === "")
+      issues.push("acceptedChange.changeSetId must not be empty");
+    if (input.acceptedChange.eventId.trim() === "")
+      issues.push("acceptedChange.eventId must not be empty");
+    if (input.acceptedChange.reasonCodes.length === 0)
+      issues.push("acceptedChange.reasonCodes must contain at least one reason");
+    if (input.acceptedChange.affectedNodeIds.length === 0)
+      issues.push("acceptedChange.affectedNodeIds must contain at least one node");
+    const allowedReasons = new Set(ARCHITECTURE_MAJOR_CHANGE_REASON_CODES);
+    for (const reason of input.acceptedChange.reasonCodes) {
+      if (!allowedReasons.has(reason))
+        issues.push(`acceptedChange.reasonCodes contains unsupported reason: ${reason}`);
+    }
+    for (const nodeId of input.acceptedChange.affectedNodeIds) {
+      if (nodeId.trim() === "")
+        issues.push("acceptedChange.affectedNodeIds must not contain empty node ids");
+    }
+  }
   return issues;
 }
 function projectionResultInvariantIssues(input) {
@@ -977,7 +1000,7 @@ function productVersionManifest() {
     }
   };
 }
-var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.4.0", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.3.10", ARCHCONTEXT_NODE_RANGE = ">=24 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
+var ARCHCONTEXT_PRODUCT_NAME = "archctx", ARCHCONTEXT_PRODUCT_VERSION = "0.4.1", ARCHCONTEXT_PACKAGE_MANAGER = "bun@1.3.10", ARCHCONTEXT_NODE_RANGE = ">=24 <26", LOCAL_RUNTIME_RPC_SCHEMA_VERSION = "archcontext.runtime-rpc/v1", ARCHCONTEXT_SCHEMA_SET_VERSION = "2026-07-11.explorer-view-v2";
 
 // packages/contracts/src/validator.ts
 function validateJsonSchema(schema, value) {
@@ -40285,9 +40308,11 @@ async function runArchitectureDocsProjectionCommand(args2, cwd, daemon) {
   const generatedAt = readFlag(args2, "--generated-at") ?? new Date(0).toISOString();
   let profile;
   let projection3;
+  let acceptedChange;
   try {
     profile = architectureProjectionProfile(args2);
-    projection3 = buildArchitectureDocsProjection(root, generatedAt, profile, undefined, acceptedArchitectureChange(args2));
+    acceptedChange = acceptedArchitectureChange(args2);
+    projection3 = buildArchitectureDocsProjection(root, generatedAt, profile, undefined, acceptedChange);
   } catch (error) {
     return errorEnvelope(`docs.${subcommand}`, "AC_PRECONDITION_FAILED", error instanceof Error ? error.message : String(error));
   }
@@ -40320,7 +40345,7 @@ async function runArchitectureDocsProjectionCommand(args2, cwd, daemon) {
     });
   }
   if (subcommand === "adopt") {
-    return runArchitectureDocsAdoptionCommand(args2, root, daemon, projection3, profile, generatedAt);
+    return runArchitectureDocsAdoptionCommand(args2, root, daemon, projection3, profile, generatedAt, acceptedChange);
   }
   if (projection3.plan.rejected.length > 0) {
     return errorEnvelope("docs.plan", "AC_PRECONDITION_FAILED", `Architecture documentation projection requires explicit adoption or ownership repair: ${projection3.plan.rejected.map((diff) => `${diff.path} (${diff.reasonCode})`).join(", ")}`);
@@ -40415,7 +40440,7 @@ function buildArchitectureDocsProjection(root, generatedAt, profile = "default",
     generatedAt,
     refreshContext: {
       repositoryId: repositoryFingerprint(root),
-      workspaceId: `workspace.${digestJson({ root }).replace(/^sha256:/, "").slice(0, 16)}`,
+      workspaceId: projectionWorkspaceId(root),
       headSha: provenance.baseHeadSha,
       worktreeDigest: provenance.worktreeDigest,
       ...acceptedChange ? { acceptedChange } : {}
@@ -40456,7 +40481,7 @@ function architectureProjectionProfile(args2) {
   }
   return profile;
 }
-async function runArchitectureDocsAdoptionCommand(args2, root, daemon, projection3, profile, generatedAt) {
+async function runArchitectureDocsAdoptionCommand(args2, root, daemon, projection3, profile, generatedAt, acceptedChange) {
   if (profile !== REPO_HARNESS_PROJECTION_PROFILE) {
     return errorEnvelope("docs.adopt", "AC_SCHEMA_INVALID", `docs adopt requires --profile ${REPO_HARNESS_PROJECTION_PROFILE}`);
   }
@@ -40497,11 +40522,11 @@ async function runArchitectureDocsAdoptionCommand(args2, root, daemon, projectio
   const simulatedByPath = new Map(projection3.loaded.existingFiles.map((file) => [file.path, file]));
   for (const file of [...projection3.plan.files, ...adoption2.files])
     simulatedByPath.set(file.path, file);
-  const canonicalFirst = buildArchitectureDocsProjection(root, generatedAt, profile, [...simulatedByPath.values()]);
+  const canonicalFirst = buildArchitectureDocsProjection(root, generatedAt, profile, [...simulatedByPath.values()], acceptedChange);
   const canonicalExistingByPath = new Map(simulatedByPath);
   for (const file of canonicalFirst.files)
     canonicalExistingByPath.set(file.path, file);
-  const canonical = buildArchitectureDocsProjection(root, generatedAt, profile, [...canonicalExistingByPath.values()]);
+  const canonical = buildArchitectureDocsProjection(root, generatedAt, profile, [...canonicalExistingByPath.values()], acceptedChange);
   if (!canonical.plan.drift.ok || canonical.plan.rejected.length > 0 || canonical.plan.projectionDigest !== canonicalFirst.plan.projectionDigest) {
     return errorEnvelope("docs.adopt", "AC_PRECONDITION_FAILED", "projection-adoption-fixed-point-unproven");
   }
@@ -40544,7 +40569,7 @@ async function runProjectionProtocolCommand(args2, cwd, daemon) {
   const generatedAt = new Date(0).toISOString();
   let projection3;
   try {
-    projection3 = buildArchitectureDocsProjection(root, generatedAt, REPO_HARNESS_PROJECTION_PROFILE);
+    projection3 = buildArchitectureDocsProjection(root, generatedAt, REPO_HARNESS_PROJECTION_PROFILE, undefined, request.acceptedChange);
     assertProjectionExpectedSnapshot(request, root, projection3);
   } catch (error) {
     return errorEnvelope("projection.run", "AC_PRECONDITION_FAILED", error instanceof Error ? error.message : String(error));
@@ -40565,12 +40590,12 @@ async function runProjectionProtocolCommand(args2, cwd, daemon) {
       expectedWorktreeDigest,
       "--task-session-id",
       request.requestId
-    ], root, daemon, projection3, REPO_HARNESS_PROJECTION_PROFILE, generatedAt);
+    ], root, daemon, projection3, REPO_HARNESS_PROJECTION_PROFILE, generatedAt, request.acceptedChange);
     if (!adopted.ok)
       return adopted;
     let output;
     try {
-      output = buildArchitectureDocsProjection(root, generatedAt, REPO_HARNESS_PROJECTION_PROFILE);
+      output = buildArchitectureDocsProjection(root, generatedAt, REPO_HARNESS_PROJECTION_PROFILE, undefined, request.acceptedChange);
       if (!output.plan.drift.ok || output.plan.rejected.length > 0) {
         return errorEnvelope("projection.run", "AC_PRECONDITION_FAILED", "projection adoption did not reach the architecture-docs fixed point");
       }
@@ -40632,14 +40657,35 @@ function parseProjectionProtocolRequest(raw) {
     throw new Error("projection request expected.headSha is invalid");
   if (typeof snapshot.worktreeDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(snapshot.worktreeDigest))
     throw new Error("projection request expected.worktreeDigest is invalid");
+  if (input.acceptedChange !== undefined)
+    validateProjectionAcceptedChange(input.acceptedChange);
   const request = input;
   const issues = projectionRequestInvariantIssues(request);
   if (issues.length > 0)
     throw new Error(`projection request invariant failed: ${issues.join("; ")}`);
   return request;
 }
+function validateProjectionAcceptedChange(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("projection request acceptedChange must be an object");
+  }
+  const accepted = value;
+  const supportedKeys = new Set(["changeSetId", "eventId", "reasonCodes", "affectedNodeIds"]);
+  const unsupportedKey = Object.keys(accepted).find((key) => !supportedKeys.has(key));
+  if (unsupportedKey)
+    throw new Error(`projection request acceptedChange contains unsupported property: ${unsupportedKey}`);
+  if (typeof accepted.changeSetId !== "string" || typeof accepted.eventId !== "string") {
+    throw new Error("projection request acceptedChange changeSetId and eventId are required");
+  }
+  if (!Array.isArray(accepted.reasonCodes) || accepted.reasonCodes.some((reason) => typeof reason !== "string")) {
+    throw new Error("projection request acceptedChange reasonCodes must be a string array");
+  }
+  if (!Array.isArray(accepted.affectedNodeIds) || accepted.affectedNodeIds.some((nodeId) => typeof nodeId !== "string")) {
+    throw new Error("projection request acceptedChange affectedNodeIds must be a string array");
+  }
+}
 function assertProjectionExpectedSnapshot(request, root, projection3) {
-  const workspaceId = `workspace.${digestJson({ root }).replace(/^sha256:/, "").slice(0, 16)}`;
+  const workspaceId = projectionWorkspaceId(root);
   const actual = {
     repositoryId: repositoryFingerprint(root),
     workspaceId,
@@ -40651,6 +40697,10 @@ function assertProjectionExpectedSnapshot(request, root, projection3) {
       throw new Error(`projection request expected snapshot mismatch: ${field}`);
   }
 }
+function projectionWorkspaceId(root) {
+  const canonicalRoot = canonicalRepositoryRoot(root);
+  return `workspace.${digestJson({ root: canonicalRoot }).replace(/^sha256:/, "").slice(0, 16)}`;
+}
 function projectionProtocolHumanStatus(request, projection3) {
   const humanSignal = projection3.plan.refreshSignals.some((signal) => signal.mode === "human-action-required");
   const adoption2 = projection3.plan.rejected.some((diff) => diff.reasonCode === "projection-adoption-required");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archctx",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Local architecture context CLI for agentic coding workflows.",
   "private": false,
   "type": "module",

package/schemas/runtime/projection-request.schema.json

@@ -24,7 +24,8 @@
       "items": { "$ref": "#/$defs/repoPath" }
     },
     "expected": { "$ref": "#/$defs/expectedSnapshot" },
-    "adoptionPlanId": { "type": "string", "pattern": "^adoption_plan\\.[a-zA-Z0-9_.-]+$" }
+    "adoptionPlanId": { "type": "string", "pattern": "^adoption_plan\\.[a-zA-Z0-9_.-]+$" },
+    "acceptedChange": { "$ref": "#/$defs/acceptedChange" }
   },
   "allOf": [
     {
@@ -46,6 +47,45 @@
         ]
       }
     },
+    "acceptedChange": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["changeSetId", "eventId", "reasonCodes", "affectedNodeIds"],
+      "properties": {
+        "changeSetId": { "type": "string", "minLength": 1 },
+        "eventId": { "type": "string", "minLength": 1 },
+        "reasonCodes": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "description": "Canonical wire order is lexicographic and is enforced by projectionRequestInvariantIssues.",
+          "items": {
+            "enum": [
+              "constraint-changed",
+              "entrypoint-changed",
+              "interface-changed",
+              "lifecycle-changed",
+              "node-added",
+              "node-moved",
+              "node-removed",
+              "node-renamed",
+              "ownership-changed",
+              "relation-changed",
+              "responsibility-changed",
+              "risk-boundary-changed",
+              "verified-flow-proof-changed"
+            ]
+          }
+        },
+        "affectedNodeIds": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "description": "Canonical wire order is lexicographic and is enforced by projectionRequestInvariantIssues.",
+          "items": { "type": "string", "minLength": 1 }
+        }
+      }
+    },
     "expectedSnapshot": {
       "type": "object",
       "additionalProperties": false,