@pennixrv/trellis 0.7.0-beta.9 → 0.7.1

package/dist/commands/teamwork/artifact.js

@@ -0,0 +1,908 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+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;
+function id(value, field) {
+    if (typeof value !== "string" || !ID.test(value))
+        throw new Error(`${field} must be a safe id`);
+    return value;
+}
+function boundedText(value, field) {
+    if (typeof value !== "string" ||
+        value.trim() === "" ||
+        value.includes("\0") ||
+        value.length > 4096) {
+        throw new Error(`${field} must be bounded text`);
+    }
+    return value;
+}
+function digest(value, field) {
+    const result = boundedText(value, field);
+    if (!/^[a-f0-9]{64}$/i.test(result))
+        throw new Error(`${field} must be a SHA-256 digest`);
+    return result;
+}
+function relativePath(value, field) {
+    const result = boundedText(value, field);
+    if (path.isAbsolute(result))
+        throw new Error(`${field} must be relative`);
+    const normalized = path.normalize(result);
+    if (normalized === "." ||
+        normalized === ".." ||
+        normalized.startsWith(`..${path.sep}`)) {
+        throw new Error(`${field} must stay within the project root`);
+    }
+    return normalized;
+}
+function relativePathList(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new Error(`${field} must be an array`);
+    const result = value.map((entry, index) => relativePath(entry, `${field}[${index}]`));
+    if (new Set(result).size !== result.length)
+        throw new Error(`${field} must not contain duplicates`);
+    return result;
+}
+function safePath(root, candidate) {
+    const absoluteRoot = path.resolve(root);
+    const lexical = path.resolve(root, candidate);
+    const relative = path.relative(absoluteRoot, lexical);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+        throw new Error(`artifact path escapes task root: ${candidate}`);
+    let current = absoluteRoot;
+    for (const part of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, part);
+        if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink()) {
+            throw new Error(`artifact path contains a symlink: ${candidate}`);
+        }
+    }
+    return lexical;
+}
+function rejectSecrets(value, field) {
+    const raw = JSON.stringify(value);
+    if (raw && SECRET.test(raw))
+        throw new Error(`${field} appears to contain a credential`);
+}
+function attemptArtifactPath(taskRoot, briefPath, attemptId, fileName) {
+    if (!ID.test(attemptId))
+        throw new Error("attempt id must be safe");
+    return safePath(taskRoot, path.join(path.dirname(briefPath), "attempts", attemptId, fileName));
+}
+function writeImmutableJson(filePath, value) {
+    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 {
+        const fd = fs.openSync(temporary, "wx", 0o600);
+        try {
+            fs.writeFileSync(fd, JSON.stringify(value) + "\n", "utf8");
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        // linkSync is exclusive on the destination and therefore preserves the
+        // write-once contract even when another coordinator races this attempt.
+        fs.linkSync(temporary, filePath);
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            throw new Error(`artifact already exists: ${filePath}`);
+        }
+        throw error;
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+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));
+        return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+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");
+}
+export function validateTeamworkPlan(input, taskRoot, expectedContext) {
+    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");
+    const taskId = id(value.task_id, "task_id");
+    const batchId = id(value.batch_id, "batch_id");
+    const sessionId = id(value.session_id, "session_id");
+    const phaseId = boundedText(value.phase_id, "phase_id");
+    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 coordinationMode = value.coordination_mode;
+    if (coordinationMode !== "general" &&
+        coordinationMode !== "advisor" &&
+        coordinationMode !== "committee") {
+        throw new Error("coordination_mode is unsupported");
+    }
+    if (expectedContext) {
+        for (const [field, expected] of Object.entries({
+            task_id: expectedContext.taskId,
+            phase_id: expectedContext.phaseId,
+            task_route_revision: expectedContext.taskRouteRevision,
+            input_revision: expectedContext.inputRevision,
+        })) {
+            if (value[field] !== expected)
+                throw new Error(`Teamwork plan ${field} does not match the current task`);
+        }
+    }
+    const deadline = boundedText(value.deadline, "deadline");
+    const deadlineAt = Date.parse(deadline);
+    if (Number.isNaN(deadlineAt))
+        throw new Error("deadline must be an ISO date");
+    if (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 === "committee" &&
+        (assignmentValue.length < 2 || assignmentValue.length > 3))
+        throw new Error("committee mode requires two or three assignments");
+    const seen = new Set();
+    const rawAssignments = new Map();
+    const briefs = new Map();
+    const assignments = assignmentValue.map((raw, index) => {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            throw new Error(`assignments[${index}] must be an object`);
+        const item = raw;
+        const assignmentId = id(item.assignment_id, `assignments[${index}].assignment_id`);
+        if (seen.has(assignmentId))
+            throw new Error(`duplicate assignment id '${assignmentId}'`);
+        seen.add(assignmentId);
+        rawAssignments.set(assignmentId, item);
+        const evaluationGroupValue = item.evaluation_group;
+        let evaluationGroup;
+        if (evaluationGroupValue !== undefined) {
+            if (!evaluationGroupValue ||
+                typeof evaluationGroupValue !== "object" ||
+                Array.isArray(evaluationGroupValue)) {
+                throw new Error(`assignments[${index}].evaluation_group must be an object`);
+            }
+            const group = evaluationGroupValue;
+            if (coordinationMode !== "committee" || group.kind !== "committee")
+                throw new Error(`assignments[${index}].evaluation_group is unsupported`);
+            evaluationGroup = {
+                id: id(group.id, `assignments[${index}].evaluation_group.id`),
+                kind: "committee",
+            };
+        }
+        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`);
+        const provider = item.provider;
+        if (provider !== "claude" &&
+            provider !== "codex" &&
+            provider !== "dsh" &&
+            provider !== "copilot") {
+            throw new Error(`assignments[${index}].provider is unsupported`);
+        }
+        const acceptance = item.acceptance;
+        if (!Array.isArray(acceptance) || acceptance.length === 0)
+            throw new Error(`assignments[${index}].acceptance must be non-empty`);
+        const maxRetries = item.max_retries;
+        if (!Number.isInteger(maxRetries) || maxRetries < 0)
+            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 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`);
+        const contextFiles = relativePathList(item.context_files, `assignments[${index}].context_files`);
+        const contextManifests = relativePathList(item.context_manifests, `assignments[${index}].context_manifests`);
+        const profile = item.profile === undefined
+            ? undefined
+            : id(item.profile, `assignments[${index}].profile`);
+        const model = item.model === undefined
+            ? undefined
+            : boundedText(item.model, `assignments[${index}].model`);
+        const absoluteBrief = safePath(taskRoot, briefPath);
+        const expectedRelative = path.join("teammates", batchId, assignmentId, "brief.json");
+        if (path.relative(path.resolve(taskRoot), absoluteBrief) !==
+            expectedRelative)
+            throw new Error(`assignments[${index}].brief_path must be ${expectedRelative}`);
+        const briefBytes = fs.readFileSync(absoluteBrief);
+        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`);
+        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,
+            task_id: taskId,
+            batch_id: batchId,
+            assignment_id: assignmentId,
+            role_id: "teammate",
+            provider,
+            summary,
+            scope,
+            lens,
+            deadline,
+        })) {
+            if (brief[field] !== expected)
+                throw new Error(`brief.${field} does not match the Teamwork plan`);
+        }
+        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`);
+        for (const [field, expected] of [
+            ["context_files", contextFiles],
+            ["context_manifests", contextManifests],
+        ]) {
+            const actual = relativePathList(brief[field], `brief.${assignmentId}.${field}`);
+            if (JSON.stringify(actual) !== JSON.stringify(expected))
+                throw new Error(`brief.${field} does not match the Teamwork plan`);
+        }
+        for (const field of ["profile", "model"]) {
+            if (item[field] !== undefined && brief[field] !== item[field])
+                throw new Error(`brief.${field} does not match the Teamwork plan`);
+            if (item[field] === undefined && brief[field] !== undefined)
+                throw new Error(`brief.${field} is not declared by the Teamwork plan`);
+        }
+        const briefAcceptance = brief.acceptance;
+        if (!Array.isArray(briefAcceptance) ||
+            JSON.stringify(briefAcceptance) !== JSON.stringify(acceptance))
+            throw new Error(`brief acceptance contract does not match assignment '${assignmentId}'`);
+        const assignment = {
+            assignmentId,
+            ...(evaluationGroup ? { evaluationGroup } : {}),
+            briefPath,
+            roleId: "teammate",
+            provider,
+            ...(profile ? { profile } : {}),
+            ...(model ? { model } : {}),
+            summary,
+            scope,
+            lens,
+            briefDigest,
+            sourceDigest,
+            ...(contextFiles ? { contextFiles } : {}),
+            ...(contextManifests ? { contextManifests } : {}),
+            acceptance: acceptance.map((entry, acceptanceIndex) => boundedText(entry, `assignments[${index}].acceptance[${acceptanceIndex}]`)),
+            maxRetries: maxRetries,
+        };
+        rejectSecrets(assignment, `assignments[${index}]`);
+        return assignment;
+    });
+    if (coordinationMode === "committee") {
+        const groups = new Map();
+        for (const assignment of assignments) {
+            const group = assignment.evaluationGroup;
+            if (!group)
+                throw new Error("committee assignments require an evaluation group");
+            const members = groups.get(group.id) ?? [];
+            members.push(assignment);
+            groups.set(group.id, members);
+        }
+        if (groups.size !== 1)
+            throw new Error("committee assignments must share one evaluation group");
+        const members = [...groups.values()][0] ?? [];
+        if (members.length < 2 || members.length > 3)
+            throw new Error("committee evaluation group requires two or three assignments");
+        if (new Set(members.map((assignment) => assignment.lens)).size !==
+            members.length)
+            throw new Error("committee assignments must use distinct lenses");
+        const assignmentFields = [
+            "assignment_id",
+            "provider",
+            "profile",
+            "model",
+            "lens",
+            "brief_path",
+            "brief_digest",
+        ];
+        const briefFields = [
+            "assignment_id",
+            "provider",
+            "profile",
+            "model",
+            "lens",
+        ];
+        const first = members[0];
+        if (!first)
+            throw new Error("committee has no assignments");
+        for (const other of members.slice(1)) {
+            const firstRaw = rawAssignments.get(first.assignmentId);
+            const otherRaw = rawAssignments.get(other.assignmentId);
+            const firstBrief = briefs.get(first.assignmentId);
+            const otherBrief = briefs.get(other.assignmentId);
+            if (!firstRaw || !otherRaw || !firstBrief || !otherBrief)
+                throw new Error("committee is missing frozen artifacts");
+            if (canonicalJson(withoutFields(firstRaw, assignmentFields)) !==
+                canonicalJson(withoutFields(otherRaw, assignmentFields)))
+                throw new Error("committee assignments must share the same assignment contract");
+            if (canonicalJson(withoutFields(firstBrief, briefFields)) !==
+                canonicalJson(withoutFields(otherBrief, briefFields)))
+                throw new Error("committee assignments must share the same brief contract");
+        }
+    }
+    if (!Array.isArray(value.protected_targets) &&
+        value.protected_targets !== undefined)
+        throw new Error("protected_targets must be an array");
+    const protectedTargets = (value.protected_targets ?? []).map((entry, index) => boundedText(entry, `protected_targets[${index}]`));
+    if (new Set(protectedTargets).size !== protectedTargets.length)
+        throw new Error("protected_targets must not contain duplicates");
+    const requestedCapacityValue = value.requested_capacity;
+    if (requestedCapacityValue !== undefined &&
+        (!Number.isInteger(requestedCapacityValue) ||
+            requestedCapacityValue <= 0))
+        throw new Error("requested_capacity must be a positive integer");
+    const plan = {
+        schemaVersion: 1,
+        taskId,
+        batchId,
+        sessionId,
+        phaseId,
+        taskRouteRevision,
+        inputRevision,
+        planSummary,
+        coordinationMode,
+        planHash: boundedText(value.plan_hash, "plan_hash"),
+        ...(requestedCapacityValue !== undefined
+            ? { requestedCapacity: requestedCapacityValue }
+            : {}),
+        assignments,
+        deadline,
+        protectedTargets,
+    };
+    if (!/^[a-f0-9]{64}$/i.test(plan.planHash) ||
+        plan.planHash !== computeTeamworkPlanHash(value))
+        throw new Error("Teamwork plan hash does not match its immutable contents");
+    rejectSecrets(plan, "Teamwork plan");
+    return plan;
+}
+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");
+    for (const key of [
+        "task_id",
+        "batch_id",
+        "assignment_id",
+        "attempt_id",
+        "teammate_id",
+        "plan_hash",
+        "phase_id",
+        "task_route_revision",
+        "input_revision",
+    ]) {
+        const expected = identity[key === "task_id"
+            ? "taskId"
+            : key === "batch_id"
+                ? "batchId"
+                : key === "assignment_id"
+                    ? "assignmentId"
+                    : key === "attempt_id"
+                        ? "attemptId"
+                        : key === "teammate_id"
+                            ? "teammateId"
+                            : key === "plan_hash"
+                                ? "planHash"
+                                : key === "phase_id"
+                                    ? "phaseId"
+                                    : key === "task_route_revision"
+                                        ? "taskRouteRevision"
+                                        : "inputRevision"];
+        if (value[key] !== expected)
+            throw new Error(`report.${key} does not match the assigned identity`);
+    }
+    const status = value.status;
+    if (status !== "complete" &&
+        status !== "blocked" &&
+        status !== "incomplete" &&
+        status !== "error")
+        throw new Error("report.status is invalid");
+    const sourceDigest = boundedText(value.source_digest, "report.source_digest");
+    if (sourceDigest !== expectedSourceDigest)
+        throw new Error("report source digest does not match the assigned brief");
+    if (!Array.isArray(value.evidence))
+        throw new Error("report.evidence must be an array");
+    const evidence = value.evidence.map((entry, index) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            throw new Error(`report.evidence[${index}] must be an object`);
+        const item = entry;
+        return {
+            id: id(item.id, `report.evidence[${index}].id`),
+            locator: boundedText(item.locator, `report.evidence[${index}].locator`),
+            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`);
+    }
+    const report = {
+        schemaVersion: 1,
+        taskId: identity.taskId,
+        batchId: identity.batchId,
+        assignmentId: identity.assignmentId,
+        attemptId: identity.attemptId,
+        teammateId: identity.teammateId,
+        planHash: identity.planHash,
+        phaseId: identity.phaseId,
+        taskRouteRevision: identity.taskRouteRevision,
+        inputRevision: identity.inputRevision,
+        status,
+        sourceDigest,
+        evidence,
+    };
+    rejectSecrets(report, "teammate report");
+    return report;
+}
+export function validateTeammateQueueFact(input, identity, expectedPlanHash, expectedBriefDigest, expectedSourceDigest) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("teammate queue fact must be an object");
+    const value = input;
+    if (value.schema_version !== 1)
+        throw new Error("teammate queue fact schema_version must be 1");
+    for (const key of ["task_id", "batch_id", "assignment_id"]) {
+        const expected = identity[key === "task_id"
+            ? "taskId"
+            : key === "batch_id"
+                ? "batchId"
+                : "assignmentId"];
+        if (value[key] !== expected)
+            throw new Error(`queue.${key} does not match the assigned work`);
+    }
+    const planHash = digest(value.plan_hash, "queue.plan_hash");
+    if (planHash !== expectedPlanHash)
+        throw new Error("queue plan hash does not match the batch plan");
+    const briefDigest = digest(value.brief_digest, "queue.brief_digest");
+    if (briefDigest !== expectedBriefDigest)
+        throw new Error("queue brief digest does not match the assigned work");
+    const sourceDigest = digest(value.source_digest, "queue.source_digest");
+    if (sourceDigest !== expectedSourceDigest)
+        throw new Error("queue source digest does not match the assigned brief");
+    const briefPath = relativePath(value.brief_path, "queue.brief_path");
+    const expectedBriefPath = path.join("teammates", identity.batchId, identity.assignmentId, "brief.json");
+    if (briefPath !== expectedBriefPath)
+        throw new Error("queue.brief_path is not the canonical work brief path");
+    if (value.status !== "queued")
+        throw new Error("queue.status must be queued");
+    if (!Number.isInteger(value.queue_index) || value.queue_index < 0)
+        throw new Error("queue.queue_index must be non-negative");
+    const queue = {
+        schemaVersion: 1,
+        ...identity,
+        planHash,
+        briefDigest,
+        sourceDigest,
+        briefPath,
+        queueIndex: value.queue_index,
+        status: "queued",
+    };
+    rejectSecrets(queue, "teammate queue fact");
+    return queue;
+}
+export function validateTeammateClaim(input, identity, expectedPlanHash, expectedSourceDigest, expectedBriefDigest) {
+    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");
+    for (const key of [
+        "task_id",
+        "batch_id",
+        "assignment_id",
+        "attempt_id",
+        "teammate_id",
+    ]) {
+        const expected = identity[key === "task_id"
+            ? "taskId"
+            : key === "batch_id"
+                ? "batchId"
+                : key === "assignment_id"
+                    ? "assignmentId"
+                    : key === "attempt_id"
+                        ? "attemptId"
+                        : "teammateId"];
+        if (value[key] !== expected)
+            throw new Error(`claim.${key} does not match the assigned identity`);
+    }
+    const planHash = digest(value.plan_hash, "claim.plan_hash");
+    if (planHash !== expectedPlanHash)
+        throw new Error("claim plan hash does not match the batch plan");
+    const sourceDigest = digest(value.source_digest, "claim.source_digest");
+    if (sourceDigest !== expectedSourceDigest)
+        throw new Error("claim source digest does not match the assigned brief");
+    const briefDigest = value.brief_digest === undefined
+        ? undefined
+        : digest(value.brief_digest, "claim.brief_digest");
+    if (expectedBriefDigest && briefDigest !== expectedBriefDigest)
+        throw new Error("claim brief digest does not match the assigned work");
+    if (value.status !== "issued")
+        throw new Error("claim.status must be issued");
+    if (!Number.isInteger(value.slot) || value.slot < 0)
+        throw new Error("claim.slot must be non-negative");
+    const snapshotKeys = [
+        "role_id",
+        "provider",
+        "profile",
+        "model",
+        "reasoning_effort",
+        "options",
+        "profile_digest",
+        "role_digest",
+        "context_digest",
+        "capability_digest",
+    ];
+    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");
+        const provider = value.provider;
+        if (provider !== "claude" &&
+            provider !== "codex" &&
+            provider !== "dsh" &&
+            provider !== "copilot") {
+            throw new Error("claim.provider is unsupported");
+        }
+        const profile = value.profile === undefined
+            ? undefined
+            : id(value.profile, "claim.profile");
+        const model = value.model === undefined
+            ? undefined
+            : boundedText(value.model, "claim.model");
+        if (model && (model.length > 256 || /[\r\n]/.test(model)))
+            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") {
+            throw new Error("claim.reasoning_effort is invalid");
+        }
+        if (!value.options ||
+            typeof value.options !== "object" ||
+            Array.isArray(value.options))
+            throw new Error("claim.options must be an object");
+        if (Object.keys(value.options).length > 32)
+            throw new Error("claim.options has too many entries");
+        const options = {};
+        for (const [key, option] of Object.entries(value.options)) {
+            if (!/^[A-Za-z0-9._-]{1,64}$/.test(key))
+                throw new Error("claim.options has an invalid key");
+            if (typeof option !== "string" &&
+                typeof option !== "number" &&
+                typeof option !== "boolean") {
+                throw new Error(`claim.options.${key} must be a scalar`);
+            }
+            if ((typeof option === "number" && !Number.isFinite(option)) ||
+                (typeof option === "string" &&
+                    (option.trim() === "" ||
+                        option.length > 256 ||
+                        /[\r\n\0]/.test(option)))) {
+                throw new Error(`claim.options.${key} must be bounded scalar data`);
+            }
+            options[key] = option;
+        }
+        execution = {
+            roleId: "teammate",
+            provider,
+            ...(profile ? { profile } : {}),
+            ...(model ? { model } : {}),
+            ...(reasoningEffort ? { reasoningEffort } : {}),
+            options,
+            ...(value.profile_digest === undefined
+                ? {}
+                : {
+                    profileDigest: digest(value.profile_digest, "claim.profile_digest"),
+                }),
+            roleDigest: digest(value.role_digest, "claim.role_digest"),
+            contextDigest: digest(value.context_digest, "claim.context_digest"),
+            capabilityDigest: digest(value.capability_digest, "claim.capability_digest"),
+        };
+    }
+    const claim = {
+        schemaVersion: 1,
+        ...identity,
+        planHash,
+        ...(briefDigest ? { briefDigest } : {}),
+        sourceDigest,
+        slot: value.slot,
+        status: "issued",
+        ...(execution ? { execution } : {}),
+    };
+    rejectSecrets(claim, "teammate claim");
+    return claim;
+}
+export function validateTeammateDisposition(input, identity, expectedSourceDigest) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        throw new Error("teammate disposition must be an object");
+    const value = input;
+    if (value.schema_version !== 1)
+        throw new Error("teammate disposition schema_version must be 1");
+    for (const key of [
+        "task_id",
+        "batch_id",
+        "assignment_id",
+        "attempt_id",
+        "teammate_id",
+    ]) {
+        const expected = identity[key === "task_id"
+            ? "taskId"
+            : key === "batch_id"
+                ? "batchId"
+                : key === "assignment_id"
+                    ? "assignmentId"
+                    : key === "attempt_id"
+                        ? "attemptId"
+                        : "teammateId"];
+        if (value[key] !== expected)
+            throw new Error(`disposition.${key} does not match the assigned identity`);
+    }
+    if (value.status !== "accepted" && value.status !== "final_failed") {
+        throw new Error("disposition.status is invalid");
+    }
+    const sourceDigest = digest(value.source_digest, "disposition.source_digest");
+    if (sourceDigest !== expectedSourceDigest)
+        throw new Error("disposition source digest does not match the assigned brief");
+    const reason = value.reason === undefined
+        ? undefined
+        : boundedText(value.reason, "disposition.reason");
+    if (value.status === "final_failed" && reason === undefined)
+        throw new Error("final_failed disposition requires a reason");
+    return {
+        schemaVersion: 1,
+        ...identity,
+        status: value.status,
+        sourceDigest,
+        ...(reason ? { reason } : {}),
+    };
+}
+export function writeTeammateClaim(input) {
+    const execution = input.launch
+        ? {
+            role_id: input.launch.roleId,
+            provider: input.launch.provider,
+            ...(input.launch.profile ? { profile: input.launch.profile } : {}),
+            ...(input.launch.model ? { model: input.launch.model } : {}),
+            ...(input.launch.reasoningEffort
+                ? { reasoning_effort: input.launch.reasoningEffort }
+                : {}),
+            options: input.launch.options,
+            ...(input.launch.profileDigest
+                ? { profile_digest: input.launch.profileDigest }
+                : {}),
+            role_digest: input.launch.roleDigest,
+            context_digest: input.launch.contextDigest,
+            capability_digest: input.launch.capability.digest,
+        }
+        : undefined;
+    const claim = validateTeammateClaim({
+        schema_version: 1,
+        task_id: input.identity.taskId,
+        batch_id: input.identity.batchId,
+        assignment_id: input.identity.assignmentId,
+        attempt_id: input.identity.attemptId,
+        teammate_id: input.identity.teammateId,
+        plan_hash: input.planHash,
+        brief_digest: input.briefDigest,
+        source_digest: input.sourceDigest,
+        slot: input.slot,
+        status: "issued",
+        ...(execution ?? {}),
+    }, input.identity, input.planHash, input.sourceDigest, input.briefDigest);
+    writeImmutableJson(attemptArtifactPath(input.taskRoot, input.briefPath, input.identity.attemptId, "claim.json"), {
+        schema_version: claim.schemaVersion,
+        task_id: claim.taskId,
+        batch_id: claim.batchId,
+        assignment_id: claim.assignmentId,
+        attempt_id: claim.attemptId,
+        teammate_id: claim.teammateId,
+        plan_hash: claim.planHash,
+        ...(claim.briefDigest ? { brief_digest: claim.briefDigest } : {}),
+        source_digest: claim.sourceDigest,
+        slot: claim.slot,
+        status: claim.status,
+        ...(claim.execution
+            ? {
+                role_id: claim.execution.roleId,
+                provider: claim.execution.provider,
+                ...(claim.execution.profile
+                    ? { profile: claim.execution.profile }
+                    : {}),
+                ...(claim.execution.model ? { model: claim.execution.model } : {}),
+                ...(claim.execution.reasoningEffort
+                    ? { reasoning_effort: claim.execution.reasoningEffort }
+                    : {}),
+                options: claim.execution.options,
+                ...(claim.execution.profileDigest
+                    ? { profile_digest: claim.execution.profileDigest }
+                    : {}),
+                role_digest: claim.execution.roleDigest,
+                context_digest: claim.execution.contextDigest,
+                capability_digest: claim.execution.capabilityDigest,
+            }
+            : {}),
+    });
+}
+export function writeTeammateQueueFact(input) {
+    const queue = validateTeammateQueueFact({
+        schema_version: 1,
+        task_id: input.taskId,
+        batch_id: input.batchId,
+        assignment_id: input.assignmentId,
+        plan_hash: input.planHash,
+        brief_digest: input.briefDigest,
+        source_digest: input.sourceDigest,
+        brief_path: input.briefPath,
+        queue_index: input.queueIndex,
+        status: "queued",
+    }, {
+        taskId: input.taskId,
+        batchId: input.batchId,
+        assignmentId: input.assignmentId,
+    }, input.planHash, input.briefDigest, input.sourceDigest);
+    writeImmutableJson(safePath(input.taskRoot, path.join(path.dirname(input.briefPath), "queue.json")), {
+        schema_version: queue.schemaVersion,
+        task_id: queue.taskId,
+        batch_id: queue.batchId,
+        assignment_id: queue.assignmentId,
+        plan_hash: queue.planHash,
+        brief_digest: queue.briefDigest,
+        source_digest: queue.sourceDigest,
+        brief_path: queue.briefPath,
+        queue_index: queue.queueIndex,
+        status: queue.status,
+    });
+}
+export function appendTeammateWorklog(input) {
+    const checkpoint = boundedText(input.checkpoint, "worklog.checkpoint");
+    rejectSecrets(checkpoint, "worklog.checkpoint");
+    const filePath = attemptArtifactPath(input.taskRoot, input.briefPath, input.attemptId, "worklog.md");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const fd = fs.openSync(filePath, "a", 0o600);
+    try {
+        fs.writeFileSync(fd, `${checkpoint}\n`, "utf8");
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export function writeTeammateReport(input) {
+    const report = validateTeammateReport({
+        schema_version: 1,
+        task_id: input.identity.taskId,
+        batch_id: input.identity.batchId,
+        assignment_id: input.identity.assignmentId,
+        attempt_id: input.identity.attemptId,
+        teammate_id: input.identity.teammateId,
+        plan_hash: input.identity.planHash,
+        phase_id: input.identity.phaseId,
+        task_route_revision: input.identity.taskRouteRevision,
+        input_revision: input.identity.inputRevision,
+        status: input.status,
+        source_digest: input.sourceDigest,
+        evidence: input.evidence,
+    }, input.identity, input.sourceDigest);
+    writeImmutableJson(attemptArtifactPath(input.taskRoot, input.briefPath, input.identity.attemptId, "report.json"), {
+        schema_version: report.schemaVersion,
+        task_id: report.taskId,
+        batch_id: report.batchId,
+        assignment_id: report.assignmentId,
+        attempt_id: report.attemptId,
+        teammate_id: report.teammateId,
+        plan_hash: report.planHash,
+        phase_id: report.phaseId,
+        task_route_revision: report.taskRouteRevision,
+        input_revision: report.inputRevision,
+        status: report.status,
+        source_digest: report.sourceDigest,
+        evidence: report.evidence,
+    });
+}
+export function assertTeammateWriteAllowed(target, protectedTargets) {
+    const normalizedTarget = path.normalize(target);
+    for (const protectedTarget of protectedTargets) {
+        const normalizedProtected = path.normalize(protectedTarget);
+        if (normalizedTarget === normalizedProtected ||
+            normalizedTarget.startsWith(`${normalizedProtected}${path.sep}`)) {
+            throw new Error(`teammate write targets protected path: ${target}`);
+        }
+    }
+}
+export function writeTeammateDisposition(input) {
+    const disposition = validateTeammateDisposition({
+        schema_version: 1,
+        task_id: input.identity.taskId,
+        batch_id: input.identity.batchId,
+        assignment_id: input.identity.assignmentId,
+        attempt_id: input.identity.attemptId,
+        teammate_id: input.identity.teammateId,
+        status: input.status,
+        source_digest: input.sourceDigest,
+        ...(input.reason ? { reason: input.reason } : {}),
+    }, input.identity, input.sourceDigest);
+    writeImmutableJson(attemptArtifactPath(input.taskRoot, input.briefPath, input.identity.attemptId, "disposition.json"), {
+        schema_version: disposition.schemaVersion,
+        task_id: disposition.taskId,
+        batch_id: disposition.batchId,
+        assignment_id: disposition.assignmentId,
+        attempt_id: disposition.attemptId,
+        teammate_id: disposition.teammateId,
+        status: disposition.status,
+        source_digest: disposition.sourceDigest,
+        ...(disposition.reason ? { reason: disposition.reason } : {}),
+    });
+}
+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);
+    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);
+    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