@c4a/context-cli 0.7.0 → 0.7.4

package/providers/context/resources/procedures/close-and-build.md

@@ -6,29 +6,23 @@ mediaType: text/markdown
 
 # Close and build
 
-Close deterministically reconciles approved Markdown, existing durable machine
-metadata, and confirmed structure snapshots into `knowledge/structure.yaml`.
-It then compacts repeated machine fields out of each Markdown page and validates
-the hydrated result. When an approved page still points at a captured source asset,
-close may mechanically replace that target with its content-addressed
-`knowledge/assets` path; it does not rewrite reader-visible prose. Before
-removing the transient snapshots, it retains only each closed prose target's
-source, collection, and consumed snapshot hash under `source_inputs`.
+Close deterministically reconciles approved Markdown and current relationship
+inputs into `knowledge/structure.yaml`. It compacts repeated machine fields out
+of each Markdown page and validates the hydrated result. When an approved page
+still points at a captured source asset, close may mechanically replace that
+target with its content-addressed `knowledge/assets` path; it does not rewrite
+reader-visible prose. Candidate fingerprints, Section mappings, old prose
+`source_inputs`, and Review receipts remain outside long-lived knowledge.
 
 Do not hand-edit, duplicate, or move fields between Markdown and
 `structure.yaml`. The CLI owns compaction and hydration. A compact Markdown page
 remains readable and keeps enough identity for projection diagnostics; complete
-code and optimization metadata is intentionally not duplicated.
+code lifecycle metadata is intentionally not duplicated.
 
 Build runs only after close and verification are current. It writes declared
 packages under `dist/` and records an inventory receipt with added, updated,
 removed, and index changes.
 
-When document optimization is enabled, its current revision batch must also be
-resolved before build. Build compiles each approved page through its optional
-`__revision.md` sidecar and records the policy and decision counts in the
-package inventory. Revision sidecars are never emitted as separate knowledge.
-
 Run only the current route command, then evaluate again. A successful build
 means the currently declared scope is current; newly captured or newly declared
 targets can reopen earlier graph nodes.
@@ -40,12 +34,3 @@ review decision in this conversation, together with its reviewed scope. Omit
 the section when no report was user-reviewed. Do not reconstruct it by scanning
 `.tmp`, invent a shareable URL, or classify fully managed or force approval as
 user review.
-# Code-index audit record
-
-When a package selects approved `codeindex` pages, build requires the current
-batch-level Agent audit to be accepted. The complete report and decision state
-are runtime data below `.tmp/context-runtime/code-index-audit/`; deleting
-`.tmp/` causes Context to recompute and re-audit them. They are not copied into
-`dist/`, uploaded with the package, or committed as knowledge. The package
-inventory stores only the report digest, decision, and compact summary needed
-to identify the audited build.

package/providers/context/resources/procedures/knowledge-review.md

@@ -23,7 +23,7 @@ authorization.
 Without explicit session-managed authority:
 
 - open the report returned by the route;
-- let the user approve or reject candidates;
+- let the user publish or durably omit candidates;
 - apply the exact returned decision payload; and
 - retain the exact report reference and reviewed scope in this conversation for
   the final completion summary.
@@ -34,10 +34,19 @@ Use it only after the user cannot use the report and explicitly replies with
 the exact phrase `强制批准` in the current conversation. It approves the complete
 current scope atomically; no candidate-specific decisions are inferred.
 
-With explicit session-managed authority, Context may approve the complete
-current batch atomically. The authority exists only in the current
+With explicit session-managed authority, first run the read-only Review HTML
+command, then read the complete generated report and every reader-facing
+Candidate in its current scope. Only after deciding that the whole batch is
+publishable may the Agent run the managed atomic approval command. If any page
+needs repair, do not approve the batch; reopen the owning Author or Composer
+through the current repair route. The authority exists only in the current
 conversation. It does not bypass source permission, validation, close, or
-verify.
+verify, and it is not proof that the report was read.
 
 After apply, re-evaluate. Do not infer that close or package output is current.
 Do not persist a duplicate review-report ledger in the workspace.
+
+The Review UI names the internal `rejected` decision **Omit** because it is a
+durable content decision, not a request to rewrite the page. When a page needs
+changes, leave the whole batch unapplied and use `context revise` so the owning
+Author or Composer produces a new Candidate through the same lifecycle.

package/providers/context/resources/procedures/source-capture-detailed.md

@@ -164,9 +164,9 @@ capture result:
   nested Skill or Schema. These conditional resources are intentionally absent
   from the Route's ordinary `resources.required`.
 
-Never suggest prose compile or hand-built document knowledge for a code-only
-source. Code sources become active knowledge only through the declared
-extraction/review route returned by `context status`.
+Never hand-build document knowledge for a code-only source. Code sources become
+active knowledge only through the current Indexer route returned by
+`context status`.
 
 If capture is rejected because another phase or write gate is active, do not
 discard it automatically. Explain the active state from `context status`, follow
@@ -192,11 +192,9 @@ Stable structure:
    summarize each as a single line naming the work and which sources are
    affected. Omit the section entirely when there is no pending follow-up.
 4. Next step. Single command suggestion driven by status: the returned
-   `context run align:<type>:<source>:<collection> ...` command when structure work is
-   pending, the returned `context run compile:<type>:<source>:<collection> ...`
-   command when prose compile work is pending, or the CLI-owned code projection
-   command when code projection is pending. If nothing is pending, say so
-   explicitly.
+   current Indexer command when semantic structure or authoring work is pending,
+   or the CLI-owned capture command when another confirmed source remains. If
+   nothing is pending, say so explicitly.
 
 Do not include raw CLI diagnostics, agent_hints content, schema names, or phase
 payload identifiers in the report. Those belong in earlier troubleshooting

package/providers/context/resources/views/authorized-indexer-workset-view.yaml

@@ -0,0 +1,15 @@
+schema: agent-graph.resource.host-action.v1
+id: authorized-indexer-workset-view
+kind: procedure
+mediaType: application/json
+materializer: actions/materialize-indexer-workset-view.yaml
+input:
+  protocol: context.indexer.workset-view-materialization-request/v1
+  handler: context.materialize-indexer-workset-view/v1
+  resource_id: authorized-indexer-workset-view
+  workset_digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+  execution_request_digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+  view_digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+  payload_digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+  request_digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+description: Runtime-bound authorized evidence for one exact Indexer workset; Context replaces the reserved template before exposing the Route.

package/providers/context/resources/views/package-current.yaml

@@ -1,4 +1,4 @@
-schema: agent-graph.resource.v1
+schema: agent-graph.resource.graph-action.v1
 id: context.package-current
 kind: context-view
 mediaType: text/markdown

package/providers/context/resources/views/resolved-indexer-instructions.yaml

@@ -1,4 +1,4 @@
-schema: agent-graph.resource.v2
+schema: agent-graph.resource.host-action.v1
 id: resolved-indexer-instructions
 kind: procedure
 mediaType: text/markdown

package/providers/context/resources/views/review-current.yaml

@@ -1,4 +1,4 @@
-schema: agent-graph.resource.v1
+schema: agent-graph.resource.graph-action.v1
 id: context.review-current
 kind: context-view
 mediaType: text/markdown

package/providers/context/resources/views/source-boundary.yaml

@@ -1,4 +1,4 @@
-schema: agent-graph.resource.v1
+schema: agent-graph.resource.graph-action.v1
 id: context.source-boundary
 kind: context-view
 mediaType: text/markdown

package/providers/context/resources/views/source-current.yaml

@@ -1,4 +1,4 @@
-schema: agent-graph.resource.v1
+schema: agent-graph.resource.graph-action.v1
 id: context.source-current
 kind: context-view
 mediaType: text/markdown

package/providers/context/resources/views/verification-current.yaml

@@ -1,4 +1,4 @@
-schema: agent-graph.resource.v1
+schema: agent-graph.resource.graph-action.v1
 id: context.verification-current
 kind: context-view
 mediaType: text/markdown

package/providers/context/resources/views/workspace-current.yaml

@@ -1,4 +1,4 @@
-schema: agent-graph.resource.v1
+schema: agent-graph.resource.graph-action.v1
 id: context.workspace-current
 kind: context-view
 mediaType: text/markdown

package/providers/context/schemas/indexer-agent-step-input.schema.json

@@ -10,8 +10,8 @@
       "type": "object",
       "required": ["protocol", "operation", "workset", "composition_input", "final_authority", "execution_request_digest"],
       "properties": {
-        "protocol": { "const": "context.indexer.run-request/v1" },
-        "operation": { "enum": ["main-index", "material-answer"] },
+        "protocol": { "const": "context.indexer.run-request/v2" },
+        "operation": { "const": "main-index" },
         "workset": { "type": "object" },
         "composition_input": { "type": "object" },
         "final_authority": { "type": "object" },

package/providers/context/schemas/indexer-agent-step-result.schema.json

@@ -1,47 +1,313 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "context.indexer.agent-step-result/v1",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "protocol",
-    "input_digest",
-    "instruction_payload_digest",
-    "run_result",
-    "execution_receipt",
-    "stable_result_digest"
+  "$id": "context.indexer.current-action-input/v1",
+  "oneOf": [
+    { "$ref": "#/$defs/providerSelection" },
+    { "$ref": "#/$defs/providerResolution" },
+    { "$ref": "#/$defs/providerProgramAuthorization" },
+    { "$ref": "#/$defs/providerFinalization" },
+    { "$ref": "#/$defs/partition" },
+    { "$ref": "#/$defs/author" },
+    { "$ref": "#/$defs/postAuthor" },
+    { "$ref": "#/$defs/structureReview" },
+    { "$ref": "#/$defs/layoutConfirmation" }
   ],
-  "properties": {
-    "protocol": { "const": "context.indexer.agent-step-result/v1" },
-    "input_digest": { "$ref": "#/$defs/digest" },
-    "instruction_payload_digest": { "$ref": "#/$defs/digest" },
-    "run_result": {
+  "$defs": {
+    "string": { "type": "string", "minLength": 1 },
+    "providerSelection": {
       "type": "object",
-      "required": ["protocol", "operation", "result"],
+      "additionalProperties": false,
+      "required": ["stage", "host_visible_skills", "indexers"],
       "properties": {
-        "protocol": { "const": "context.indexer.run-result/v1" },
-        "operation": { "enum": ["main-index", "material-answer"] },
-        "result": { "type": "object" }
+        "stage": { "const": "provider-selection" },
+        "host_visible_skills": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["skill", "version", "source_type"],
+            "properties": {
+              "skill": { "$ref": "#/$defs/string" },
+              "version": { "oneOf": [{ "$ref": "#/$defs/string" }, { "type": "null" }] },
+              "source_type": {
+                "enum": ["community-plugin", "workspace", "installed-plugin", "marketplace"]
+              }
+            }
+          }
+        },
+        "indexers": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "type": "object" }
+        }
       }
     },
-    "execution_receipt": {
+    "providerResolution": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["adapter", "adapter_version", "execution_id", "receipt_digest"],
+      "required": ["stage", "result"],
       "properties": {
-        "adapter": { "type": "string", "minLength": 1 },
-        "adapter_version": { "type": "string", "minLength": 1 },
-        "model": { "type": "string", "minLength": 1 },
-        "execution_id": { "type": "string", "minLength": 1 },
-        "receipt_digest": { "$ref": "#/$defs/digest" }
+        "stage": { "const": "provider-resolution" },
+        "result": { "type": "object" },
+        "managed_output": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["ref", "digest", "value"],
+          "properties": {
+            "ref": { "$ref": "#/$defs/string" },
+            "digest": { "$ref": "#/$defs/string" },
+            "value": {}
+          }
+        }
       }
     },
-    "stable_result_digest": { "$ref": "#/$defs/digest" }
-  },
-  "$defs": {
-    "digest": {
-      "type": "string",
-      "pattern": "^sha256:[a-f0-9]{64}$"
+    "providerFinalization": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage"],
+      "properties": {
+        "stage": { "const": "provider-finalization" }
+      }
+    },
+    "providerProgramAuthorization": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "decision"],
+      "properties": {
+        "stage": { "const": "provider-program-authorization" },
+        "decision": { "enum": ["approved", "rejected"] }
+      }
+    },
+    "partition": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "outcome", "unit_type", "partition_axis", "groups", "excluded", "unsupported"],
+      "properties": {
+        "stage": { "const": "partition" },
+        "outcome": { "enum": ["complete", "failed"] },
+        "unit_type": { "$ref": "#/$defs/string" },
+        "partition_axis": { "$ref": "#/$defs/string" },
+        "groups": { "type": "array", "items": { "$ref": "#/$defs/partitionGroup" } },
+        "excluded": { "type": "array", "items": { "$ref": "#/$defs/excluded" } },
+        "unsupported": { "type": "array", "items": { "$ref": "#/$defs/unsupported" } },
+        "failure": { "$ref": "#/$defs/failure" }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "outcome": { "const": "failed" } } },
+          "then": { "required": ["failure"] }
+        }
+      ]
+    },
+    "partitionGroup": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["key", "title", "reader_task", "subject", "subject_intent", "members", "questions", "question_targets", "outline"],
+      "properties": {
+        "key": { "$ref": "#/$defs/string" },
+        "title": { "$ref": "#/$defs/string" },
+        "reader_task": { "$ref": "#/$defs/string" },
+        "subject": {
+          "oneOf": [
+            { "$ref": "#/$defs/string" },
+            {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["namespace", "kind", "local_key"],
+              "properties": {
+                "namespace": { "$ref": "#/$defs/string" },
+                "kind": { "$ref": "#/$defs/string" },
+                "local_key": { "$ref": "#/$defs/string" }
+              }
+            }
+          ]
+        },
+        "subject_intent": { "enum": ["primary", "enrich-or-independent"] },
+        "members": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/string" } },
+        "questions": { "type": "array", "items": { "$ref": "#/$defs/string" } },
+        "question_targets": { "type": "array", "items": { "$ref": "#/$defs/questionTarget" } },
+        "outline": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/string" } }
+      }
+    },
+    "questionTarget": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["target", "role"],
+      "properties": {
+        "target": { "$ref": "#/$defs/string" },
+        "role": { "enum": ["primary-carrier", "enricher"] }
+      }
+    },
+    "excluded": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["item", "reason_code"],
+      "properties": {
+        "item": { "$ref": "#/$defs/string" },
+        "reason_code": { "$ref": "#/$defs/string" }
+      }
+    },
+    "unsupported": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["item", "missing_capabilities"],
+      "properties": {
+        "item": { "$ref": "#/$defs/string" },
+        "missing_capabilities": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/string" } }
+      }
+    },
+    "failure": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message", "unassigned"],
+      "properties": {
+        "code": { "enum": ["unsupported-domain", "no-stable-axis", "insufficient-identity-facts", "invalid-input", "strategy-failed"] },
+        "message": { "$ref": "#/$defs/string" },
+        "unassigned": { "type": "array", "items": { "$ref": "#/$defs/string" } },
+        "missing_capabilities": { "type": "array", "items": { "$ref": "#/$defs/string" } },
+        "missing_sources": { "type": "array", "items": { "$ref": "#/$defs/string" } }
+      }
+    },
+    "author": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "group_key", "outcome", "target_resolutions", "sections", "member_dispositions", "material_gaps", "diagnostics"],
+      "properties": {
+        "stage": { "const": "author" },
+        "group_key": { "$ref": "#/$defs/string" },
+        "outcome": { "enum": ["publish", "catalog-only", "request-material", "unsupported"] },
+        "artifact_intent": { "$ref": "#/$defs/string" },
+        "policy": { "$ref": "#/$defs/string" },
+        "target_resolutions": { "type": "array", "items": { "$ref": "#/$defs/targetResolution" } },
+        "title": { "$ref": "#/$defs/string" },
+        "summary": { "$ref": "#/$defs/string" },
+        "sections": { "type": "array", "items": { "$ref": "#/$defs/authorSection" } },
+        "member_dispositions": { "type": "array", "items": { "$ref": "#/$defs/memberDisposition" } },
+        "material_gaps": { "type": "array", "items": { "$ref": "#/$defs/materialGap" } },
+        "diagnostics": { "type": "array", "items": { "$ref": "#/$defs/diagnostic" } }
+      }
+    },
+    "targetResolution": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["target", "disposition"],
+      "properties": {
+        "target": { "$ref": "#/$defs/string" },
+        "disposition": { "enum": ["reuse-existing", "create-independent", "unresolved"] },
+        "reason_code": { "$ref": "#/$defs/string" }
+      }
+    },
+    "authorSection": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["key", "heading", "markdown", "source_items", "facts", "answers"],
+      "properties": {
+        "key": { "$ref": "#/$defs/string" },
+        "heading": { "$ref": "#/$defs/string" },
+        "markdown": { "$ref": "#/$defs/string" },
+        "source_items": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/string" } },
+        "facts": { "type": "array", "items": { "$ref": "#/$defs/string" } },
+        "answers": { "type": "array", "items": { "$ref": "#/$defs/string" } }
+      }
+    },
+    "memberDisposition": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["item", "state"],
+      "properties": {
+        "item": { "$ref": "#/$defs/string" },
+        "state": { "enum": ["covered", "catalog-only", "unsupported"] },
+        "section": { "$ref": "#/$defs/string" },
+        "reason_code": { "$ref": "#/$defs/string" }
+      }
+    },
+    "materialGap": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["question", "source_hints"],
+      "properties": {
+        "question": { "$ref": "#/$defs/string" },
+        "source_hints": { "type": "array", "items": { "$ref": "#/$defs/string" } }
+      }
+    },
+    "diagnostic": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["code", "message"],
+      "properties": {
+        "code": { "$ref": "#/$defs/string" },
+        "message": { "$ref": "#/$defs/string" },
+        "target": { "$ref": "#/$defs/string" }
+      }
+    },
+    "postAuthor": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "outcome", "proposals", "diagnostics"],
+      "properties": {
+        "stage": { "const": "post-author" },
+        "outcome": { "enum": ["complete", "failed"] },
+        "proposals": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["target", "artifact_kind", "title", "summary", "sections"],
+            "properties": {
+              "target": { "$ref": "#/$defs/string" },
+              "artifact_kind": { "$ref": "#/$defs/string" },
+              "title": { "$ref": "#/$defs/string" },
+              "summary": { "$ref": "#/$defs/string" },
+              "sections": {
+                "type": "array",
+                "minItems": 1,
+                "items": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": ["key", "heading", "markdown", "source_refs"],
+                  "properties": {
+                    "key": { "$ref": "#/$defs/string" },
+                    "heading": { "$ref": "#/$defs/string" },
+                    "markdown": { "$ref": "#/$defs/string" },
+                    "source_refs": {
+                      "type": "array",
+                      "minItems": 1,
+                      "items": { "$ref": "#/$defs/string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        "diagnostics": { "type": "array", "items": { "$ref": "#/$defs/diagnostic" } }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "outcome": { "const": "failed" } } },
+          "then": { "properties": { "diagnostics": { "minItems": 1 } } }
+        }
+      ]
+    },
+    "structureReview": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "decision"],
+      "properties": {
+        "stage": { "const": "structure-review" },
+        "decision": { "enum": ["approved", "request-adjustment"] },
+        "feedback": { "$ref": "#/$defs/string" }
+      }
+    },
+    "layoutConfirmation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "decision"],
+      "properties": {
+        "stage": { "const": "layout-confirmation" },
+        "decision": { "enum": ["approved", "rejected"] },
+        "feedback": { "$ref": "#/$defs/string" }
+      }
     }
   }
 }

package/providers/context/schemas/indexer-authorized-workset-view.schema.json

@@ -0,0 +1,65 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "context.indexer.authorized-workset-view/v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "protocol",
+    "operation",
+    "stage",
+    "workset_digest",
+    "execution_request_digest",
+    "source_ref",
+    "module_ref",
+    "projection_input_digests",
+    "items",
+    "view_digest"
+  ],
+  "properties": {
+    "protocol": { "const": "context.indexer.authorized-workset-view/v1" },
+    "operation": { "const": "main-index" },
+    "stage": { "enum": ["partition", "author"] },
+    "workset_digest": { "$ref": "#/$defs/digest" },
+    "execution_request_digest": { "$ref": "#/$defs/digest" },
+    "source_ref": { "type": "string", "minLength": 1 },
+    "module_ref": { "type": ["string", "null"] },
+    "projection_input_digests": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/digest" }
+    },
+    "items": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["ref", "category", "provenance", "value", "item_digest"],
+        "properties": {
+          "ref": { "type": "string", "minLength": 1 },
+          "category": { "type": "string", "minLength": 1 },
+          "provenance": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["protocol", "digest"],
+            "properties": {
+              "protocol": { "type": "string", "minLength": 1 },
+              "digest": { "$ref": "#/$defs/digest" },
+              "container_ref": { "type": "string", "minLength": 1 }
+            }
+          },
+          "value": {},
+          "item_digest": { "$ref": "#/$defs/digest" }
+        }
+      }
+    },
+    "view_digest": { "$ref": "#/$defs/digest" }
+  },
+  "$defs": {
+    "digest": {
+      "type": "string",
+      "pattern": "^sha256:[a-f0-9]{64}$"
+    }
+  }
+}