@tiangong-ai/cli 0.0.59 → 0.0.61

package/AGENTS.md

@@ -17,8 +17,8 @@ checkPaths:
   - .docpact/config.yaml
   - docs/agents/**
   - src/**
-lastReviewedAt: 2026-09-02
-lastReviewedCommit: 8a18ba69f432d2c639517549157ef29545722cff
+lastReviewedAt: 2026-09-04
+lastReviewedCommit: 4cb45f23331677a7c713f20f3aa3cbb65afe9358
 ---
 
 # Tiangong AI CLI Contract

package/README.md

@@ -12,8 +12,8 @@ checkPaths:
   - package.json
   - bin/**
   - src/**
-lastReviewedAt: 2026-09-02
-lastReviewedCommit: 8a18ba69f432d2c639517549157ef29545722cff
+lastReviewedAt: 2026-09-04
+lastReviewedCommit: 25b236a15c846c0168ffb84f8afa390d71985f4b
 ---
 
 # Tiangong AI CLI
@@ -607,8 +607,9 @@ owns the same due gate. Pending implementations use `null` for implementation
 SHA-256, locator, and entrypoint; pending environments use `null` for lock
 SHA-256 and locator. They are exposed in every earlier review packet as
 `futureGateObligations` and become blocking mechanical errors at that gate.
-Freezing them requires a new authoritative generation; it never upgrades the
-old object in place.
+Their predeclared slots may be fulfilled through the append-only same-project
+command below. The original design bytes never change; a material assumption,
+question, policy or already-frozen value still requires a reviewed successor.
 
 Use the same Policy project ID and exact design when preflighting and admitting
 the research project:
@@ -677,6 +678,16 @@ schema-valid, packet/session-bound review. A saved successful execution is
 replayed without another model call after revalidating its immutable proof.
 Failures require explicit `--retry` and remain bounded by the attempt budget;
 unreported usage and interrupted wall time retain conservative reservations.
+Failed processes return a bounded, sanitized exit diagnostic and record it in
+the journal; no full prompt or raw authentication output is persisted. Automatic
+Claude invocation uses the same dialect-annotation conversion as
+`research schema show NAME --compatibility claude-code`; canonical controller
+validation and its scientific constraints remain unchanged.
+The provider view explicitly types scalar constants/enums; returned values are
+never coerced to satisfy the canonical schema.
+Claude's structured result is used instead of any accompanying narrative;
+declared error results remain failures, with their safe diagnostic ahead of
+incidental stderr warnings.
 A nonpassing mechanical packet can receive an independent stop verdict, never
 an override. The existing manual submit command remains available for an exact
 independent review.
@@ -685,6 +696,8 @@ Reviewer status is read-only and transport-aware. Native-direct does not
 require a bridge connection. Smoke configuration readiness is explicitly not
 production readiness and does not demand an attestation that smoke mode never
 writes. Production still requires its current reviewer doctor attestation.
+Packet read responses carry their actual content and receipt together; a
+receipt alone does not establish that the host displayed the content to its model.
 
 Repeat the same prepare/execute route for `evidence-construct`, adding an
 owner-reviewed JSON array of absolute canonical canary paths with
@@ -712,9 +725,15 @@ submission manifest must bind distinct absolute files for cover letter, title
 page, reporting checklist, data availability, code availability, and source
 data; figure/table index, extended data, and supplementary methods are optional.
 `research publication freeze` then content-addresses the Policy, scientific
-design and early reviews, acquisition/content/inference snapshots, reproduced
+design and early reviews, acquisition/content/inference snapshots, mode-bound
 analysis, Claim-Evidence Graph, base outputs, manuscript, assessment,
 supplements, role-complete submission files, and reproducibility manifest.
+Computational/mixed analysis still requires reproduced metadata with exact
+implementation/environment bindings. Qualitative analysis uses
+`status: not-applicable`, null command/seed and empty implementation/environment
+lists; it must not invent a computation. Both paths retain the same evidence,
+graph, Policy and independent-review checks. Metadata alone is not proof that
+a computation was executed.
 Exactly four fresh independent sessions review that frozen generation:
 evidence, methods/reproducibility, domain/novelty, and journal-editor. A revised
 manuscript invalidates prior reviews. Every reviewer must use the configured
@@ -753,6 +772,12 @@ derivatives. Credentials, setup
 sources, browser profiles, native active state, capsules, unrelated projects,
 and host-specific absolute paths are excluded.
 
+Text inspection distinguishes internal identifiers such as `interruptedSessionId`
+from credential fields. It checks raw text and read-only decoded JSON/JSONL,
+including escaped keys and nested string payloads, while retaining the exact
+evidence and ledger bytes. Authentication values remain blocked even when wrapped
+in arrays or objects; an identifier's UUID shape is never a credential exemption.
+
 ```bash
 tiangong-ai research project audit export top-journal-paper \
   --output /absolute/path/to/new-audit-directory \
@@ -853,8 +878,10 @@ For large local sources, pass an immutable `--input-plan` to both preflight and
 project initialization. Each plan entry may expose either a separate
 `contextPath` or non-overlapping, one-based `contextRanges`; the producer sees
 only that bounded context, while independent review receives the hash-verified
-full source. Symlinks, duplicate content, changed hashes, and context above
-`maxInputContextTokens` are rejected.
+full source. Symlinks, duplicate content and changed hashes are rejected.
+There is no total stage-context length gate: large admitted objects remain complete
+and are read through the packet's artifact directory instead of being forced into
+the initial prompt. This does not expose files deliberately withheld by an input plan.
 
 The workspace stores its current protocol state under `.tiangong-research/`.
 Each project follows the evidence-first sequence: broad discovery, strict
@@ -865,6 +892,13 @@ CodeBuddy session. The CLI never launches a nested producer process. Independent
 runs through the other configured agent family's CLI, and execution is blocked
 when the two roles use the same family.
 
+Native packets direct the host to save one new JSON submission file, not to write
+admitted output paths. Acquire may retrieve files and readable derivatives for
+provisionally admitted sources through the packet's binding/registration commands;
+it may not reopen discovery. Analyze, synthesize and the isolated reviewer retain
+their no-new-evidence boundary. Headless reviewer prompts remain capsule-scoped
+and return JSON rather than saving native submission files.
+
 Every workspace mutation is serialized by an owner-recorded directory lease
 with a heartbeat. A later command immediately reclaims a lease whose same-host
 owner process is definitely dead; an unverifiable cross-host lease is reclaimed
@@ -1016,6 +1050,14 @@ deficits; exit `0` means only potential eligibility, never successful atom
 registration, content freeze, independence certification, or review. Pending
 input materialization, decomposition, and exact atom assignments remain
 explicit. Re-run after material acquisition changes, not after every atom.
+`submissionGate` separately reports deterministic acquire-submit blockers;
+`potentially-ready` is not an inference/content pass. An accepted binary without
+required readable content stops before submission, while an honest incomplete
+audit may still freeze its limitations and separate inference-stop decision.
+An admitted local PDF/Office file alone is not producer-readable. Forecast uses
+the same media rules as artifact registration and reports a missing readable
+derivative unless a verified readable artifact or admitted text/context input
+is available. This classification does not reread or decode the binary again.
 Flat `sourceTypeRequirements` arrays mean **all-of**. A design may instead use
 `{"allOf":["academic-paper"],"anyOf":["government","industry"],"atLeast":{"count":2,"from":["academic-paper","government","industry"]}}`;
 every present group applies, and counts use distinct types. Forecast, typed
@@ -1151,7 +1193,8 @@ total tokens, USD 5,000, 30 days, and package ceilings of 12,000,000 for discove
 acquisition, 1,500,000 each for analysis and synthesis, and 2,500,000 for
 review. Primary output is bounded at 32,000 tokens and a separately invoked
 repair at 16,000. The production broker hard ceiling is 256 bounded views with
-32,000 context tokens per view; input context is bounded at 128,000 tokens.
+32,000 context tokens per broker view. The legacy `maxInputContextTokens` setting
+is an embedding/planning hint, not an input admission or artifact-read ceiling.
 Top-journal admission additionally reserves three early scientific reviews at
 500,000 tokens each, four final publication reviews at 750,000 each, and one
 4,000,000-token revision cycle, including their finite wall-time allowances.
@@ -1160,7 +1203,7 @@ stop control ordinary use, while the finite ceilings, three attempts per
 package, and explicit confirmation above the cost threshold stop runaway work.
 Smoke-test workspaces retain their smaller low-cost defaults.
 Before project initialization and every executable package, the control plane
-requires the complete token and conservative price reservation to fit. Native
+requires a token and conservative price estimate to fit the finite execution budget. Native
 producer stages reserve prompt, schema, admitted context, bounded broker
 context, and output allowance, but the host app does not expose trusted
 per-stage usage telemetry to this CLI. A successful native submit therefore
@@ -1170,9 +1213,14 @@ output bytes/tokens, provenance, coverage, hashes, and remaining project budget.
 It does not claim a provider-side turn or output-token cap for the host app.
 
 Independent review uses the pre-call reservation calculator and the reviewer's
-provider-side structured-output/turn controls where available. Review admission
-reserves three maximum-size generated artifacts plus one globally bounded
-evidence-excerpt bundle, and formatting repair remains one separately budgeted,
+provider-side structured-output/turn controls where available. Claude packet-only
+review has a 64-turn provider guard; Codex uses the existing finite wall-time and
+token/cost guards because its CLI has no equivalent turn flag. Planning uses a
+small initial-context estimate and expected reads, not the entire corpus or an
+unbounded legacy context hint. Preflight reports `inputContextTokenLimit=null`.
+These are approximate estimates, not precise billing; scientific review keeps
+the approved remaining cost ceiling separate from its rough read-cost estimate.
+Formatting repair remains one separately budgeted,
 tool-free JSON correction. Production workspaces enforce a finite 256-view
 broker ceiling mechanically, while each project derives a much smaller working
 budget from its reviewed coverage requirements and stops early when they are
@@ -1197,8 +1245,9 @@ context, evidence objects, and registered local input hashes before recording
 their safe locators. Capsule deletion therefore does not delete the durable
 review chain.
 
-Native discovery preparation embeds the exact staged capability manifest and
-each external Skill's top-level `SKILL.md`. It also projects every built-in data
+Native discovery preparation supplies the exact staged capability manifest and
+each external Skill's top-level `SKILL.md` inline or by an exact artifact reference.
+It also projects every built-in data
 operation dynamically, with no per-provider Research adapter. The current host
 may fetch generic broker evidence with `research project evidence fetch`, whose bounded request file
 contains logical IDs but no credential values. The manifest includes the locked,
@@ -1226,19 +1275,37 @@ credentialed operation must resolve its namespaced logical credential from the
 workspace's owner-only store or it is blocked before any provider request.
 Standalone `tiangong-ai data run` keeps its separate manifest-declared
 environment-variable policy. A blocked data result is not promoted to evidence.
-Analyze and synthesize packets contain bounded, hash-verified prior-stage
-artifacts and require no external evidence calls. Review is tool-free and uses the
-reviewer's route-specific structured-output turn cap:
-its prompt embeds the complete generated artifacts and a deterministic,
-globally bounded set of excerpts distributed across registered local contexts
-and broker receipts. Broker excerpts prioritize deterministic, sanitized
+Analyze and synthesize packets contain hash-verified prior-stage artifacts and
+require no external evidence calls. Base and scientific review use only the
+packet-bound `research_list_artifacts` and `research_read_artifact` tools; shell,
+general filesystem, browser, broker and undeclared integrations remain disabled.
+The same surface works through native-direct and the signed sandbox-bridge.
+Small objects/excerpts are included initially; large objects are referenced without
+rejecting the stage. Broker excerpts prioritize deterministic, sanitized
 projections of the exact raw-response items selected by admitted evidence JSON
 Pointers; uncited receipts retain metadata-only bindings, and unresolved
 pointers receive a bounded-context fallback. The packet hash is schema-bound, but complete packet
 metadata is not redundantly copied into model context. Full local files,
-original per-receipt bounded contexts, raw broker objects, and the complete
-packet remain hash-bound for durable human/mechanical audit; the model must not
-claim to have read beyond the embedded excerpts.
+original per-receipt contexts, raw broker objects, checks and counterevidence stay
+discoverable in the exact directory. Reads use opaque object IDs and byte offsets;
+UTF-8 pages preserve character boundaries. Omit `length` for a 16 KiB page or use
+`length: null` for the whole object, without a CLI read-length ceiling. Objects
+actually read are preserved under `reads/objects/`, with exact directory and
+packet/object/view hash receipts. Receipts prove bytes delivered, not comprehension
+or scientific truth; actual provider/model capacity remains a limitation.
+
+Native hosts can use the same primitives without adding an IDE integration:
+
+```bash
+tiangong-ai research project stage artifacts PROJECT --session SESSION --workspace /absolute/workspace --json
+tiangong-ai research project stage read PROJECT --session SESSION --artifact OBJECT_ID --offset 0 --length 16384 --workspace /absolute/workspace --json
+tiangong-ai research project stage read PROJECT --session SESSION --artifact OBJECT_ID --length all --workspace /absolute/workspace --json
+```
+
+Follow `nextOffset` for subsequent pages. `--encoding base64` explicitly requests
+binary bytes; prefer a registered text derivative for interpretation. The channel
+does not scan arbitrary host paths or discover files created after the snapshot.
+Stopped, changed or expired native sessions cannot read through it.
 The CLI mechanically derives local full-text availability, source types,
 counts, date coverage, source IDs, and the coverage decision. A `partial`
 dimension is usable but incomplete; a missing dimension or unmet declared
@@ -1370,27 +1437,206 @@ read-only under `outputs/revisions/synthesize/<sha256>/report.md`; review and
 closure are invalidated, while unchanged discovery, acquisition, content,
 inference, analysis, and graph objects remain bound.
 
-Recovery fork writes are rollback-protected. If inherited output, content,
-inference, or graph validation fails, the target directory is removed and
-source authority is restored. A source typed-content snapshot is revalidated
+Recovery forks have one journal commit point. Before `project.forked` commits,
+their target is staging, not an authoritative project; the original source
+remains authoritative. Status, run and native/reviewer admission share that
+same verified lineage view. A source typed-content snapshot is revalidated
 and re-signed for the target generation instead of copying its project-bound
 hash. Top-journal generations may resume only through `acquire`, because the
 target-specific scientific design must complete fresh evidence-construct and
-pilot-methods reviews before analysis. `research status --all` marks any legacy
-fork directory without a `project.forked` commit marker as
-`authority.state = "invalid"` rather than authoritative.
-
-To repair completed acquisition before analysis, use
-`research project fork SOURCE --to TARGET --resume-through discover`. This
-preserves the original frozen audit, inherits verified discovery/receipts and
-exact acquired artifacts, and opens TARGET's acquire stage. Reuse the returned
-artifact IDs from the source acquisition audit, run
-`project evidence content forecast TARGET --input AUDIT`,
-then prepare/submit TARGET's acquire stage and rebuild typed content. There is
-no need to repeat paid searches or download unchanged files. Top-journal
-recovery additionally requires a Policy approved for TARGET and `--design`,
-`--design-producer-agent`, and `--design-producer-session`; new generation
-reviews cannot inherit the source generation's scientific approval.
+pilot-methods reviews before analysis.
+
+After process interruption, repeat the same explicit fork request. The next
+lease holder settles only hash-bound CLI-owned pending operations: before
+commit it retains the interrupted target under
+`lineage/interrupted-project-mutations/<operation-id>/target`, outside the
+project namespace; after commit it finishes source/ledger projections. Exact
+committed replay returns the existing target without recopying evidence or
+repeating provider work. A different request for that target is a conflict.
+An unchanged completed retry request is likewise acknowledged without another
+revision or attempt. A subsequent real failure can still be retried normally.
+
+Unknown targets, symlink replacements, modified source state and invalid
+recovery metadata are not overwritten or deleted. Resolve the reported
+`RESEARCH_PROJECT_RECOVERY_REQUIRED` conflict or restore a trusted backup before
+retrying; do not forge control files. Read-only status ignores never-committed
+directories without project state and reports existing uncommitted derived
+states as invalid. Missing state for a committed project is still an error.
+Recovery does not truncate a corrupt journal or claim power-loss durability.
+
+To repair completed acquisition before any analysis attempt, prefer an explicit
+same-project revision when question, Policy, design, and requirements are unchanged:
+
+```bash
+tiangong-ai research project evidence acquisition revise PROJECT \
+  --expected-snapshot <current-acquisition-sha256> \
+  --reason "Add the verified readable derivative before analysis" \
+  --workspace /absolute/workspace --json
+```
+
+This reopens acquire, preserves discovery, exact artifacts/receipts, historical
+snapshot bytes, budgets already spent, and the research-design approval. It
+invalidates evidence-construct and pilot-methods approvals because their evidence
+changed. Add `--include-discovery` only when new sources must be discovered or
+admitted; that explicitly reopens discover then acquire without a new project or
+automatic provider call. Prepare the returned stage, reuse unchanged objects,
+forecast once per meaningful batch, submit the complete revised audit, and rebuild
+typed content. Exact revision replay is idempotent. Stale snapshots, active native
+sessions, unresolved handoffs, inference freezes, and later attempts are refused.
+
+Changed failed/limited decomposition records can be superseded under a descendant
+acquisition snapshot; unchanged records are reused. Single and batch intake share
+this rule. Historical records remain immutable, and atoms from deselected artifacts
+cannot fill current coverage. Same-snapshot conflicting extraction still fails.
+
+Actual question/Policy/design changes or post-analysis work require the existing
+fork/addendum flow. Pre-feature snapshots without immutable evidence records cannot
+be repaired in place; use `research project fork SOURCE --to TARGET
+--resume-through discover` to reuse discovery/receipts/artifacts, or explicitly
+start a new generation. There is no automatic migration. A top-journal successor
+requires a Policy approved for TARGET and `--design`, `--design-producer-agent`,
+and `--design-producer-session`; it cannot inherit scientific approval.
+
+### Fulfill predeclared scientific objects
+
+At an idle boundary before analysis, register the exact code/environment files
+as scientific objects, then supply only the pending slots already named in the
+frozen design:
+
+```bash
+tiangong-ai research schema show scientific-fulfillment --json
+tiangong-ai research scientific fulfillment status PROJECT --workspace /absolute/workspace --json
+tiangong-ai research scientific fulfillment record PROJECT \
+  --input /absolute/fulfillment.json --workspace /absolute/workspace --json
+```
+
+The closed input names `designSha256`, the exact `parentFulfillmentSha256`
+(`null` initially), a non-sensitive reason, and arrays `modelImplementations`,
+`environmentLocks`, and `parameterStates`. Model entries bind the registered
+`objectLocator`, raw `sha256`, registration `recordSha256`, and the declared
+`modelId`; implementations additionally supply `entrypoint`. Parameter entries
+name the existing `parameterId` and every exact `stateId`, its source-derived
+`value`, and admitted `evidenceAtomIds` from the frozen typed-content snapshot.
+Units, state sets, ranges, factors, composition, claims, thresholds and Policy
+cannot be changed through this intake. At least one pending slot is required.
+
+Identical replay returns the same immutable record. Replacing an already-frozen
+slot, guessing a parent, an active native session, or analysis/inference already
+started is refused. The journal is the commit point; interrupted state projection
+uses the same narrow recovery mechanism as acquisition/scope revisions.
+
+Only the fulfillment's due gate and later scientific gates are reset; earlier
+reviews remain bound to their unchanged deadline-specific design view. New review
+packets include the original design, the exact fulfillment chain, the effective
+view and registered code/environment bytes. Filing objects does **not** mark the
+original Policy rule scientifically satisfied or certify code execution. The
+existing independent reviewer must assess the actual objects and rule. Portable
+audits retain the raw objects and registration metadata and verify the committed
+fulfillment head, slot semantics and current review view after relocation.
+
+### Original task, current scope, and actual checks
+
+For a new research project, record a small original-requirement checklist after
+project initialization and before any producer execution or scientific review.
+The native host authors the content; the CLI owns its schema and hash bindings:
+
+```bash
+tiangong-ai research schema show task-contract --json
+tiangong-ai research project task define PROJECT \
+  --input /absolute/task.json --workspace /absolute/workspace --json
+tiangong-ai research project task status PROJECT --workspace /absolute/workspace --json
+```
+
+Each requirement has a stable ID, acceptance condition, `checkKind` (`evidence`,
+`computation`, or `proof`), and optional bindings to existing design claims and
+coverage dimensions. Original wording cannot be overwritten. Old projects without
+a task remain explicitly unassessed rather than retrospectively accepted.
+
+Optional `requestProvenance` supplies `mode` (`verbatim`, `interpreted`, or
+`reconstructed`), `source` (`kind: user-message|user-file`, exact `text`, `locator`
+or null), and `explanation`. A null source is valid only for reconstruction.
+Verbatim source text must equal `originalRequest` exactly, including BOM and line
+endings. Source bytes are immutable; locator values are retained only by hash.
+Missing provenance is explicitly `unrecorded`, never inferred retroactively.
+Scope changes and forks preserve it. Declared origin is not authenticated authorship;
+secrets are rejected before admission.
+Scientific review also stages the exact supplied request-source object, so its
+original bytes are available through the same packet-only read channel as its hash.
+
+Before analysis, use `research schema show task-scope-change` and
+`project task scope propose PROJECT --input FILE --expected-contract SHA` to
+propose a change. Review the returned `changes.details` before/after values, then
+approve only with both `--proposal SHA` and `--confirm-change SHA` on
+`project task scope approve`. A generic continue instruction is not scope consent.
+The record is an **operator confirmation**, not authenticated proof of a human's
+identity. Scope approval does not rewrite scientific design or evidence floors;
+it invalidates prior scoped scientific reviews. Withdrawn original requirements
+remain visible and a fork/addendum retains original history without inheriting
+task completion.
+
+Use `research schema show task-acceptance` and
+`project task acceptance record PROJECT --input FILE` after acquisition and
+between native stages. Records bind the exact requirement version, source/atom/
+finding IDs, and explicitly selected bounded UTF-8 result files. The declared
+command is stored only by hash and is **not executed by this command**. Raw result
+bytes are copied into immutable hash-addressed objects; secrets and control-store
+sources are rejected. A reported computation without an observed run remains
+`unverified-execution`, not an answered computational requirement. Failed,
+inconclusive and not-run checks remain honest without invented results. Evidence
+and proof checks need no fabricated computation. All records say
+`trust=native-observation`, `executionCertified=false`.
+
+For an actual calculation, the native host authors and reviews one ordinary
+Node/Python program and explicitly requests observation:
+
+```bash
+tiangong-ai research schema show task-native-run --json
+tiangong-ai research project task run observe PROJECT \
+  --input /absolute/native-run.json --confirm-execution --workspace /absolute/workspace --json
+tiangong-ai research project task run inspect PROJECT --run RUN_ID \
+  --workspace /absolute/workspace --json
+```
+
+The closed request binds the computational requirement version, explicit
+interpreter, script, environment-lock declaration, current acquisition artifact
+IDs/hashes, unique output filenames, non-secret arguments and finite timeout.
+Use `{input:ID}` / `{output:ID}` placeholders rather than host paths in arguments,
+and name `nativeSessionId` when a producer stage is active. The CLI snapshots
+inputs and plans exact output paths before invoking the ordinary program. It
+adds no permission bypass or dependency installation, forwards no provider
+credentials and launches no reasoning agent. The workspace lease is released
+during computation. Program authoring and scientific decisions remain native.
+
+The returned record binds runtime/code/input/output bytes, process exit/signal
+and time. Use `nativeRunSha256` at acceptance; those results come only from that
+run, not a directory scan or unrelated external files. Success requires a zero
+exit, stable inputs and every declared output; failure/timeout/cancellation and
+missing or changed outputs remain nonpassing records. Committed replay does not
+run again. An incomplete interrupted run requires inspection and an explicitly
+new run ID, not automatic retry. `stagingDirectoryName` is only a safe relative
+local-inspection hint; permanent hash-bound objects carry audit authority.
+`observation=cli-observed-native-process` is not mathematical correctness or an
+authenticated execution certificate. The dependency lock is explicitly
+`declared-lock-not-attested`; no hermetic-environment claim is inferred.
+
+One unchanged result blob is stored once and appears once in the reviewer directory. The
+existing independent review receives the original request, original/current
+requirements, exact checks and results, and returns a bound `taskAssessment`;
+there is no additional default paid review round. Missing current checks stop
+before review, and stale/failed/inconclusive checks cannot be promoted to answered.
+Publication packets and portable audit verification retain these relationships;
+hash integrity does not prove execution, scientific validity, or editorial acceptance.
+Native and scientific packets stage observed programs, locks, inputs and outputs
+for exact on-demand inspection. Portable audit checks native start/completion
+events, requirement versions and all run objects. It also replays read selectors
+against the exact stored object, directory and packet/delivery records; a rehashed
+outer inventory cannot hide missing program bytes or a changed read receipt.
+
+`project task status` and each `research run` project summary report original and
+current task completion separately from workflow completion and publication verdict.
+A completed workflow or approved reduced scope must not be described as satisfying
+unanswered original requirements. Use the selected runtime's help/schema discovery
+once before adopting these commands; they are not an implicit runtime upgrade.
 
 ## Research Search