archctx-contracts 0.2.2 → 0.4.0

package/src/projection.ts

@@ -0,0 +1,301 @@
+import { digestJson, type Json } from "./schema";
+
+export const PROJECTION_REQUEST_SCHEMA_VERSION = "archcontext.projection-request/v1" as const;
+export const PROJECTION_RESULT_SCHEMA_VERSION = "archcontext.projection-result/v1" as const;
+export const ARCHITECTURE_REFRESH_SIGNAL_SCHEMA_VERSION = "archcontext.architecture-refresh-signal/v1" as const;
+export const ARCHCTX_CAPABILITIES_SCHEMA_VERSION = "archcontext.capabilities/v1" as const;
+export const ARCHITECTURE_DOCS_RENDERER_VERSION = "archcontext.docs-renderer/v2" as const;
+export const AGENT_CONTEXT_RENDERER_VERSION = "archcontext.agent-context-renderer/v1" as const;
+
+export const PROJECTION_MODES = ["check", "plan", "apply", "adopt"] as const;
+export const PROJECTION_TARGETS = ["agent-context", "architecture-docs"] as const;
+export const PROJECTION_RESULT_STATUSES = [
+  "adoption-required",
+  "applied",
+  "blocked",
+  "human-action-required",
+  "noop",
+  "permanent-failure",
+  "planned",
+  "retryable-failure"
+] as const;
+export const PROJECTION_HUMAN_ACTION_REASON_CODES = [
+  "adoption-required",
+  "manual-region-conflict",
+  "target-collision",
+  "unprovable-required-flow",
+  "unresolved-major-change"
+] as const;
+export const ARCHITECTURE_MAJOR_CHANGE_REASON_CODES = [
+  "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"
+] as const;
+export const ARCHITECTURE_REFRESH_TARGETS = [
+  "architecture-contract-context",
+  "architecture-readiness",
+  "architecture-request-index",
+  "capability-context",
+  "capability-index"
+] as const;
+export const ARCHCTX_FEATURES = [
+  "architecture-docs-renderer-v2",
+  "architecture-refresh-signal-v1",
+  "projection-protocol-v1"
+] as const;
+
+export type ProjectionMode = (typeof PROJECTION_MODES)[number];
+export type ProjectionTarget = (typeof PROJECTION_TARGETS)[number];
+export type ProjectionResultStatus = (typeof PROJECTION_RESULT_STATUSES)[number];
+export type ProjectionHumanActionReasonCode = (typeof PROJECTION_HUMAN_ACTION_REASON_CODES)[number];
+export type ArchitectureMajorChangeReasonCode = (typeof ARCHITECTURE_MAJOR_CHANGE_REASON_CODES)[number];
+export type ArchitectureRefreshTarget = (typeof ARCHITECTURE_REFRESH_TARGETS)[number];
+export type ArchctxFeature = (typeof ARCHCTX_FEATURES)[number];
+export type Sha256Digest = `sha256:${string}`;
+
+export interface ProjectionExpectedSnapshotV1 {
+  repositoryId: string;
+  workspaceId: string;
+  headSha: string;
+  worktreeDigest: Sha256Digest;
+}
+
+export interface ProjectionRequestV1 {
+  schemaVersion: typeof PROJECTION_REQUEST_SCHEMA_VERSION;
+  requestId: string;
+  profile: "repo-harness/v1";
+  mode: ProjectionMode;
+  targets: ProjectionTarget[];
+  changedPaths: string[];
+  expected: ProjectionExpectedSnapshotV1;
+  adoptionPlanId?: string;
+}
+
+export interface ProjectionSnapshotV1 extends ProjectionExpectedSnapshotV1 {
+  baseHeadSha: string;
+  sourceTreeDigest: Sha256Digest;
+  modelDigest: Sha256Digest;
+  codeGraphDigest: Sha256Digest;
+  indexedWorktreeDigest: Sha256Digest | null;
+  projectionInputDigest: Sha256Digest;
+  rendererVersion: typeof ARCHITECTURE_DOCS_RENDERER_VERSION;
+  layoutVersion: "archcontext.docs-layout/v1";
+  generatedFrom: {
+    codeGraphPackage: "@colbymchenry/codegraph";
+    codeGraphVersion: "1.5.0";
+    codeGraphBinaryDigest: Sha256Digest;
+    codeGraphStatus: "ready" | "unavailable";
+  };
+}
+
+export interface ProjectionFileResultV1 {
+  path: string;
+  action: "create" | "delete" | "unchanged" | "update";
+  preimageDigest: Sha256Digest | null;
+  outputDigest: Sha256Digest | null;
+}
+
+export interface ProjectionHumanActionV1 {
+  reasonCode: ProjectionHumanActionReasonCode;
+  affectedNodeIds: string[];
+  requestPayloadDigest: Sha256Digest;
+}
+
+export interface ArchitectureDigestSetV1 {
+  modelDigest: Sha256Digest;
+  sourceTreeDigest: Sha256Digest;
+  flowProofDigest: Sha256Digest;
+  projectionDigest: Sha256Digest;
+}
+
+export interface AcceptedArchitectureChangeReferenceV1 {
+  changeSetId: string;
+  eventId: string;
+  reasonCodes: ArchitectureMajorChangeReasonCode[];
+  affectedNodeIds: string[];
+}
+
+export interface ArchitectureRefreshSignalV1 {
+  schemaVersion: typeof ARCHITECTURE_REFRESH_SIGNAL_SCHEMA_VERSION;
+  signalId: Sha256Digest;
+  idempotencyKey: Sha256Digest;
+  mode: "human-action-required" | "refresh-required";
+  repository: { repositoryId: string };
+  worktree: { workspaceId: string; headSha: string; worktreeDigest: Sha256Digest };
+  cause: "accepted-semantic-delta" | "unresolved-major-candidate" | "verified-flow-proof-delta";
+  acceptedChange?: AcceptedArchitectureChangeReferenceV1;
+  reasonCodes: ArchitectureMajorChangeReasonCode[];
+  affectedNodeIds: string[];
+  refreshTargets: ArchitectureRefreshTarget[];
+  baseDigests: ArchitectureDigestSetV1;
+  resultingDigests: ArchitectureDigestSetV1;
+  projectionReceiptDigest: Sha256Digest;
+}
+
+export interface ProjectionResultV1 {
+  schemaVersion: typeof PROJECTION_RESULT_SCHEMA_VERSION;
+  requestId: string;
+  status: ProjectionResultStatus;
+  inputSnapshot: ProjectionSnapshotV1;
+  outputSnapshot: ProjectionSnapshotV1;
+  affectedNodeIds: string[];
+  files: ProjectionFileResultV1[];
+  humanActions: ProjectionHumanActionV1[];
+  refreshSignals: ArchitectureRefreshSignalV1[];
+  receiptDigest: Sha256Digest;
+}
+
+export interface ArchctxCapabilitiesV1 {
+  schemaVersion: typeof ARCHCTX_CAPABILITIES_SCHEMA_VERSION;
+  package: {
+    name: "archctx";
+    version: string;
+  };
+  protocols: {
+    projectionRequest: typeof PROJECTION_REQUEST_SCHEMA_VERSION;
+    projectionResult: typeof PROJECTION_RESULT_SCHEMA_VERSION;
+    architectureRefreshSignal: typeof ARCHITECTURE_REFRESH_SIGNAL_SCHEMA_VERSION;
+  };
+  renderers: {
+    architectureDocs: typeof ARCHITECTURE_DOCS_RENDERER_VERSION;
+    agentContext: typeof AGENT_CONTEXT_RENDERER_VERSION;
+  };
+  features: ArchctxFeature[];
+}
+
+export function archctxCapabilities(packageVersion: string): ArchctxCapabilitiesV1 {
+  return {
+    schemaVersion: ARCHCTX_CAPABILITIES_SCHEMA_VERSION,
+    package: { name: "archctx", version: packageVersion },
+    protocols: {
+      projectionRequest: PROJECTION_REQUEST_SCHEMA_VERSION,
+      projectionResult: PROJECTION_RESULT_SCHEMA_VERSION,
+      architectureRefreshSignal: ARCHITECTURE_REFRESH_SIGNAL_SCHEMA_VERSION
+    },
+    renderers: {
+      architectureDocs: ARCHITECTURE_DOCS_RENDERER_VERSION,
+      agentContext: AGENT_CONTEXT_RENDERER_VERSION
+    },
+    features: [...ARCHCTX_FEATURES]
+  };
+}
+
+export function projectionRequestInvariantIssues(input: ProjectionRequestV1): string[] {
+  const issues = [
+    ...sortedUniqueIssues("targets", input.targets),
+    ...sortedUniqueIssues("changedPaths", input.changedPaths)
+  ];
+  if (input.targets.length === 0) issues.push("targets must contain at least one projection target");
+  if (!/^[a-zA-Z0-9_.:-]+$/.test(input.requestId)) issues.push("requestId must use the stable identifier character set");
+  if (input.mode === "adopt" && !input.adoptionPlanId) issues.push("adoptionPlanId is required when mode=adopt");
+  if (input.mode !== "adopt" && input.adoptionPlanId !== undefined) issues.push("adoptionPlanId is only allowed when mode=adopt");
+  return issues;
+}
+
+export function projectionResultInvariantIssues(input: ProjectionResultV1): string[] {
+  const issues = [
+    ...sortedUniqueIssues("affectedNodeIds", input.affectedNodeIds),
+    ...sortedUniqueIssues("files.path", input.files.map((file) => file.path)),
+    ...sortedUniqueIssues("refreshSignals.signalId", input.refreshSignals.map((signal) => signal.signalId)),
+    ...input.humanActions.flatMap((action, index) => sortedUniqueIssues(`humanActions[${index}].affectedNodeIds`, action.affectedNodeIds)),
+    ...input.refreshSignals.flatMap((signal, index) => architectureRefreshSignalInvariantIssues(signal, `refreshSignals[${index}]`))
+  ];
+  if (!/^[a-zA-Z0-9_.:-]+$/.test(input.requestId)) issues.push("requestId must use the stable identifier character set");
+  if (input.inputSnapshot.repositoryId !== input.outputSnapshot.repositoryId) issues.push("outputSnapshot.repositoryId must match inputSnapshot.repositoryId");
+  if (input.inputSnapshot.workspaceId !== input.outputSnapshot.workspaceId) issues.push("outputSnapshot.workspaceId must match inputSnapshot.workspaceId");
+  if (input.inputSnapshot.baseHeadSha !== input.outputSnapshot.baseHeadSha) issues.push("outputSnapshot.baseHeadSha must match inputSnapshot.baseHeadSha");
+  const statusRequiresHumanAction = input.status === "adoption-required" || input.status === "human-action-required";
+  if (statusRequiresHumanAction && input.humanActions.length === 0) issues.push(`${input.status} status requires at least one human action`);
+  if (!statusRequiresHumanAction && input.humanActions.length > 0) issues.push(`human actions are not allowed when status=${input.status}`);
+  for (const [index, file] of input.files.entries()) {
+    const prefix = `files[${index}]`;
+    if (file.action === "create" && (file.preimageDigest !== null || file.outputDigest === null)) {
+      issues.push(`${prefix} create requires null preimageDigest and non-null outputDigest`);
+    }
+    if (file.action === "delete" && (file.preimageDigest === null || file.outputDigest !== null)) {
+      issues.push(`${prefix} delete requires non-null preimageDigest and null outputDigest`);
+    }
+    if (file.action === "update" && (file.preimageDigest === null || file.outputDigest === null || file.preimageDigest === file.outputDigest)) {
+      issues.push(`${prefix} update requires two different non-null digests`);
+    }
+    if (file.action === "unchanged" && (file.preimageDigest === null || file.outputDigest === null || file.preimageDigest !== file.outputDigest)) {
+      issues.push(`${prefix} unchanged requires equal non-null digests`);
+    }
+  }
+  const { receiptDigest, ...receiptPayload } = input;
+  if (projectionResultReceiptDigest(receiptPayload) !== receiptDigest) issues.push("receiptDigest must match the canonical projection result payload");
+  for (const [index, signal] of input.refreshSignals.entries()) {
+    const prefix = `refreshSignals[${index}]`;
+    if (signal.projectionReceiptDigest !== receiptDigest) issues.push(`${prefix}.projectionReceiptDigest must match receiptDigest`);
+    if (signal.repository.repositoryId !== input.outputSnapshot.repositoryId) issues.push(`${prefix}.repositoryId must match outputSnapshot.repositoryId`);
+    if (signal.worktree.workspaceId !== input.outputSnapshot.workspaceId) issues.push(`${prefix}.workspaceId must match outputSnapshot.workspaceId`);
+    if (signal.worktree.headSha !== input.outputSnapshot.headSha) issues.push(`${prefix}.headSha must match outputSnapshot.headSha`);
+    if (signal.worktree.worktreeDigest !== input.outputSnapshot.worktreeDigest) issues.push(`${prefix}.worktreeDigest must match outputSnapshot.worktreeDigest`);
+  }
+  return issues;
+}
+
+/**
+ * Computes the accepted projection receipt. Signal back-references are omitted from the
+ * receipt payload to avoid a circular hash; every signal must then bind that receipt via
+ * projectionReceiptDigest, which projectionResultInvariantIssues verifies.
+ */
+export function projectionResultReceiptDigest(input: Omit<ProjectionResultV1, "receiptDigest">): Sha256Digest {
+  const refreshSignals = input.refreshSignals.map(({ projectionReceiptDigest: _projectionReceiptDigest, ...signal }) => signal);
+  return digestJson({ ...input, refreshSignals } as unknown as Json) as Sha256Digest;
+}
+
+export function architectureRefreshSignalInvariantIssues(input: ArchitectureRefreshSignalV1, prefix = "signal"): string[] {
+  const issues = [
+    ...sortedUniqueIssues(`${prefix}.reasonCodes`, input.reasonCodes),
+    ...sortedUniqueIssues(`${prefix}.affectedNodeIds`, input.affectedNodeIds),
+    ...sortedUniqueIssues(`${prefix}.refreshTargets`, input.refreshTargets)
+  ];
+  if (input.acceptedChange) {
+    issues.push(
+      ...sortedUniqueIssues(`${prefix}.acceptedChange.reasonCodes`, input.acceptedChange.reasonCodes),
+      ...sortedUniqueIssues(`${prefix}.acceptedChange.affectedNodeIds`, input.acceptedChange.affectedNodeIds)
+    );
+    if (input.acceptedChange.changeSetId.trim() === "") issues.push(`${prefix}.acceptedChange.changeSetId must not be empty`);
+    if (input.acceptedChange.eventId.trim() === "") issues.push(`${prefix}.acceptedChange.eventId must not be empty`);
+    if (input.acceptedChange.reasonCodes.join("\u0000") !== input.reasonCodes.join("\u0000")) {
+      issues.push(`${prefix}.acceptedChange.reasonCodes must match signal reasonCodes`);
+    }
+    if (input.acceptedChange.affectedNodeIds.join("\u0000") !== input.affectedNodeIds.join("\u0000")) {
+      issues.push(`${prefix}.acceptedChange.affectedNodeIds must match signal affectedNodeIds`);
+    }
+  }
+  if (input.reasonCodes.length === 0) issues.push(`${prefix}.reasonCodes must contain at least one reason`);
+  if (input.affectedNodeIds.length === 0) issues.push(`${prefix}.affectedNodeIds must contain at least one node`);
+  if (input.refreshTargets.length === 0) issues.push(`${prefix}.refreshTargets must contain at least one target`);
+  if (input.cause === "unresolved-major-candidate" && input.mode !== "human-action-required") {
+    issues.push(`${prefix}.unresolved-major-candidate requires human-action-required mode`);
+  }
+  if (input.cause !== "unresolved-major-candidate" && input.mode !== "refresh-required") {
+    issues.push(`${prefix}.${input.cause} requires refresh-required mode`);
+  }
+  if (input.mode === "refresh-required" && !input.acceptedChange) {
+    issues.push(`${prefix}.refresh-required requires acceptedChange`);
+  }
+  if (input.mode === "human-action-required" && input.acceptedChange) {
+    issues.push(`${prefix}.human-action-required forbids acceptedChange`);
+  }
+  return issues;
+}
+
+function sortedUniqueIssues(label: string, values: readonly string[]): string[] {
+  const expected = [...new Set(values)].sort();
+  return expected.length === values.length && expected.every((value, index) => value === values[index])
+    ? []
+    : [`${label} must be sorted and unique`];
+}

package/src/schema.ts

@@ -36,6 +36,7 @@ export interface ArchContextError {
   severity: Severity;
   retryable: boolean;
   action: string;
+  reasonCode?: string;
 }
 
 export interface JsonEnvelope<T extends Json = Json> {
@@ -71,12 +72,12 @@ export function okEnvelope<T extends Json>(requestId: string, data: T): JsonEnve
   return { schemaVersion: "archcontext.envelope/v1", ok: true, requestId, data };
 }
 
-export function errorEnvelope(requestId: string, code: ArchContextErrorCode, message: string): JsonEnvelope {
+export function errorEnvelope(requestId: string, code: ArchContextErrorCode, message: string, reasonCode?: string): JsonEnvelope {
   return {
     schemaVersion: "archcontext.envelope/v1",
     ok: false,
     requestId,
-    error: { ...ERROR_CATALOG[code], message }
+    error: { ...ERROR_CATALOG[code], message, ...(reasonCode ? { reasonCode } : {}) }
   };
 }
 

package/src/validator.ts

@@ -1,4 +1,4 @@
-import type { Json } from "./schema";
+import { canonicalize, type Json } from "./schema";
 
 export interface ValidationIssue {
   path: string;
@@ -11,6 +11,8 @@ export interface ValidationResult {
 }
 
 type JsonSchema = {
+  $ref?: string;
+  $defs?: Record<string, JsonSchema>;
   type?: string | string[];
   const?: Json;
   enum?: Json[];
@@ -19,23 +21,42 @@ type JsonSchema = {
   properties?: Record<string, JsonSchema>;
   items?: JsonSchema;
   oneOf?: JsonSchema[];
+  anyOf?: JsonSchema[];
+  allOf?: JsonSchema[];
+  if?: JsonSchema;
+  then?: JsonSchema;
+  else?: JsonSchema;
+  not?: JsonSchema;
   additionalProperties?: boolean | JsonSchema;
   minItems?: number;
+  maxItems?: number;
+  uniqueItems?: boolean;
+  minLength?: number;
+  maxLength?: number;
   minimum?: number;
   maximum?: number;
 };
 
 export function validateJsonSchema(schema: JsonSchema, value: Json): ValidationResult {
   const issues: ValidationIssue[] = [];
-  visit(schema, value, "$", issues);
+  visit(schema, value, "$", issues, schema);
   return { valid: issues.length === 0, issues };
 }
 
-function visit(schema: JsonSchema, value: Json, path: string, issues: ValidationIssue[]): void {
+function visit(schema: JsonSchema, value: Json, path: string, issues: ValidationIssue[], root: JsonSchema): void {
+  if (schema.$ref) {
+    if (!schema.$ref.startsWith("#/")) return;
+    const resolved = resolveLocalRef(root, schema.$ref);
+    if (!resolved) {
+      issues.push({ path, message: `unresolved schema reference ${schema.$ref}` });
+      return;
+    }
+    visit(resolved, value, path, issues, root);
+  }
   if (schema.oneOf) {
     const matched = schema.oneOf.filter((candidate) => {
       const candidateIssues: ValidationIssue[] = [];
-      visit(candidate, value, path, candidateIssues);
+      visit(candidate, value, path, candidateIssues, root);
       return candidateIssues.length === 0;
     }).length;
     if (matched !== 1) {
@@ -43,6 +64,26 @@ function visit(schema: JsonSchema, value: Json, path: string, issues: Validation
       return;
     }
   }
+  if (schema.anyOf) {
+    const matched = schema.anyOf.some((candidate) => {
+      const candidateIssues: ValidationIssue[] = [];
+      visit(candidate, value, path, candidateIssues, root);
+      return candidateIssues.length === 0;
+    });
+    if (!matched) issues.push({ path, message: "expected at least one matching schema" });
+  }
+  for (const candidate of schema.allOf ?? []) visit(candidate, value, path, issues, root);
+  if (schema.if) {
+    const conditionIssues: ValidationIssue[] = [];
+    visit(schema.if, value, path, conditionIssues, root);
+    const branch = conditionIssues.length === 0 ? schema.then : schema.else;
+    if (branch) visit(branch, value, path, issues, root);
+  }
+  if (schema.not) {
+    const candidateIssues: ValidationIssue[] = [];
+    visit(schema.not, value, path, candidateIssues, root);
+    if (candidateIssues.length === 0) issues.push({ path, message: "matched forbidden schema" });
+  }
   if (schema.const !== undefined && JSON.stringify(value) !== JSON.stringify(schema.const)) {
     issues.push({ path, message: `expected const ${JSON.stringify(schema.const)}` });
     return;
@@ -57,6 +98,12 @@ function visit(schema: JsonSchema, value: Json, path: string, issues: Validation
   if (typeof value === "string" && schema.pattern && !new RegExp(schema.pattern).test(value)) {
     issues.push({ path, message: `does not match ${schema.pattern}` });
   }
+  if (typeof value === "string" && schema.minLength !== undefined && value.length < schema.minLength) {
+    issues.push({ path, message: `shorter than minimum length ${schema.minLength}` });
+  }
+  if (typeof value === "string" && schema.maxLength !== undefined && value.length > schema.maxLength) {
+    issues.push({ path, message: `longer than maximum length ${schema.maxLength}` });
+  }
   if (typeof value === "number") {
     if (schema.minimum !== undefined && value < schema.minimum) issues.push({ path, message: `below minimum ${schema.minimum}` });
     if (schema.maximum !== undefined && value > schema.maximum) issues.push({ path, message: `above maximum ${schema.maximum}` });
@@ -65,7 +112,13 @@ function visit(schema: JsonSchema, value: Json, path: string, issues: Validation
     if (schema.minItems !== undefined && value.length < schema.minItems) {
       issues.push({ path, message: `expected at least ${schema.minItems} items` });
     }
-    if (schema.items) value.forEach((item, index) => visit(schema.items!, item, `${path}[${index}]`, issues));
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+      issues.push({ path, message: `expected at most ${schema.maxItems} items` });
+    }
+    if (schema.uniqueItems && new Set(value.map(canonicalize)).size !== value.length) {
+      issues.push({ path, message: "expected unique items" });
+    }
+    if (schema.items) value.forEach((item, index) => visit(schema.items!, item, `${path}[${index}]`, issues, root));
   }
   if (value !== null && typeof value === "object" && !Array.isArray(value)) {
     const objectValue = value as Record<string, Json>;
@@ -73,7 +126,7 @@ function visit(schema: JsonSchema, value: Json, path: string, issues: Validation
       if (!(key in objectValue)) issues.push({ path: `${path}.${key}`, message: "required" });
     }
     for (const [key, child] of Object.entries(schema.properties ?? {})) {
-      if (key in objectValue) visit(child, objectValue[key], `${path}.${key}`, issues);
+      if (key in objectValue) visit(child, objectValue[key], `${path}.${key}`, issues, root);
     }
     if (schema.additionalProperties === false && schema.properties) {
       for (const key of Object.keys(objectValue)) {
@@ -83,6 +136,17 @@ function visit(schema: JsonSchema, value: Json, path: string, issues: Validation
   }
 }
 
+function resolveLocalRef(root: JsonSchema, ref: string): JsonSchema | undefined {
+  if (!ref.startsWith("#/")) return undefined;
+  let current: unknown = root;
+  for (const rawSegment of ref.slice(2).split("/")) {
+    const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!current || typeof current !== "object" || Array.isArray(current) || !(segment in current)) return undefined;
+    current = (current as Record<string, unknown>)[segment];
+  }
+  return current && typeof current === "object" && !Array.isArray(current) ? current as JsonSchema : undefined;
+}
+
 function matchesType(type: string | string[], value: Json): boolean {
   const allowed = Array.isArray(type) ? type : [type];
   return allowed.some((candidate) => {

package/fixtures/invalid/explorer-projection-write-field.json

@@ -1,21 +0,0 @@
-{
-  "schemaVersion": "archcontext.explorer-projection/v1",
-  "generatedAt": "2026-06-20T00:00:00.000Z",
-  "repository": {
-    "repositoryId": "repo.local",
-    "headSha": "abc123",
-    "worktreeDigest": "sha256:1111111111111111111111111111111111111111111111111111111111111111"
-  },
-  "nodes": [],
-  "relations": [],
-  "verification": [],
-  "pressure": [],
-  "interventions": [],
-  "capabilities": {
-    "readOnly": true,
-    "mutationMode": "forbidden",
-    "egress": "none",
-    "tokenRequired": true
-  },
-  "mutationEndpoint": "/changesets/apply"
-}

package/fixtures/valid/explorer-projection.json

@@ -1,53 +0,0 @@
-{
-  "schemaVersion": "archcontext.explorer-projection/v1",
-  "generatedAt": "2026-06-20T00:00:00.000Z",
-  "repository": {
-    "repositoryId": "repo.local",
-    "headSha": "abc123",
-    "worktreeDigest": "sha256:1111111111111111111111111111111111111111111111111111111111111111",
-    "modelDigest": "sha256:2222222222222222222222222222222222222222222222222222222222222222"
-  },
-  "nodes": [
-    {
-      "id": "module.runtime-daemon",
-      "name": "Runtime Daemon",
-      "kind": "module",
-      "repositoryId": "repo.local",
-      "verificationStatus": "MATCHED",
-      "pressure": {
-        "level": "low",
-        "score": 12,
-        "signals": []
-      },
-      "sourceSelectors": [
-        {
-          "path": "packages/local-runtime/runtime-daemon/src/index.ts",
-          "symbolId": "ArchctxDaemon",
-          "startLine": 41,
-          "endLine": 300
-        }
-      ]
-    }
-  ],
-  "relations": [
-    {
-      "id": "relation.cli-runtime",
-      "source": "module.cli",
-      "target": "module.runtime-daemon",
-      "kind": "uses",
-      "verificationStatus": "MATCHED"
-    }
-  ],
-  "landscape": {
-    "repositories": ["repo.local"]
-  },
-  "verification": [],
-  "pressure": [],
-  "interventions": [],
-  "capabilities": {
-    "readOnly": true,
-    "mutationMode": "forbidden",
-    "egress": "none",
-    "tokenRequired": true
-  }
-}

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

@@ -1,92 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://archctx.repoharness.com/schemas/runtime/explorer-projection.schema.json",
-  "title": "ExplorerProjection",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["schemaVersion", "generatedAt", "repository", "nodes", "relations", "verification", "pressure", "interventions", "capabilities"],
-  "properties": {
-    "schemaVersion": { "const": "archcontext.explorer-projection/v1" },
-    "generatedAt": { "type": "string" },
-    "repository": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["repositoryId", "headSha", "worktreeDigest"],
-      "properties": {
-        "repositoryId": { "type": "string" },
-        "headSha": { "type": "string" },
-        "worktreeDigest": { "type": "string" },
-        "modelDigest": { "type": "string" }
-      }
-    },
-    "nodes": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["id", "name", "kind", "verificationStatus", "pressure", "sourceSelectors"],
-        "properties": {
-          "id": { "type": "string" },
-          "name": { "type": "string" },
-          "kind": { "type": "string" },
-          "repositoryId": { "type": "string" },
-          "verificationStatus": { "type": "string", "enum": ["MATCHED", "DRIFT", "UNKNOWN", "VERIFIED"] },
-          "pressure": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": ["level", "score", "signals"],
-            "properties": {
-              "level": { "type": "string", "enum": ["low", "medium", "high"] },
-              "score": { "type": "number", "minimum": 0, "maximum": 100 },
-              "signals": { "type": "array", "items": { "type": "string" } }
-            }
-          },
-          "sourceSelectors": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "additionalProperties": false,
-              "required": ["path"],
-              "properties": {
-                "path": { "type": "string" },
-                "symbolId": { "type": "string" },
-                "startLine": { "type": "integer", "minimum": 1 },
-                "endLine": { "type": "integer", "minimum": 1 }
-              }
-            }
-          }
-        }
-      }
-    },
-    "relations": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["id", "source", "target", "kind", "verificationStatus"],
-        "properties": {
-          "id": { "type": "string" },
-          "source": { "type": "string" },
-          "target": { "type": "string" },
-          "kind": { "type": "string" },
-          "verificationStatus": { "type": "string", "enum": ["MATCHED", "DRIFT", "UNKNOWN", "VERIFIED"] }
-        }
-      }
-    },
-    "landscape": { "type": "object", "additionalProperties": true },
-    "verification": { "type": "array", "items": { "type": "object", "additionalProperties": true } },
-    "pressure": { "type": "array", "items": { "type": "object", "additionalProperties": true } },
-    "interventions": { "type": "array", "items": { "type": "object", "additionalProperties": true } },
-    "capabilities": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["readOnly", "mutationMode", "egress", "tokenRequired"],
-      "properties": {
-        "readOnly": { "const": true },
-        "mutationMode": { "type": "string", "enum": ["forbidden"] },
-        "egress": { "type": "string", "enum": ["none"] },
-        "tokenRequired": { "type": "boolean" }
-      }
-    }
-  }
-}