@pennixrv/trellis 0.7.1 → 0.7.2-beta.2

package/dist/commands/teamwork/artifact.js

@@ -1,8 +1,12 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { parseFrozenTeammate, } from "./teammate-launch.js";
+import { assertCoordinationMembers, } from "./coordination.js";
+import { REASONING_EFFORTS } from "./profiles.js";
+import { teammateContentSchema } from "./result.js";
 const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-const SECRET = /(-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk|gh[pousr])_[A-Za-z0-9]{20,}\b|\bBearer\s+\S+)/i;
+const SECRET = /(-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk|gh[pousr])_[A-Za-z0-9]{20,}\b|\bBearer\s+(?!<(?:redacted|token|placeholder)>(?:\s|[.,;:!?)]|$))\S+)/i;
 function id(value, field) {
     if (typeof value !== "string" || !ID.test(value))
         throw new Error(`${field} must be a safe id`);
@@ -45,7 +49,7 @@ function relativePathList(value, field) {
         throw new Error(`${field} must not contain duplicates`);
     return result;
 }
-function safePath(root, candidate) {
+export function safePath(root, candidate) {
     const absoluteRoot = path.resolve(root);
     const lexical = path.resolve(root, candidate);
     const relative = path.relative(absoluteRoot, lexical);
@@ -70,7 +74,7 @@ function attemptArtifactPath(taskRoot, briefPath, attemptId, fileName) {
         throw new Error("attempt id must be safe");
     return safePath(taskRoot, path.join(path.dirname(briefPath), "attempts", attemptId, fileName));
 }
-function writeImmutableJson(filePath, value) {
+function writeImmutableJson(filePath, value, idempotent = false) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const temporary = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${crypto.randomBytes(6).toString("hex")}.tmp`);
     try {
@@ -88,6 +92,10 @@ function writeImmutableJson(filePath, value) {
     }
     catch (error) {
         if (error.code === "EEXIST") {
+            if (idempotent &&
+                fs.lstatSync(filePath).isFile() &&
+                fs.readFileSync(filePath, "utf8") === JSON.stringify(value) + "\n")
+                return;
             throw new Error(`artifact already exists: ${filePath}`);
         }
         throw error;
@@ -100,9 +108,7 @@ function canonicalJson(value) {
     if (Array.isArray(value))
         return `[${value.map(canonicalJson).join(",")}]`;
     if (value && typeof value === "object") {
-        const entries = Object.entries(value)
-            .filter(([key]) => key !== "plan_hash")
-            .sort(([a], [b]) => a.localeCompare(b));
+        const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
         return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
     }
     return JSON.stringify(value);
@@ -111,14 +117,20 @@ function withoutFields(value, fields) {
     return Object.fromEntries(Object.entries(value).filter(([field]) => !fields.includes(field)));
 }
 export function computeTeamworkPlanHash(value) {
-    return crypto.createHash("sha256").update(canonicalJson(value)).digest("hex");
+    const contents = value && typeof value === "object" && !Array.isArray(value)
+        ? withoutFields(value, ["plan_hash"])
+        : value;
+    return crypto
+        .createHash("sha256")
+        .update(canonicalJson(contents))
+        .digest("hex");
 }
-export function validateTeamworkPlan(input, taskRoot, expectedContext) {
+export function validateTeamworkPlan(input, taskRoot, expectedContext, options = {}) {
     if (!input || typeof input !== "object" || Array.isArray(input))
         throw new Error("Teamwork plan must be an object");
     const value = input;
-    if (value.schema_version !== 1)
-        throw new Error("Teamwork plan schema_version must be 1");
+    if (value.schema_version !== 2)
+        throw new Error("Teamwork plan schema_version must be 2; construct a new frozen plan");
     const taskId = id(value.task_id, "task_id");
     const batchId = id(value.batch_id, "batch_id");
     const sessionId = id(value.session_id, "session_id");
@@ -126,6 +138,7 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
     const taskRouteRevision = boundedText(value.task_route_revision, "task_route_revision");
     const inputRevision = boundedText(value.input_revision, "input_revision");
     const planSummary = boundedText(value.plan_summary, "plan_summary");
+    const coordinationDigest = digest(value.coordination_digest, "coordination_digest");
     const coordinationMode = value.coordination_mode;
     if (coordinationMode !== "general" &&
         coordinationMode !== "advisor" &&
@@ -147,13 +160,13 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
     const deadlineAt = Date.parse(deadline);
     if (Number.isNaN(deadlineAt))
         throw new Error("deadline must be an ISO date");
-    if (deadlineAt <= Date.now())
+    if (!options.allowExpired && deadlineAt <= Date.now())
         throw new Error("deadline must be in the future");
     const assignmentValue = value.assignments;
     if (!Array.isArray(assignmentValue) || assignmentValue.length === 0)
         throw new Error("Teamwork plan assignments must be non-empty");
-    if (coordinationMode === "advisor" && assignmentValue.length !== 1)
-        throw new Error("advisor mode requires exactly one assignment");
+    if (coordinationMode === "advisor" && assignmentValue.length > 3)
+        throw new Error("advisor mode requires one to three assignments");
     if (coordinationMode === "committee" &&
         (assignmentValue.length < 2 || assignmentValue.length > 3))
         throw new Error("committee mode requires two or three assignments");
@@ -188,8 +201,10 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
         else if (coordinationMode === "committee") {
             throw new Error(`assignments[${index}] must declare an evaluation group`);
         }
-        if (item.role_id !== "teammate")
-            throw new Error(`assignments[${index}].role_id must be teammate`);
+        if (item.role_id !== undefined)
+            throw new Error(`assignments[${index}].role_id is retired; teammate is an internal execution type`);
+        const execution = parseFrozenTeammate(item.execution);
+        const selectionReason = boundedText(item.selection_reason, `assignments[${index}].selection_reason`);
         const provider = item.provider;
         if (provider !== "claude" &&
             provider !== "codex" &&
@@ -205,7 +220,9 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
             throw new Error(`assignments[${index}].max_retries must be non-negative`);
         const briefPath = boundedText(item.brief_path, `assignments[${index}].brief_path`);
         const scope = boundedText(item.scope, `assignments[${index}].scope`);
-        const lens = boundedText(item.lens, `assignments[${index}].lens`);
+        const lens = item.lens === undefined
+            ? undefined
+            : boundedText(item.lens, `assignments[${index}].lens`);
         const summary = boundedText(item.summary, `assignments[${index}].summary`);
         const briefDigest = digest(item.brief_digest, `assignments[${index}].brief_digest`);
         const sourceDigest = digest(item.source_digest, `assignments[${index}].source_digest`);
@@ -222,22 +239,31 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
         if (path.relative(path.resolve(taskRoot), absoluteBrief) !==
             expectedRelative)
             throw new Error(`assignments[${index}].brief_path must be ${expectedRelative}`);
-        const briefBytes = fs.readFileSync(absoluteBrief);
+        const prepared = options.briefContents?.get(briefPath);
+        if (options.briefContents && prepared === undefined)
+            throw new Error(`missing prepared brief: ${briefPath}`);
+        const briefBytes = prepared === undefined
+            ? fs.readFileSync(absoluteBrief)
+            : Buffer.from(prepared);
         if (briefBytes.byteLength > 64 * 1024)
             throw new Error(`brief for assignment '${assignmentId}' exceeds 65536 bytes`);
         const brief = JSON.parse(briefBytes.toString("utf8"));
         if (!brief || typeof brief !== "object" || Array.isArray(brief))
             throw new Error(`brief for assignment '${assignmentId}' must be an object`);
+        if (typeof brief.input !== "string" ||
+            brief.input.trim() === "" ||
+            brief.input.length > 32768 ||
+            brief.input.includes("\0"))
+            throw new Error("brief.input must be nonempty task text of at most 32768 characters");
         briefs.set(assignmentId, brief);
         rejectSecrets(brief, `brief for assignment '${assignmentId}'`);
         if (computeTeamworkPlanHash(brief) !== briefDigest)
             throw new Error(`brief.${assignmentId} digest does not match the Teamwork plan`);
         for (const [field, expected] of Object.entries({
-            schema_version: 1,
+            schema_version: 2,
             task_id: taskId,
             batch_id: batchId,
             assignment_id: assignmentId,
-            role_id: "teammate",
             provider,
             summary,
             scope,
@@ -247,6 +273,16 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
             if (brief[field] !== expected)
                 throw new Error(`brief.${field} does not match the Teamwork plan`);
         }
+        if (brief.role_id !== undefined)
+            throw new Error("brief.role_id is retired");
+        if (canonicalJson(brief.execution) !== canonicalJson(item.execution))
+            throw new Error("brief.execution does not match the frozen plan");
+        if (brief.selection_reason !== selectionReason)
+            throw new Error("brief.selection_reason does not match the frozen plan");
+        if (execution.profile.provider !== provider ||
+            execution.profile.profile !== profile ||
+            execution.profile.model !== model)
+            throw new Error("assignment provider, profile, or model does not match frozen execution");
         const briefSourceDigest = digest(brief.source_digest, `brief.${assignmentId}.source_digest`);
         if (briefSourceDigest !== sourceDigest)
             throw new Error(`brief.${assignmentId}.source_digest does not match the Teamwork plan`);
@@ -279,6 +315,9 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
             summary,
             scope,
             lens,
+            execution,
+            selectionReason,
+            taskInput: brief.input,
             briefDigest,
             sourceDigest,
             ...(contextFiles ? { contextFiles } : {}),
@@ -289,6 +328,7 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
         rejectSecrets(assignment, `assignments[${index}]`);
         return assignment;
     });
+    assertCoordinationMembers(coordinationMode, assignments);
     if (coordinationMode === "committee") {
         const groups = new Map();
         for (const assignment of assignments) {
@@ -315,6 +355,8 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
             "lens",
             "brief_path",
             "brief_digest",
+            "execution",
+            "selection_reason",
         ];
         const briefFields = [
             "assignment_id",
@@ -322,6 +364,8 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
             "profile",
             "model",
             "lens",
+            "execution",
+            "selection_reason",
         ];
         const first = members[0];
         if (!first)
@@ -348,12 +392,32 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
     if (new Set(protectedTargets).size !== protectedTargets.length)
         throw new Error("protected_targets must not contain duplicates");
     const requestedCapacityValue = value.requested_capacity;
+    let retryOf;
+    if (value.retry_of !== undefined) {
+        const retry = value.retry_of;
+        const assignmentIds = retry?.assignment_ids;
+        if (!retry ||
+            typeof retry !== "object" ||
+            !Array.isArray(assignmentIds) ||
+            assignmentIds.length !== assignments.length ||
+            new Set(assignmentIds).size !== assignments.length ||
+            assignments.some((entry) => !assignmentIds.includes(entry.assignmentId)))
+            throw new Error("Retry lineage must contain the exact selected assignment set");
+        retryOf = {
+            batchId: id(retry.batch_id, "retry_of.batch_id"),
+            planHash: digest(retry.plan_hash, "retry_of.plan_hash"),
+            assignmentIds: assignmentIds.map((entry) => id(entry, "retry_of.assignment_ids")),
+            approvalRef: boundedText(retry.approval_ref, "retry_of.approval_ref"),
+        };
+        if (retryOf.batchId === batchId)
+            throw new Error("Retry must use a new batch identity");
+    }
     if (requestedCapacityValue !== undefined &&
         (!Number.isInteger(requestedCapacityValue) ||
             requestedCapacityValue <= 0))
         throw new Error("requested_capacity must be a positive integer");
     const plan = {
-        schemaVersion: 1,
+        schemaVersion: 2,
         taskId,
         batchId,
         sessionId,
@@ -362,6 +426,11 @@ export function validateTeamworkPlan(input, taskRoot, expectedContext) {
         inputRevision,
         planSummary,
         coordinationMode,
+        coordinationDigest,
+        ...(retryOf ? { retryOf } : {}),
+        ...(value.coordination_snapshot
+            ? { coordinationSnapshot: value.coordination_snapshot }
+            : {}),
         planHash: boundedText(value.plan_hash, "plan_hash"),
         ...(requestedCapacityValue !== undefined
             ? { requestedCapacity: requestedCapacityValue }
@@ -380,8 +449,31 @@ export function validateTeammateReport(input, identity, expectedSourceDigest) {
     if (!input || typeof input !== "object" || Array.isArray(input))
         throw new Error("teammate report must be an object");
     const value = input;
-    if (value.schema_version !== 1)
-        throw new Error("teammate report schema_version must be 1");
+    if (value.schema_version !== 1 && value.schema_version !== 2)
+        throw new Error("teammate report schema_version must be 1 or 2");
+    if (value.schema_version === 2) {
+        const allowed = new Set([
+            ...Object.keys(teammateContentSchema.shape),
+            "task_id",
+            "batch_id",
+            "assignment_id",
+            "attempt_id",
+            "teammate_id",
+            "plan_hash",
+            "phase_id",
+            "task_route_revision",
+            "input_revision",
+            "source_digest",
+        ]);
+        if (Object.keys(value).some((key) => !allowed.has(key)))
+            throw new Error("teammate report contains unknown fields");
+    }
+    const content = value.schema_version === 2
+        ? teammateContentSchema.parse(Object.fromEntries(Object.keys(teammateContentSchema.shape).map((key) => [
+            key,
+            value[key],
+        ])))
+        : undefined;
     for (const key of [
         "task_id",
         "batch_id",
@@ -434,11 +526,11 @@ export function validateTeammateReport(input, identity, expectedSourceDigest) {
             summary: boundedText(item.summary, `report.evidence[${index}].summary`),
         };
     });
-    if (status !== "complete" || evidence.length === 0) {
-        throw new Error(`report status '${status}' cannot be accepted as completed work`);
-    }
+    if (evidence.length === 0)
+        throw new Error("report.evidence must include at least one item");
     const report = {
-        schemaVersion: 1,
+        schemaVersion: value.schema_version,
+        ...(content ? { content } : {}),
         taskId: identity.taskId,
         batchId: identity.batchId,
         assignmentId: identity.assignmentId,
@@ -504,8 +596,8 @@ export function validateTeammateClaim(input, identity, expectedPlanHash, expecte
     if (!input || typeof input !== "object" || Array.isArray(input))
         throw new Error("teammate claim must be an object");
     const value = input;
-    if (value.schema_version !== 1)
-        throw new Error("teammate claim schema_version must be 1");
+    if (value.schema_version !== 2)
+        throw new Error("teammate claim schema_version must be 2");
     for (const key of [
         "task_id",
         "batch_id",
@@ -541,7 +633,7 @@ export function validateTeammateClaim(input, identity, expectedPlanHash, expecte
     if (!Number.isInteger(value.slot) || value.slot < 0)
         throw new Error("claim.slot must be non-negative");
     const snapshotKeys = [
-        "role_id",
+        "configuration",
         "provider",
         "profile",
         "model",
@@ -555,8 +647,8 @@ export function validateTeammateClaim(input, identity, expectedPlanHash, expecte
     const hasSnapshot = snapshotKeys.some((key) => value[key] !== undefined);
     let execution;
     if (hasSnapshot) {
-        if (value.role_id !== "teammate")
-            throw new Error("claim.role_id must be teammate");
+        if (value.role_id !== undefined)
+            throw new Error("claim.role_id is retired");
         const provider = value.provider;
         if (provider !== "claude" &&
             provider !== "codex" &&
@@ -574,9 +666,7 @@ export function validateTeammateClaim(input, identity, expectedPlanHash, expecte
             throw new Error("claim.model must be bounded single-line text");
         const reasoningEffort = value.reasoning_effort;
         if (reasoningEffort !== undefined &&
-            reasoningEffort !== "medium" &&
-            reasoningEffort !== "high" &&
-            reasoningEffort !== "xhigh") {
+            !REASONING_EFFORTS.includes(reasoningEffort)) {
             throw new Error("claim.reasoning_effort is invalid");
         }
         if (!value.options ||
@@ -605,10 +695,13 @@ export function validateTeammateClaim(input, identity, expectedPlanHash, expecte
         }
         execution = {
             roleId: "teammate",
+            configuration: id(value.configuration, "claim.configuration"),
             provider,
             ...(profile ? { profile } : {}),
             ...(model ? { model } : {}),
-            ...(reasoningEffort ? { reasoningEffort } : {}),
+            ...(reasoningEffort
+                ? { reasoningEffort: reasoningEffort }
+                : {}),
             options,
             ...(value.profile_digest === undefined
                 ? {}
@@ -621,7 +714,7 @@ export function validateTeammateClaim(input, identity, expectedPlanHash, expecte
         };
     }
     const claim = {
-        schemaVersion: 1,
+        schemaVersion: 2,
         ...identity,
         planHash,
         ...(briefDigest ? { briefDigest } : {}),
@@ -680,7 +773,7 @@ export function validateTeammateDisposition(input, identity, expectedSourceDiges
 export function writeTeammateClaim(input) {
     const execution = input.launch
         ? {
-            role_id: input.launch.roleId,
+            configuration: input.launch.configuration,
             provider: input.launch.provider,
             ...(input.launch.profile ? { profile: input.launch.profile } : {}),
             ...(input.launch.model ? { model: input.launch.model } : {}),
@@ -697,7 +790,7 @@ export function writeTeammateClaim(input) {
         }
         : undefined;
     const claim = validateTeammateClaim({
-        schema_version: 1,
+        schema_version: 2,
         task_id: input.identity.taskId,
         batch_id: input.identity.batchId,
         assignment_id: input.identity.assignmentId,
@@ -724,7 +817,7 @@ export function writeTeammateClaim(input) {
         status: claim.status,
         ...(claim.execution
             ? {
-                role_id: claim.execution.roleId,
+                configuration: claim.execution.configuration,
                 provider: claim.execution.provider,
                 ...(claim.execution.profile
                     ? { profile: claim.execution.profile }
@@ -789,8 +882,13 @@ export function appendTeammateWorklog(input) {
     }
 }
 export function writeTeammateReport(input) {
+    if (input.content &&
+        (input.content.status !== input.status ||
+            JSON.stringify(input.content.evidence) !== JSON.stringify(input.evidence)))
+        throw new Error("report content status/evidence must match the submitted report");
     const report = validateTeammateReport({
-        schema_version: 1,
+        ...input.content,
+        schema_version: input.content ? 2 : 1,
         task_id: input.identity.taskId,
         batch_id: input.identity.batchId,
         assignment_id: input.identity.assignmentId,
@@ -805,6 +903,7 @@ export function writeTeammateReport(input) {
         evidence: input.evidence,
     }, input.identity, input.sourceDigest);
     writeImmutableJson(attemptArtifactPath(input.taskRoot, input.briefPath, input.identity.attemptId, "report.json"), {
+        ...report.content,
         schema_version: report.schemaVersion,
         task_id: report.taskId,
         batch_id: report.batchId,
@@ -852,57 +951,61 @@ export function writeTeammateDisposition(input) {
         status: disposition.status,
         source_digest: disposition.sourceDigest,
         ...(disposition.reason ? { reason: disposition.reason } : {}),
-    });
+        ...(input.review ? { review: input.review } : {}),
+    }, input.review !== undefined);
+}
+export class TeammateReportReadError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.kind = kind;
+        this.name = "TeammateReportReadError";
+    }
+}
+function isMissingFile(error) {
+    return (error !== null &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
 }
 export function readTeammateReport(input) {
     if (!ID.test(input.attemptId))
         throw new Error("attempt id must be safe");
-    const reportPath = safePath(input.taskRoot, path.join(path.dirname(input.briefPath), "attempts", input.attemptId, "report.json"));
-    const stat = fs.lstatSync(reportPath);
+    let reportPath;
+    try {
+        reportPath = safePath(input.taskRoot, path.join(path.dirname(input.briefPath), "attempts", input.attemptId, "report.json"));
+    }
+    catch {
+        throw new TeammateReportReadError("storage", "teammate report path is unsafe");
+    }
+    let stat;
+    try {
+        stat = fs.lstatSync(reportPath);
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            throw new TeammateReportReadError("missing", "teammate report is missing");
+        throw new TeammateReportReadError("storage", "could not inspect teammate report");
+    }
     if (!stat.isFile() || stat.size > 128 * 1024)
-        throw new Error("teammate report must be a regular file under 131072 bytes");
-    const raw = fs.readFileSync(reportPath, "utf8");
-    const report = JSON.parse(raw);
+        throw new TeammateReportReadError("storage", "teammate report must be a regular file under 131072 bytes");
+    let raw;
+    try {
+        raw = fs.readFileSync(reportPath, "utf8");
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            throw new TeammateReportReadError("missing", "teammate report is missing");
+        throw new TeammateReportReadError("storage", "could not read teammate report");
+    }
+    let report;
+    try {
+        report = JSON.parse(raw);
+    }
+    catch {
+        throw new TeammateReportReadError("incomplete", "teammate report is not complete JSON");
+    }
     rejectSecrets(report, "teammate report");
     return validateTeammateReport(report, { ...input.identity, attemptId: input.attemptId }, input.sourceDigest);
 }
-export function cleanupSettledTeamworkArtifacts(input) {
-    const failures = [];
-    for (const assignment of input.assignments) {
-        try {
-            const assignmentDir = safePath(input.taskRoot, path.dirname(assignment.briefPath));
-            const queueFile = safePath(input.taskRoot, path.join(assignmentDir, "queue.json"));
-            if (fs.existsSync(queueFile))
-                fs.unlinkSync(queueFile);
-            const attemptsDir = safePath(input.taskRoot, path.join(assignmentDir, "attempts"));
-            if (!fs.existsSync(attemptsDir))
-                continue;
-            for (const attemptId of fs.readdirSync(attemptsDir)) {
-                if (!ID.test(attemptId))
-                    continue;
-                const attemptDir = safePath(input.taskRoot, path.join(attemptsDir, attemptId));
-                const keepReport = input.acceptedAttempts.get(assignment.assignmentId) === attemptId;
-                const transientFiles = [
-                    "claim.json",
-                    "disposition.json",
-                    "worklog.md",
-                    ...(keepReport ? [] : ["report.json"]),
-                ];
-                for (const fileName of transientFiles) {
-                    const filePath = safePath(input.taskRoot, path.join(attemptDir, fileName));
-                    if (fs.existsSync(filePath))
-                        fs.unlinkSync(filePath);
-                }
-                if (fs.readdirSync(attemptDir).length === 0)
-                    fs.rmdirSync(attemptDir);
-            }
-            if (fs.readdirSync(attemptsDir).length === 0)
-                fs.rmdirSync(attemptsDir);
-        }
-        catch (error) {
-            failures.push(`${assignment.assignmentId}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    return failures;
-}
 //# sourceMappingURL=artifact.js.map