@tiangong-ai/cli 0.0.59 → 0.0.61

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";
@@ -27,16 +31,19 @@ import { recordNativeResearchActivity } from "./workspace/native-activity.js";
 import { inspectReviewerStatus, startReviewerBridgeSidecar } from "./workspace/review-executor.js";
 import { readAndVerifyProjectInputPlan } from "./workspace/input-plan.js";
 import { executeScientificReview } from "./workspace/scientific-review-execution.js";
+import { claudeCodeCompatibleSchema } from "./workspace/schema-compatibility.js";
 import { loadCurrentClaimEvidenceGraph, loadCurrentInferenceSnapshot, } from "./workspace/inference.js";
 import { addProjectInput, createProjectAddendum, initializeProject, forkProject, listProjects, loadProject, nextReadyPackage, normalizeEvidenceRequirements, refreshProject, retryProjectPackage, setProjectDisposition, scientificGateRecommendedAction, } from "./workspace/projects.js";
 import { evaluateProjectPreflight } from "./workspace/preflight.js";
 import { closePublication, freezePublicationManuscript, inspectPublicationStatus, preparePublicationReview, publicationAssessmentSchema, publicationReviewSchema, submitPublicationReview, } from "./workspace/publication-workflow.js";
 import { approveResearchPolicy, initializeResearchPolicy, inspectResearchPolicyCatalog, inspectResearchPolicyStatus, loadApprovedResearchPolicy, } from "./workspace/research-policy.js";
 import { resolveInstalledResearchPolicySource, runInteractiveResearchPolicyWizard, } from "./workspace/research-policy-wizard.js";
-import { abortNativeResearchStage, inspectNativeResearchStage, prepareNativeResearchStage, requestResearchHandoff, resolveResearchHandoff, runResearchWorkspace, submitNativeResearchStage, } from "./workspace/runtime.js";
+import { abortNativeResearchStage, inspectNativeResearchStage, prepareNativeResearchStage, readNativeStageArtifact, requestResearchHandoff, resolveResearchHandoff, runResearchWorkspace, submitNativeResearchStage, } from "./workspace/runtime.js";
 import { schemaForStage } from "./workspace/schemas.js";
 import { readAndVerifyScientificDesign, scientificDesignSchema, } from "./workspace/scientific-design.js";
 import { inspectScientificObject, parseScientificObjectKind, registerScientificObject, } from "./workspace/scientific-objects.js";
+import { inspectScientificFulfillment, recordScientificFulfillment, scientificFulfillmentSchema, } from "./workspace/scientific-fulfillment.js";
+import { inspectNativeRun, nativeRunInputSchema, observeNativeRun, } from "./workspace/native-run.js";
 import { inspectScientificReviewStatus, prepareScientificReview, scientificGateAssessmentSchema, scientificReviewSchema, submitScientificReview, } from "./workspace/scientific-review.js";
 import { isObject, pathExists, sha256Text, workspacePaths } from "./workspace/storage.js";
 import { doctorResearchWorkspace, initializeResearchWorkspace, loadWorkspaceConfig, requireResearchWorkspace, withWorkspaceLock, } from "./workspace/workspace.js";
@@ -100,10 +107,19 @@ export function researchOrchestrationHelp() {
   tiangong-ai research publication close <project-id> [--workspace <path>] [--json]
   tiangong-ai research scientific object register --kind model-implementation|environment-lock --path <absolute-file> [--media-type <type>] [--workspace <path>] [--json]
   tiangong-ai research scientific object inspect --kind model-implementation|environment-lock --locator <control-relative-locator> [--workspace <path>] [--json]
+  tiangong-ai research scientific fulfillment record <project> --input <json-file> [--workspace <path>] [--json]
+  tiangong-ai research scientific fulfillment status <project> [--workspace <path>] [--json]
+  tiangong-ai research project task run observe <project> --input <json-file> --confirm-execution [--workspace <path>] [--json]
+  tiangong-ai research project task run inspect <project> --run <run-id> [--workspace <path>] [--json]
   tiangong-ai research project init <project-id> --question <question> [--goal evidence-report|top-journal] [--design <absolute-json> --design-producer-agent codex|claude --design-producer-session <opaque-id>] [--requirements <absolute-json>] [--input-plan <absolute-json>] [--confirm-budget] [--workspace <path>] [--json]
   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]
@@ -120,6 +136,8 @@ export function researchOrchestrationHelp() {
   tiangong-ai research project stage prepare <project-id> --stage discover|acquire|analyze|synthesize --host-agent codex|claude|workbuddy|codebuddy [--workspace <path>] [--json]
   tiangong-ai research project stage submit <project-id> --session <id> --output <absolute-json> [--confirm-model <id>] [--workspace <path>] [--json]
   tiangong-ai research project stage abort <project-id> --session <id> [--workspace <path>] [--json]
+  tiangong-ai research project stage artifacts <project-id> --session <id> [--offset <n>] [--limit <n>] [--path-prefix <prefix>] [--workspace <path>] [--json]
+  tiangong-ai research project stage read <project-id> --session <id> --artifact <object-id> [--offset <bytes>] [--length <bytes|all>] [--encoding utf8|base64] [--workspace <path>] [--json]
   tiangong-ai research project evidence fetch <project-id> --request <absolute-json> [--workspace <path>] [--json]
   tiangong-ai research project evidence data run <project-id> --request <absolute-data-run-request.json> [--workspace <path>] [--json]
   tiangong-ai research project evidence activity record <project-id> --record <absolute-json> [--workspace <path>] [--json]
@@ -134,8 +152,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]
 
@@ -150,6 +169,28 @@ async function runScientific(argv, io) {
     const [action, ...rest] = argv;
     if (!action || action === "--help" || action === "-h")
         return writeHelp(io);
+    if (action === "fulfillment") {
+        const [operation, ...arguments_] = rest;
+        if (operation !== "record" && operation !== "status")
+            throw unknownAction("research scientific fulfillment", operation ?? "");
+        const args = parseStrictArgs(arguments_, { ...WORKSPACE_OPTIONS, ...(operation === "record" ? { input: "string" } : {}) }, `research scientific fulfillment ${operation}`);
+        if (strictBoolean(args, "help"))
+            return writeHelp(io);
+        const projectId = onePositional(args.positionals, `research scientific fulfillment ${operation}`);
+        const root = await workspaceFromArgs(args);
+        if (operation === "status")
+            writeJson(io, await inspectScientificFulfillment(root, projectId), args);
+        else {
+            const path = strictString(args, "input");
+            if (!path)
+                throw new CliError("Fulfillment record requires --input.", {
+                    code: "RESEARCH_SCIENTIFIC_FULFILLMENT_INVALID",
+                    exitCode: 2,
+                });
+            writeJson(io, await recordScientificFulfillment(root, projectId, await readBoundedJsonRecord(path, "--input", "RESEARCH_SCIENTIFIC_FULFILLMENT_INVALID")), args);
+        }
+        return 0;
+    }
     if (action !== "object")
         throw unknownAction("research scientific", action);
     const [objectAction, ...objectRest] = rest;
@@ -506,12 +547,24 @@ 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 (stage === "task-native-run") {
+        schema = nativeRunInputSchema();
+    }
+    else if (isTaskSchemaName(stage)) {
+        schema = taskInputSchema(stage);
+    }
+    else if (isEvidenceContentSchemaName(stage)) {
         schema = evidenceContentInputSchema(stage);
     }
     else if (stage === "scientific-design") {
         schema = scientificDesignSchema();
     }
+    else if (stage === "scientific-fulfillment") {
+        schema = scientificFulfillmentSchema();
+    }
     else if (stage.startsWith("scientific-assessment-")) {
         const role = scientificReviewRole(stage.slice("scientific-assessment-".length));
         schema = scientificGateAssessmentSchema(role);
@@ -554,23 +607,7 @@ function compatibleSchema(schema, compatibility) {
             details: { supported: ["claude-code"] },
         });
     }
-    const compatible = structuredClone(schema);
-    const stripMetadata = (value) => {
-        if (Array.isArray(value)) {
-            for (const item of value)
-                stripMetadata(item);
-            return;
-        }
-        if (!value || typeof value !== "object")
-            return;
-        const record = value;
-        delete record.$schema;
-        delete record.$id;
-        for (const item of Object.values(record))
-            stripMetadata(item);
-    };
-    stripMetadata(compatible);
-    return compatible;
+    return claudeCodeCompatibleSchema(schema);
 }
 async function runContext(argv, io) {
     const [action, ...rest] = argv;
@@ -965,6 +1002,60 @@ async function runProject(argv, io) {
     }
     if (action === "stage") {
         const [stageAction, ...stageRest] = rest;
+        if (stageAction === "artifacts" || stageAction === "read") {
+            const args = parseStrictArgs(stageRest, {
+                ...WORKSPACE_OPTIONS,
+                session: "string",
+                artifact: "string",
+                offset: "string",
+                limit: "string",
+                length: "string",
+                encoding: "string",
+                "path-prefix": "string",
+            }, `research project stage ${stageAction}`);
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const sessionId = strictString(args, "session");
+            const objectId = strictString(args, "artifact");
+            if (!sessionId || (stageAction === "read" && !objectId))
+                throw new CliError("Stage artifact reads require --session and an exact --artifact for read.", { code: "RESEARCH_NATIVE_STAGE_SESSION_REQUIRED", exitCode: 3 });
+            const offset = strictString(args, "offset");
+            const limit = strictString(args, "limit");
+            const length = strictString(args, "length");
+            const encoding = strictString(args, "encoding");
+            if (encoding && encoding !== "utf8" && encoding !== "base64")
+                throw new CliError("Artifact encoding must be utf8 or base64.", {
+                    code: "RESEARCH_ARTIFACT_VIEW_INVALID",
+                    exitCode: 3,
+                });
+            const projectId = onePositional(args.positionals, `research project stage ${stageAction}`);
+            writeJson(io, await readNativeStageArtifact({
+                root: await workspaceFromArgs(args),
+                projectId,
+                sessionId,
+                ...(stageAction === "read"
+                    ? {
+                        selection: {
+                            objectId: objectId,
+                            ...(offset === undefined ? {} : { offset: Number(offset) }),
+                            ...(length === undefined
+                                ? {}
+                                : { length: length === "all" ? null : Number(length) }),
+                            ...(encoding ? { encoding: encoding } : {}),
+                        },
+                    }
+                    : {
+                        listing: {
+                            ...(offset === undefined ? {} : { offset: Number(offset) }),
+                            ...(limit === undefined ? {} : { limit: Number(limit) }),
+                            ...(strictString(args, "path-prefix")
+                                ? { pathPrefix: strictString(args, "path-prefix") }
+                                : {}),
+                        },
+                    }),
+            }), args);
+            return 0;
+        }
         if (stageAction === "prepare") {
             const args = parseStrictArgs(stageRest, { ...WORKSPACE_OPTIONS, stage: "string", "host-agent": "string" }, "research project stage prepare");
             if (strictBoolean(args, "help"))
@@ -1025,8 +1116,94 @@ async function runProject(argv, io) {
         }
         throw unknownAction("research project stage", stageAction ?? "");
     }
+    if (action === "task") {
+        const [taskAction, ...taskRest] = rest;
+        if (taskAction === "run") {
+            const [runAction, ...runRest] = taskRest;
+            if (runAction !== "observe" && runAction !== "inspect")
+                throw unknownAction("research project task run", runAction ?? "");
+            const args = parseStrictArgs(runRest, { ...WORKSPACE_OPTIONS, input: "string", run: "string", "confirm-execution": "boolean" }, `research project task run ${runAction}`);
+            if (strictBoolean(args, "help"))
+                return writeHelp(io);
+            const projectId = onePositional(args.positionals, `research project task run ${runAction}`);
+            const root = await workspaceFromArgs(args);
+            const result = runAction === "inspect"
+                ? await inspectNativeRun(root, projectId, strictString(args, "run") ?? "")
+                : await observeNativeRun(root, projectId, await readBoundedJsonRecord(strictString(args, "input") ?? "", "--input", "RESEARCH_NATIVE_RUN_INVALID"), strictBoolean(args, "confirm-execution"));
+            writeJson(io, result, args);
+            return "record" in result && result.record && result.record.status !== "succeeded" ? 3 : 0;
+        }
+        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 +1464,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 +1782,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 +1792,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 +1811,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 +1819,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 +1844,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 +1960,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)))