@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/scheduler/night-harvest.js

@@ -0,0 +1,412 @@
+import { rm } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { filterSourceDirtyPorcelain } from "./git-base.js";
+import { getLeasePath } from "./paths.js";
+import { verifyEvidenceArchive } from "./evidence.js";
+import { patchScheduleIsolation, transitionSchedule, } from "./lifecycle.js";
+import { readAdmission, readExecution, readSchedule } from "./store.js";
+import { releaseExecutionLease } from "./lease.js";
+import { validateTaskCard } from "./traceability.js";
+import { SCHEDULER_ERROR_CODES, SchedulerError, } from "./types.js";
+/**
+ * MVP harvest: exact-base fast-forward only.
+ * Refuses when base HEAD moved, dirty, missing evidence, or bad mergeState.
+ */
+export async function harvestNightSchedule(input) {
+    const now = input.now ?? new Date();
+    const controlRepoRoot = path.resolve(input.controlRepoRoot);
+    const schedule = await readSchedule(controlRepoRoot, input.scheduleId);
+    if (!schedule) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.NOT_FOUND, `schedule not found: ${input.scheduleId}`);
+    }
+    if (schedule.status !== "succeeded") {
+        return blocked("schedule-not-succeeded", `schedule status is ${schedule.status}, expected succeeded`, "Inspect schedule status / evidence; only succeeded pending-harvest can harvest");
+    }
+    if (schedule.isolation?.mergeState !== "pending-harvest") {
+        return blocked("merge-state-invalid", `mergeState is ${schedule.isolation?.mergeState ?? "missing"}, expected pending-harvest`, schedule.isolation?.mergeState === "merged"
+            ? "Already harvested"
+            : "Use scheduler status / doctor before harvest");
+    }
+    const baseBranch = schedule.isolation.baseBranch;
+    const baseCommit = schedule.isolation.baseCommit;
+    const nightBranch = schedule.isolation.branch;
+    const worktreeRel = schedule.isolation.worktreePath;
+    if (!baseBranch || !baseCommit || !nightBranch) {
+        return blocked("isolation-incomplete", "schedule isolation missing baseBranch/baseCommit/branch", "Doctor admission/isolation facts");
+    }
+    if (nightBranch !== `night/${schedule.id}`) {
+        return blocked("night-branch-unsafe", `night branch must be night/${schedule.id}, got ${nightBranch}`, "Run scheduler doctor and repair the tampered isolation facts");
+    }
+    let safeWorktreePath;
+    if (worktreeRel) {
+        try {
+            safeWorktreePath = resolveSafeNightWorktreePath(controlRepoRoot, worktreeRel);
+        }
+        catch (error) {
+            return blocked("worktree-path-unsafe", error instanceof Error ? error.message : String(error), "Run scheduler doctor and repair the tampered isolation facts");
+        }
+    }
+    const baseStatus = (await runGit(controlRepoRoot, [
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+    ])).trimEnd();
+    // Scheduler/Task Pool runtime under .harness and night worktrees are expected
+    // control facts; they must not block harvest of source commits.
+    const dirtySource = filterSourceDirtyPorcelain(baseStatus);
+    if (dirtySource.length > 0) {
+        return blocked("base-dirty", `control repo has uncommitted source changes: ${dirtySource
+            .slice(0, 5)
+            .map((line) => line.slice(3).trim())
+            .join(", ")}`, "Commit or stash base source changes, then retry harvest");
+    }
+    const currentBranch = (await runGit(controlRepoRoot, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    if (currentBranch !== baseBranch) {
+        return blocked("base-branch-mismatch", `checked out ${currentBranch}, expected base branch ${baseBranch}`, `git checkout ${baseBranch} then retry harvest`);
+    }
+    const head = (await runGit(controlRepoRoot, ["rev-parse", "HEAD"])).trim();
+    if (head !== baseCommit) {
+        return blocked("base-moved", `base HEAD ${head.slice(0, 12)} != frozen baseCommit ${baseCommit.slice(0, 12)}`, "MVP refuses harvest when base moved; integrate manually or open Phase 3.5+ integration worktree");
+    }
+    const isAncestor = await runGitAllowFail(controlRepoRoot, [
+        "merge-base",
+        "--is-ancestor",
+        baseCommit,
+        nightBranch,
+    ]);
+    if (isAncestor.exitCode !== 0) {
+        return blocked("night-branch-not-descendant", `night branch ${nightBranch} is not a descendant of frozen baseCommit`, "Inspect night branch history; do not force FF");
+    }
+    // Traceability: every commit on night branch after base must mention work item when required.
+    const cardCheck = await auditBranchTraceability(controlRepoRoot, baseCommit, nightBranch, schedule);
+    if (!cardCheck.ok) {
+        return blocked("traceability-failed", cardCheck.reason, "Fix commit messages on night branch or discard");
+    }
+    // Evidence archive integrity when execution id present
+    if (schedule.currentExecutionId) {
+        const evidenceOk = await evidenceArchivePresent(controlRepoRoot, schedule.currentExecutionId);
+        if (!evidenceOk) {
+            return blocked("evidence-missing", `evidence archive missing for ${schedule.currentExecutionId}`, "Restore evidence or re-archive before harvest");
+        }
+    }
+    // Fast-forward only
+    try {
+        await runGit(controlRepoRoot, ["merge", "--ff-only", nightBranch]);
+    }
+    catch (error) {
+        return blocked("ff-failed", error instanceof Error ? error.message : String(error), "Resolve history manually; MVP does not rebase/merge");
+    }
+    const mergedCommit = (await runGit(controlRepoRoot, ["rev-parse", "HEAD"])).trim();
+    let worktreeRemoved = false;
+    let branchDeleted = false;
+    if (!input.keepWorktree && safeWorktreePath) {
+        try {
+            await runGit(controlRepoRoot, [
+                "worktree",
+                "remove",
+                "--force",
+                safeWorktreePath,
+            ]);
+            worktreeRemoved = true;
+        }
+        catch {
+            try {
+                await rm(safeWorktreePath, { recursive: true, force: true });
+                await runGit(controlRepoRoot, ["worktree", "prune"]).catch(() => { });
+                worktreeRemoved = true;
+            }
+            catch {
+                worktreeRemoved = false;
+            }
+        }
+        try {
+            await runGit(controlRepoRoot, ["branch", "-d", nightBranch]);
+            branchDeleted = true;
+        }
+        catch {
+            branchDeleted = false;
+        }
+    }
+    // succeeded is already terminal — only patch mergeState + ledger (no status change).
+    await patchScheduleIsolation({
+        controlRepoRoot,
+        scheduleId: schedule.id,
+        isolation: {
+            mode: "git-worktree",
+            required: true,
+            baseBranch: schedule.isolation.baseBranch,
+            baseCommit: schedule.isolation.baseCommit,
+            worktreePath: schedule.isolation.worktreePath,
+            branch: schedule.isolation.branch,
+            mergePolicy: schedule.isolation.mergePolicy,
+            mergeState: "merged",
+        },
+        event: "merge_completed",
+        reason: `fast-forward ${nightBranch} -> ${baseBranch}`,
+        reasonCode: "merged",
+        ...(schedule.currentExecutionId
+            ? {
+                evidencePaths: [
+                    `.harness/task-pool/scheduler/evidence/${schedule.currentExecutionId}`,
+                ],
+            }
+            : {}),
+        now,
+    });
+    return {
+        ok: true,
+        scheduleId: schedule.id,
+        baseBranch,
+        baseCommit,
+        nightBranch,
+        mergedCommit,
+        fastForward: true,
+        worktreeRemoved,
+        branchDeleted,
+        mergeState: "merged",
+    };
+}
+/**
+ * Discard night worktree/branch after evidence is retained.
+ * Failed/human_required require --force.
+ */
+export async function discardNightSchedule(input) {
+    const now = input.now ?? new Date();
+    const controlRepoRoot = path.resolve(input.controlRepoRoot);
+    const schedule = await readSchedule(controlRepoRoot, input.scheduleId);
+    if (!schedule) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.NOT_FOUND, `schedule not found: ${input.scheduleId}`);
+    }
+    const activeRuntime = new Set(["dispatching", "running", "cancel_requested"]);
+    if (activeRuntime.has(schedule.status)) {
+        return blocked("still-running", `cannot discard schedule in status ${schedule.status}`, "Wait for terminal status or cancel first");
+    }
+    if ((schedule.status === "failed" || schedule.status === "human_required") &&
+        !input.force) {
+        return blocked("force-required", `discard of ${schedule.status} schedule requires --force`, `agent-worker scheduler discard ${schedule.id} --repo . --reason "..." --force`);
+    }
+    if (schedule.currentExecutionId) {
+        const evidenceOk = await evidenceArchivePresent(controlRepoRoot, schedule.currentExecutionId);
+        if (!evidenceOk) {
+            // Still allow discard if never executed (no execution file)
+            const execution = await readExecution(controlRepoRoot, schedule.currentExecutionId);
+            if (execution) {
+                return blocked("evidence-missing", `evidence archive missing for ${schedule.currentExecutionId}`, "Archive evidence before discard so control root retains forensics");
+            }
+        }
+    }
+    // Drop lease if any
+    await releaseExecutionLease({
+        controlRepoRoot,
+        scheduleId: schedule.id,
+    }).catch(() => { });
+    try {
+        await rm(getLeasePath(controlRepoRoot, schedule.id), { force: true });
+    }
+    catch {
+        // ignore
+    }
+    const nightBranch = schedule.isolation?.branch;
+    const worktreeRel = schedule.isolation?.worktreePath;
+    if (nightBranch && nightBranch !== `night/${schedule.id}`) {
+        return blocked("night-branch-unsafe", `night branch must be night/${schedule.id}, got ${nightBranch}`, "Run scheduler doctor and repair the tampered isolation facts");
+    }
+    let safeWorktreePath;
+    if (worktreeRel) {
+        try {
+            safeWorktreePath = resolveSafeNightWorktreePath(controlRepoRoot, worktreeRel);
+        }
+        catch (error) {
+            return blocked("worktree-path-unsafe", error instanceof Error ? error.message : String(error), "Run scheduler doctor and repair the tampered isolation facts");
+        }
+    }
+    let worktreeRemoved = false;
+    let branchDeleted = false;
+    if (safeWorktreePath) {
+        try {
+            await runGit(controlRepoRoot, [
+                "worktree",
+                "remove",
+                "--force",
+                safeWorktreePath,
+            ]);
+            worktreeRemoved = true;
+        }
+        catch {
+            try {
+                await rm(safeWorktreePath, { recursive: true, force: true });
+                await runGit(controlRepoRoot, ["worktree", "prune"]).catch(() => { });
+                worktreeRemoved = true;
+            }
+            catch {
+                worktreeRemoved = false;
+            }
+        }
+    }
+    if (nightBranch) {
+        try {
+            await runGit(controlRepoRoot, ["branch", "-D", nightBranch]);
+            branchDeleted = true;
+        }
+        catch {
+            branchDeleted = false;
+        }
+    }
+    // Keep schedule terminal status; only mergeState → discarded + ledger.
+    if (schedule.status === "scheduled" ||
+        schedule.status === "waiting" ||
+        schedule.status === "validated" ||
+        schedule.status === "submitted" ||
+        schedule.status === "validating") {
+        await transitionSchedule({
+            controlRepoRoot,
+            scheduleId: schedule.id,
+            toStatus: "cancelled",
+            event: "worktree_discarded",
+            reason: input.reason,
+            reasonCode: "discard",
+            patch: {
+                isolation: {
+                    mode: "git-worktree",
+                    required: true,
+                    baseBranch: schedule.isolation?.baseBranch,
+                    baseCommit: schedule.isolation?.baseCommit,
+                    worktreePath: schedule.isolation?.worktreePath,
+                    branch: schedule.isolation?.branch,
+                    mergePolicy: schedule.isolation?.mergePolicy ?? "manual-on-success",
+                    mergeState: "discarded",
+                },
+                cancelReason: input.reason,
+            },
+            now,
+        });
+    }
+    else {
+        await patchScheduleIsolation({
+            controlRepoRoot,
+            scheduleId: schedule.id,
+            isolation: {
+                mode: "git-worktree",
+                required: true,
+                baseBranch: schedule.isolation?.baseBranch,
+                baseCommit: schedule.isolation?.baseCommit,
+                worktreePath: schedule.isolation?.worktreePath,
+                branch: schedule.isolation?.branch,
+                mergePolicy: schedule.isolation?.mergePolicy ?? "manual-on-success",
+                mergeState: "discarded",
+            },
+            event: "worktree_discarded",
+            reason: input.reason,
+            reasonCode: "discarded",
+            ...(schedule.currentExecutionId
+                ? {
+                    evidencePaths: [
+                        `.harness/task-pool/scheduler/evidence/${schedule.currentExecutionId}`,
+                    ],
+                }
+                : {}),
+            now,
+        });
+    }
+    return {
+        ok: true,
+        scheduleId: schedule.id,
+        worktreeRemoved,
+        branchDeleted,
+        mergeState: "discarded",
+        reason: input.reason,
+    };
+}
+function resolveSafeNightWorktreePath(controlRepoRoot, worktreeRef) {
+    if (path.isAbsolute(worktreeRef)) {
+        throw new Error(`night worktree path must be repo-relative: ${worktreeRef}`);
+    }
+    const worktreeRoot = path.resolve(controlRepoRoot, ".worktrees");
+    const candidate = path.resolve(controlRepoRoot, worktreeRef);
+    const relative = path.relative(worktreeRoot, candidate);
+    if (relative.length === 0 ||
+        relative.startsWith("..") ||
+        path.isAbsolute(relative)) {
+        throw new Error(`night worktree path escapes .worktrees: ${worktreeRef}`);
+    }
+    return candidate;
+}
+function blocked(code, message, nextAction) {
+    return { ok: false, code, message, nextAction };
+}
+async function evidenceArchivePresent(controlRepoRoot, executionId) {
+    return (await verifyEvidenceArchive({ controlRepoRoot, executionId })).ok;
+}
+async function auditBranchTraceability(controlRepoRoot, baseCommit, nightBranch, schedule) {
+    const required = schedule.traceability?.requiredOnEveryPushableCommit ??
+        schedule.traceability?.requiredOnCreate ??
+        false;
+    if (!required)
+        return { ok: true };
+    const workItemRef = schedule.traceability?.workItemRef;
+    const card = validateTaskCard(workItemRef, {
+        required: true,
+        label: schedule.traceability?.label ?? "Task Card",
+        pattern: schedule.traceability?.pattern ?? "^[A-Z][A-Z0-9]+-[A-Z0-9]+#[0-9]+$",
+        commitMessageTemplate: schedule.traceability?.commitMessageTemplate ??
+            "{summary}\n\n{workItemRef}",
+    });
+    if (!card.ok || !card.workItemRef) {
+        return {
+            ok: false,
+            reason: card.ok ? "missing workItemRef" : card.reason,
+        };
+    }
+    const log = (await runGit(controlRepoRoot, [
+        "log",
+        `${baseCommit}..${nightBranch}`,
+        "--format=%H%n%B%n==END==",
+    ])).trim();
+    if (!log) {
+        return { ok: false, reason: "no commits on night branch after base" };
+    }
+    const messages = log
+        .split("==END==")
+        .map((part) => part.trim())
+        .filter(Boolean);
+    for (const block of messages) {
+        const body = block.split("\n").slice(1).join("\n");
+        if (!body.includes(card.workItemRef)) {
+            const sha = block.split("\n")[0] ?? "?";
+            return {
+                ok: false,
+                reason: `commit ${sha.slice(0, 12)} missing task card ${card.workItemRef}`,
+            };
+        }
+    }
+    return { ok: true };
+}
+async function runGit(cwd, args) {
+    const result = await runGitAllowFail(cwd, args);
+    if (result.exitCode !== 0) {
+        throw new Error(`git ${args.join(" ")} failed (exit ${result.exitCode}): ${result.stderr}`);
+    }
+    return result.stdout;
+}
+async function runGitAllowFail(cwd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("git", ["-C", cwd, ...args], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout?.on("data", (c) => stdout.push(c));
+        child.stderr?.on("data", (c) => stderr.push(c));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve({
+                exitCode: code ?? 1,
+                stdout: Buffer.concat(stdout).toString("utf-8"),
+                stderr: Buffer.concat(stderr).toString("utf-8"),
+            });
+        });
+    });
+}
+// keep admission import used for future branch ownership checks
+void readAdmission;

package/dist/worker/scheduler/paths.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import { getTaskPoolRoot } from "../pool/run-store.js";
+import { SCHEDULER_ERROR_CODES, SchedulerError } from "./types.js";
+export const SCHEDULER_RELATIVE_ROOT = ".harness/task-pool/scheduler";
+const SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function assertSafeSchedulerId(value, label) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        !SAFE_SEGMENT.test(value)) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.UNSAFE_ID, `${label} contains unsafe path characters: ${JSON.stringify(value)}`);
+    }
+}
+export function getSchedulerRoot(controlRepoRoot) {
+    return path.join(getTaskPoolRoot(controlRepoRoot), "scheduler");
+}
+export function getSchedulesDir(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "schedules");
+}
+export function getAdmissionsDir(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "admissions");
+}
+export function getExecutionsDir(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "executions");
+}
+export function getTransactionsDir(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "transactions");
+}
+export function getLeasesDir(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "leases");
+}
+export function getEvidenceDir(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "evidence");
+}
+export function getReportsDir(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "reports");
+}
+export function getLedgerPath(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "ledger.jsonl");
+}
+export function getMutationLockPath(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "mutation.lock");
+}
+/** Actual tick receipt (manual + OS timer share this file). */
+export function getClockReceiptPath(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "clock.json");
+}
+/** Managed OS timer install receipt (not the same as tick evidence). */
+export function getClockInstallReceiptPath(controlRepoRoot) {
+    return path.join(getSchedulerRoot(controlRepoRoot), "clock-install.json");
+}
+export function getSchedulePath(controlRepoRoot, scheduleId) {
+    assertSafeSchedulerId(scheduleId, "scheduleId");
+    const schedulePath = path.join(getSchedulesDir(controlRepoRoot), `${scheduleId}.json`);
+    assertWithinSchedulerRoot(controlRepoRoot, schedulePath);
+    return schedulePath;
+}
+export function getAdmissionPath(controlRepoRoot, scheduleId) {
+    assertSafeSchedulerId(scheduleId, "scheduleId");
+    const admissionPath = path.join(getAdmissionsDir(controlRepoRoot), `${scheduleId}.json`);
+    assertWithinSchedulerRoot(controlRepoRoot, admissionPath);
+    return admissionPath;
+}
+export function getExecutionPath(controlRepoRoot, executionId) {
+    assertSafeSchedulerId(executionId, "executionId");
+    const executionPath = path.join(getExecutionsDir(controlRepoRoot), `${executionId}.json`);
+    assertWithinSchedulerRoot(controlRepoRoot, executionPath);
+    return executionPath;
+}
+export function getTransactionPath(controlRepoRoot, transitionId) {
+    assertSafeSchedulerId(transitionId, "transitionId");
+    const transactionPath = path.join(getTransactionsDir(controlRepoRoot), `${transitionId}.json`);
+    assertWithinSchedulerRoot(controlRepoRoot, transactionPath);
+    return transactionPath;
+}
+export function getLeasePath(controlRepoRoot, scheduleId) {
+    assertSafeSchedulerId(scheduleId, "scheduleId");
+    const leasePath = path.join(getLeasesDir(controlRepoRoot), `${scheduleId}.json`);
+    assertWithinSchedulerRoot(controlRepoRoot, leasePath);
+    return leasePath;
+}
+export function relativeSchedulerPath(controlRepoRoot, absolutePath) {
+    const relative = path.relative(path.resolve(controlRepoRoot), absolutePath);
+    return relative.split(path.sep).join("/");
+}
+function assertWithinSchedulerRoot(controlRepoRoot, candidatePath) {
+    const root = path.resolve(getSchedulerRoot(controlRepoRoot));
+    const resolved = path.resolve(candidatePath);
+    const relative = path.relative(root, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.UNSAFE_ID, `Scheduler path escapes scheduler root: ${candidatePath}`);
+    }
+}