@tiangong-ai/cli 0.0.59 → 0.0.60

package/AGENTS.md

@@ -17,8 +17,8 @@ checkPaths:
   - .docpact/config.yaml
   - docs/agents/**
   - src/**
-lastReviewedAt: 2026-09-02
-lastReviewedCommit: 8a18ba69f432d2c639517549157ef29545722cff
+lastReviewedAt: 2026-09-03
+lastReviewedCommit: 06dadef170ab79c19eef9a35663e86fdee22479b
 ---
 
 # 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-03
+lastReviewedCommit: 06dadef170ab79c19eef9a35663e86fdee22479b
 ---
 
 # Tiangong AI CLI
@@ -712,9 +712,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
@@ -1016,6 +1022,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
@@ -1370,27 +1384,118 @@ 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.
+
+### 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.
+
+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. Positive/negative computational outcomes need a command and
+results; failed, inconclusive, and not-run checks remain honest without invented
+results. All records say `trust=native-observation`, `executionCertified=false`.
+
+One unchanged result blob is stored and included once per reviewer context. 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.
+
+`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
 

package/dist/research/orchestration.js

@@ -1,6 +1,7 @@
 import { lstat, readFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
 import { CliError } from "../errors.js";
+import { projectAuthority, projectWithEffectiveAuthority, readProjectAuthorityIndex, } from "./workspace/project-authority.js";
 import { stringifyJson, write } from "../io.js";
 import { parseStrictArgs, strictBoolean, strictString } from "../strict-args.js";
 import { researchSetupHelp, runResearchSetupCommand } from "./setup-command.js";
@@ -9,13 +10,16 @@ import { inspectResearchContext } from "./workspace/context.js";
 import { packageVersion } from "./workspace/constants.js";
 import { researchDataCredentialIds, setCapabilityCredentialValue, } from "./workspace/credentials.js";
 import { configureExternalSkillProfile, doctorExternalCapabilities, EXTERNAL_SKILL_CONTEXT_PROFILE, EXTERNAL_SKILL_MEDIA_PROFILE, EXTERNAL_SKILL_PROFILE, importExternalCapability, inspectExternalSkillCatalog, } from "./workspace/external-skills.js";
-import { appendJournalEvent, readJournal } from "./workspace/journal.js";
+import { appendJournalEvent } from "./workspace/journal.js";
 import { fetchNativeCandidateSource } from "./workspace/broker.js";
 import { preflightEvidenceArtifact, registerEvidenceArtifact } from "./workspace/artifacts.js";
 import { executeResearchDataCapability } from "./workspace/data-evidence-adapter.js";
 import { exportProjectAuditBundle, verifyProjectAuditBundle } from "./workspace/audit-bundle.js";
 import { loadCurrentEvidenceSnapshot } from "./workspace/acquisition.js";
 import { inspectAcquisitionForecast } from "./workspace/acquisition-forecast.js";
+import { reviseProjectAcquisition } from "./workspace/acquisition-revision.js";
+import { approveProjectTaskScope, defineProjectTask, isTaskSchemaName, proposeProjectTaskScope, taskInputSchema, } from "./workspace/task-contract.js";
+import { inspectProjectTask, recordProjectTaskAcceptance, taskAcceptanceInputSchema, } from "./workspace/task-acceptance.js";
 import { freezeEvidenceContentSnapshot, loadCurrentEvidenceContentSnapshot, recordArtifactDecomposition, registerEvidenceAtom, registerEvidenceContentBatch, } from "./workspace/content-evidence.js";
 import { inspectDiscoveryProgress } from "./workspace/discovery-status.js";
 import { EVIDENCE_CONTENT_LIMITS, EVIDENCE_CONTENT_SCHEMA_NAMES, evidenceContentInputSchema, isEvidenceContentSchemaName, } from "./workspace/evidence-content-schema.js";
@@ -104,6 +108,11 @@ export function researchOrchestrationHelp() {
   tiangong-ai research project preflight --question <question> [--goal evidence-report|top-journal] [--policy-project <project-id> --design <absolute-json>] [--requirements <absolute-json>] [--input-plan <absolute-json>] [--workspace <path>] [--json]
   tiangong-ai research project input add <project-id> --path <absolute-file> [--role primary|reference|replication] [--trust-status verified-owner-input|unverified-owner-input|reference-only|replication-candidate] [--independently-reproduced] [--workspace <path>] [--json]
   tiangong-ai research project retry <project-id> [--package <package-id>] [--workspace <path>] [--json]
+  tiangong-ai research project task define <project-id> --input <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project task status <project-id> [--workspace <path>] [--json]
+  tiangong-ai research project task acceptance record <project-id> --input <absolute-json> [--workspace <path>] [--json]
+  tiangong-ai research project task scope propose <project-id> --input <absolute-json> --expected-contract <sha256> [--workspace <path>] [--json]
+  tiangong-ai research project task scope approve <project-id> --proposal <sha256> --confirm-change <sha256> [--workspace <path>] [--json]
   tiangong-ai research project fork <source-project-id> --to <target-project-id> [--resume-through discover|acquire|analyze|synthesize] [--design <absolute-json> --design-producer-agent codex|claude --design-producer-session <opaque-id>] [--workspace <path>] [--json]
   tiangong-ai research project addendum <closed-project-id> --to <target-project-id> [--design <absolute-json> --design-producer-agent codex|claude --design-producer-session <opaque-id>] [--workspace <path>] [--json]
   tiangong-ai research project archive <project-id> --reason <text> [--workspace <path>] [--json]
@@ -134,8 +143,9 @@ export function researchOrchestrationHelp() {
   tiangong-ai research project evidence atom register <project-id> --record <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence content freeze <project-id> [--workspace <path>] [--json]
   tiangong-ai research project evidence content forecast <project-id> --input <absolute-acquisition-audit.json> [--workspace <path>] [--json]
+  tiangong-ai research project evidence acquisition revise <project-id> --expected-snapshot <sha256> --reason <text> [--include-discovery] [--workspace <path>] [--json]
   tiangong-ai research project evidence content status <project-id> [--workspace <path>] [--json]
-  tiangong-ai research schema show <discover|acquire|analyze|synthesize|review|doctor|scientific-design|scientific-assessment-research-design|scientific-assessment-evidence-construct|scientific-assessment-pilot-methods|scientific-review-research-design|scientific-review-evidence-construct|scientific-review-pilot-methods|publication-assessment|publication-review-evidence|publication-review-methods-reproducibility|publication-review-domain-novelty|publication-review-journal-editor> [--compatibility claude-code] [--json]
+  tiangong-ai research schema show <discover|acquire|analyze|synthesize|review|doctor|task-contract|task-scope-change|task-acceptance|scientific-design|scientific-assessment-research-design|scientific-assessment-evidence-construct|scientific-assessment-pilot-methods|scientific-review-research-design|scientific-review-evidence-construct|scientific-review-pilot-methods|publication-assessment|publication-review-evidence|publication-review-methods-reproducibility|publication-review-domain-novelty|publication-review-journal-editor> [--compatibility claude-code] [--json]
   tiangong-ai research status [--project <project-id>] [--all] [--workspace <absolute-path>] [--json]
   tiangong-ai research run [--project <project-id>] [--max-parallel <1-8>] [--max-cycles <1-100>] [--dry-run] [--progress-jsonl] [--workspace <absolute-path>] [--json]
 
@@ -506,7 +516,13 @@ async function runSchema(argv, io) {
         return writeHelp(io);
     const stage = onePositional(args.positionals, "research schema show");
     let schema;
-    if (isEvidenceContentSchemaName(stage)) {
+    if (stage === "task-acceptance") {
+        schema = taskAcceptanceInputSchema();
+    }
+    else if (isTaskSchemaName(stage)) {
+        schema = taskInputSchema(stage);
+    }
+    else if (isEvidenceContentSchemaName(stage)) {
         schema = evidenceContentInputSchema(stage);
     }
     else if (stage === "scientific-design") {
@@ -1025,8 +1041,79 @@ async function runProject(argv, io) {
         }
         throw unknownAction("research project stage", stageAction ?? "");
     }
+    if (action === "task") {
+        const [taskAction, ...taskRest] = rest;
+        if (taskAction === "acceptance") {
+            const [acceptanceAction, ...acceptanceRest] = taskRest;
+            if (acceptanceAction !== "record")
+                throw unknownAction("research project task acceptance", acceptanceAction ?? "");
+            const args = parseStrictArgs(acceptanceRest, { ...WORKSPACE_OPTIONS, input: "string" }, "research project task acceptance record");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project task acceptance record");
+            const result = await recordProjectTaskAcceptance(await workspaceFromArgs(args), projectId, await readBoundedJsonRecord(strictString(args, "input") ?? "", "--input", "RESEARCH_TASK_ACCEPTANCE_INVALID"));
+            writeJson(io, result, args);
+            return 0;
+        }
+        if (taskAction === "scope") {
+            const [scopeAction, ...scopeRest] = taskRest;
+            if (!["propose", "approve"].includes(scopeAction ?? ""))
+                throw unknownAction("research project task scope", scopeAction ?? "");
+            const args = parseStrictArgs(scopeRest, {
+                ...WORKSPACE_OPTIONS,
+                input: "string",
+                "expected-contract": "string",
+                proposal: "string",
+                "confirm-change": "string",
+            }, `research project task scope ${scopeAction}`);
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, `research project task scope ${scopeAction}`);
+            const root = await workspaceFromArgs(args);
+            const result = scopeAction === "approve"
+                ? await approveProjectTaskScope(root, projectId, strictString(args, "proposal") ?? "", strictString(args, "confirm-change"))
+                : await proposeProjectTaskScope(root, projectId, strictString(args, "expected-contract") ?? "", await readBoundedJsonRecord(strictString(args, "input") ?? "", "--input", "RESEARCH_TASK_INVALID"));
+            writeJson(io, result, args);
+            return 0;
+        }
+        if (taskAction !== "define" && taskAction !== "status")
+            throw unknownAction("research project task", taskAction ?? "");
+        const args = parseStrictArgs(taskRest, { ...WORKSPACE_OPTIONS, input: "string" }, `research project task ${taskAction}`);
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, `research project task ${taskAction}`);
+        const root = await workspaceFromArgs(args);
+        const result = taskAction === "status"
+            ? await inspectProjectTask(root, projectId)
+            : await defineProjectTask(root, projectId, await readBoundedJsonRecord(strictString(args, "input") ?? "", "--input", "RESEARCH_TASK_INVALID"));
+        writeJson(io, result, args);
+        return 0;
+    }
     if (action === "evidence") {
         const [evidenceAction, ...evidenceRest] = rest;
+        if (evidenceAction === "acquisition") {
+            const [revisionAction, ...revisionRest] = evidenceRest;
+            if (revisionAction !== "revise")
+                throw unknownAction("research project evidence acquisition", revisionAction ?? "");
+            const args = parseStrictArgs(revisionRest, {
+                ...WORKSPACE_OPTIONS,
+                "expected-snapshot": "string",
+                reason: "string",
+                "include-discovery": "boolean",
+            }, "research project evidence acquisition revise");
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, "research project evidence acquisition revise");
+            const result = await reviseProjectAcquisition({
+                root: await workspaceFromArgs(args),
+                projectId,
+                expectedSnapshotSha256: strictString(args, "expected-snapshot") ?? "",
+                reason: strictString(args, "reason") ?? "",
+                includeDiscovery: strictBoolean(args, "include-discovery"),
+            });
+            writeJson(io, result, args);
+            return 0;
+        }
         if (evidenceAction === "data") {
             const [dataAction, ...dataRest] = evidenceRest;
             if (dataAction !== "run") {
@@ -1287,7 +1374,9 @@ async function runProject(argv, io) {
                 const value = await readBoundedJsonRecord(inputPath, "--input", "RESEARCH_ACQUISITION_FORECAST_INVALID");
                 const result = await inspectAcquisitionForecast(root, projectId, value);
                 writeJson(io, result, args);
-                return result.acquisitionGate.decision === "pass" && !result.knownRoleDeficits.length
+                return result.submissionGate.decision !== "stop" &&
+                    result.acquisitionGate.decision === "pass" &&
+                    !result.knownRoleDeficits.length
                     ? 0
                     : 3;
             }
@@ -1603,12 +1692,8 @@ async function runStatus(argv, io) {
     const root = await workspaceFromArgs(args);
     const config = await loadWorkspaceConfig(root);
     const selectedProject = strictString(args, "project");
-    const workspaceProjects = await listProjects(root);
-    const committedForkTargets = new Set((await readJournal(workspacePaths(root).journal))
-        .filter((event) => event.type === "project.forked" &&
-        isObject(event.payload) &&
-        typeof event.payload.targetProjectId === "string")
-        .map((event) => String(event.payload.targetProjectId)));
+    const authorityIndex = await readProjectAuthorityIndex(root);
+    const workspaceProjects = await listProjects(root, authorityIndex);
     const allProjects = selectedProject
         ? [
             workspaceProjects.find((project) => project.id === selectedProject) ??
@@ -1617,9 +1702,7 @@ async function runStatus(argv, io) {
         : workspaceProjects;
     const projects = selectedProject || strictBoolean(args, "all")
         ? allProjects
-        : allProjects.filter((project) => project.lineage.supersededBy === null &&
-            project.status !== "archived" &&
-            project.status !== "abandoned");
+        : allProjects.filter((project) => ["authoritative", "invalid"].includes(projectAuthority(project, authorityIndex).state));
     const result = {
         workspace: root,
         execution: {
@@ -1638,7 +1721,7 @@ async function runStatus(argv, io) {
         },
         hiddenSupersededProjects: selectedProject || strictBoolean(args, "all")
             ? 0
-            : workspaceProjects.filter((project) => project.lineage.supersededBy !== null).length,
+            : workspaceProjects.filter((project) => authorityIndex.successors.has(project.id)).length,
         hiddenArchivedProjects: selectedProject || strictBoolean(args, "all")
             ? 0
             : workspaceProjects.filter((project) => project.status === "archived").length,
@@ -1646,13 +1729,13 @@ async function runStatus(argv, io) {
             ? 0
             : workspaceProjects.filter((project) => project.status === "abandoned").length,
         projects: await Promise.all(projects.map(async (project) => {
-            const current = refreshProject(project);
-            const authority = projectAuthority(current, workspaceProjects, committedForkTargets);
+            const current = refreshProject(projectWithEffectiveAuthority(project, authorityIndex));
+            const authority = projectAuthority(current, authorityIndex);
             const nativeStage = await inspectNativeResearchStage(root, current);
             const evidencePipeline = await inspectEvidencePipelineForStatus(root, current);
             const snapshot = evidencePipeline.acquisition;
             const readyPackage = nextReadyPackage(current)?.id ?? null;
-            const scientificReview = await inspectScientificReviewStatus(root, current.id);
+            const scientificReview = await inspectScientificReviewStatus(root, current.id, current);
             const evidenceAccess = current.scientificDesign
                 ? await inspectEvidenceAccessForStatus(root, current.id)
                 : null;
@@ -1671,6 +1754,7 @@ async function runStatus(argv, io) {
                 evidencePipeline,
                 nativeStage,
                 scientificReview,
+                task: await inspectProjectTask(root, current.id, authorityIndex.taskEvents.get(current.id) ?? []),
                 evidenceAccess,
                 publication,
                 readyPackage,
@@ -1786,33 +1870,6 @@ async function inspectEvidenceAccessForStatus(root, projectId) {
         };
     }
 }
-function projectAuthority(project, projects, committedForkTargets) {
-    if (project.lineage.kind === "fork" && !committedForkTargets.has(project.id)) {
-        return { state: "invalid", projectId: project.id };
-    }
-    const byId = new Map(projects.map((candidate) => [candidate.id, candidate]));
-    const visited = new Set([project.id]);
-    let current = project;
-    while (current.lineage.supersededBy) {
-        if (visited.has(current.lineage.supersededBy))
-            break;
-        visited.add(current.lineage.supersededBy);
-        const next = byId.get(current.lineage.supersededBy);
-        if (!next)
-            return { state: "superseded", projectId: current.lineage.supersededBy };
-        if (next.lineage.kind === "fork" && !committedForkTargets.has(next.id))
-            break;
-        current = next;
-    }
-    if (project.status === "archived")
-        return { state: "archived", projectId: current.id };
-    if (project.status === "abandoned")
-        return { state: "abandoned", projectId: current.id };
-    return {
-        state: project.id === current.id ? "authoritative" : "superseded",
-        projectId: current.id,
-    };
-}
 async function inspectSnapshotForStatus(root, projectId) {
     const currentPath = join(workspacePaths(root).projects, projectId, "outputs", "evidence-snapshot.json");
     if (!(await pathExists(currentPath)))