@ai-dossier/sched 0.67.0 → 0.68.0

package/README.md

@@ -464,6 +464,58 @@ Only SIGINT had a handler, so a SIGTERM/SIGHUP (another session's restart, a clo
 terminal) killed the engine with no line and no lease release. That is now logged; if the
 2026-09-29 cause was SIGKILL/OOM, the missing `engine-exit` plus the stale lease is now the
 documented signature (`journalctl -k` for the OOM window).
+### Restart never discards work (#945, #940)
+
+Before the engine respawns an agent onto a worktree that already exists — a batch **tail**, a
+batch **member** reusing its worktree, an issue **takeover** — it preserves whatever the dead
+agent left there (`preserve.ts`):
+
+- a WIP commit under the **non-branch** ref `refs/sched-rescue/<unit>-<timestamp>` (adds no branch,
+  triggers no CI), holding every tracked change (`git add -u`, deletions and staged renames
+  included), the unpushed commits, and those untracked / staged-new files that pass the **secret
+  and size filter**, journaled as `work-preserved` (`branch` = the ref). **Only tracked changes and
+  unpushed commits are ever pushed.** A rescue whose tree also holds untracked / staged-new files
+  stays **local** (the ref lives in the local repo; the worktree and its `.git` survive a respawn
+  anyway) and says `local only` in the journal and the respawn prompt. The final tree is filtered
+  once more: any path new relative to HEAD (a rename into a secret name, `git add -N`, staged-new)
+  matching `.env*`, `*.env.*`, `*.pem`/`*.key` (and `*.pem.*`/`*.key.*`), `id_rsa*`, `id_ed25519*`,
+  `*credentials*`, `*secret*`, `*token*`, `*.p12`, `*.pfx`, `*.tfstate*`, `*.tfvars`, `kubeconfig`,
+  `.kube/`, `.docker/config.json`, `.pypirc`, `.vault-token`, `.htpasswd`, `.s3cfg`, `.npmrc`,
+  `.netrc`, `.ssh/` … is dropped. Untracked files over 1 MiB, past 500 files / 16 MiB, tracked
+  changes over 50 MiB and submodule/nested-repo contents are not captured; they stay in the
+  worktree and the journal / prompt count what was skipped and why. This filter is
+  defence-in-depth: the rescue bypasses the pre-commit secret scan;
+- **TTL is housekeeping, not privacy.** A pushed rescue ref is **world-readable on a public
+  repository, and deleting a ref does NOT unpublish it** (GitHub keeps objects reachable by SHA).
+  Rescue refs older than 14 days (by the timestamp in the ref name) are deleted locally and on
+  origin (listed with `git ls-remote`, so refs pushed from other clones are covered) together with
+  their `sched-rescue-pushed-<sha>` markers: at `sched start` and then daily outside the state
+  lock. A ref whose remote deletion fails for any reason but "already gone" is kept and retried.
+  Find live ones with `git for-each-ref refs/sched-rescue`;
+- built with a throwaway index, so the worktree, its index and its HEAD are untouched — the
+  respawned agent still finds the files in place, and preservation cannot itself lose work;
+- idempotent: an unchanged tree reuses its existing rescue ref instead of minting one per tick;
+- the respawned agent's prompt gets a `PRESERVED WORK` instruction naming the ref and forbidding a
+  reset to the last pushed head. A failed push is journaled (`pushed: false` in the detail) and is
+  not fatal; an unpreservable worktree journals `work-preserve-failed` and is left as it is.
+
+A takeover's worktree path comes from a setup milestone (an issue comment), so it is acted on only
+when `git worktree list` registers it in this repository, it is under the sanctioned `worktrees/`
+roots, it is not the main checkout, and no batch holds it (`takeoverWorktreeRefusal`; a refusal is
+journaled `work-preserve-failed` and never blocks the respawn). **The takeover rescue runs outside
+the state lock** (it shells out to `gh`, `git` and `git push`): a stalled unit enters recovery on
+one tick and its takeover is spawned on the next, after the rescue. Takeover preservation is on
+only when the engine is given a `rescueExec` (the CLI wires one, 120 s per call).
+
+**Batch tail, respawn only:** when the previous tail exited unverified and its worktree holds
+uncommitted files, or the NEWEST `gate.batch` row in `caps.jsonl` for that worktree (matched by realpath of `cwd`) is a
+passing run on a **dirty** tree (`dirty: true` or `git_probe` set — #941's fields) newer than the
+last pushed head while local work exists, the engine does **not** respawn. Rows without #941's
+fields (the engine's own post-landing gate rows) and clean rows are never evidence; an older dirty
+row is superseded by a newer clean or failed one. It blocks the batch `tail-dirty-worktree`, with the evidence and the
+rescue ref in the journal and `sched status`. Commit or discard the work in the worktree, then
+`sched resume --batch <id>`. A tail that left only unpushed commits is respawned, told to resume
+from the rescue ref. `sched resume --batch` deliberately does NOT re-run this guard: by resuming, the operator has looked at the worktree.
 
 ### Zombie-run fencing (#504)
 

package/dist/batch-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}

package/dist/batch-dispatch.js

@@ -106,6 +106,7 @@ exports.reconcileKeptWorktrees = reconcileKeptWorktrees;
 exports.memberDispatchModeFor = memberDispatchModeFor;
 exports.runBatchTick = runBatchTick;
 const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const core_1 = require("@ai-dossier/core");
 const worktree_pool_1 = require("@ai-dossier/worktree-pool");
@@ -117,6 +118,7 @@ const dossier_root_1 = require("./dossier-root");
 const groundtruth_1 = require("./groundtruth");
 const journal_1 = require("./journal");
 const merge_mechanism_1 = require("./merge-mechanism");
+const preserve_1 = require("./preserve");
 const readiness_1 = require("./readiness");
 const recovery_1 = require("./recovery");
 const run_log_1 = require("./run-log");
@@ -166,6 +168,98 @@ function sanitizeUntrustedText(value) {
 function journalEvent(deps, event, unitId, extra = {}) {
     deps.journal.append((0, journal_1.unitEvent)(event, unitId, extra), deps.now());
 }
+/**
+ * #945: preserve whatever a dead agent left in `worktree` before a respawn
+ * reuses it (see `preserve.ts`). Journals the outcome; returns the preserved
+ * work for the respawned agent's prompt, or undefined when there was nothing to
+ * preserve (clean) or preservation was not possible (failure is journaled, the
+ * worktree is untouched either way — the respawn is not made worse by it).
+ */
+function preserveForRespawn(deps, unitId, worktree, now) {
+    const outcome = (0, preserve_1.preserveWork)(deps.exec, { worktree, unit: unitId, now });
+    return journalPreserveOutcome(deps, unitId, worktree, outcome);
+}
+function journalPreserveOutcome(deps, unitId, worktree, outcome) {
+    if (outcome.kind === 'preserved') {
+        const w = outcome.work;
+        // A REUSED rescue was journaled when it was minted; a respawn loop must not
+        // add a line per tick.
+        if (!w.reused) {
+            const skipped = (0, preserve_1.skippedSummary)(w.skipped);
+            journalEvent(deps, 'work-preserved', unitId, {
+                branch: w.ref,
+                worktree,
+                detail: `${w.dirty_files} uncommitted file(s) + ${w.unpushed_commits} unpushed commit(s) on head ${w.head} preserved as ${w.sha} at ${w.ref} (${w.pushed ? 'pushed' : w.local_only ? 'local only — includes untracked files, never pushed' : 'NOT pushed — local ref only'})${skipped ? `; ${skipped}` : ''}; the respawned agent is told to resume from it`,
+            });
+        }
+        return w;
+    }
+    if (outcome.kind === 'failed' && (0, preserve_1.firstOccurrence)(deps.journal, `${unitId}|${outcome.reason}`)) {
+        journalEvent(deps, 'work-preserve-failed', unitId, {
+            worktree,
+            detail: `${outcome.reason} — ${outcome.probe.dirty_files} uncommitted file(s), ${outcome.probe.unpushed_commits} unpushed commit(s) left in place in the worktree`,
+        });
+    }
+    return undefined;
+}
+/**
+ * #940 ask 1 + #945: before RESPAWNING a batch tail onto its batch worktree,
+ * preserve what the dead tail left there, and refuse the respawn when that
+ * includes uncommitted files or a passing DIRTY `gate.batch` run past the last
+ * pushed head (`findGatedWorkEvidence`) — the operator decides commit vs
+ * discard (`tail-dirty-worktree`, resumable via `sched resume --batch`, which
+ * deliberately does not re-run this guard: the operator has looked). Clean or
+ * only-unpushed: respawn, told to resume from the rescue ref.
+ */
+function guardTailRespawn(deps, batch, now) {
+    const worktree = batch.worktree;
+    if (worktree === null)
+        return { block: null, instruction: null };
+    const unitId = unit(batch.id);
+    const outcome = (0, preserve_1.preserveWork)(deps.exec, { worktree, unit: unitId, now });
+    const work = journalPreserveOutcome(deps, unitId, worktree, outcome);
+    if (outcome.kind === 'skipped')
+        return { block: null, instruction: null };
+    const probe = outcome.kind === 'preserved' || outcome.kind === 'failed' || outcome.kind === 'clean'
+        ? outcome.probe
+        : null;
+    if (probe === null)
+        return { block: null, instruction: null };
+    const since = (0, preserve_1.pushedHeadDate)(deps.exec, worktree);
+    const gate = since === null
+        ? null
+        : (0, preserve_1.findGatedWorkEvidence)({
+            capsFile: path.join(deps.homeDir ?? os.homedir(), '.dossier', 'caps.jsonl'),
+            worktree,
+            sinceIso: since,
+            headTree: headTreeOf(deps, worktree),
+            hasLocalWork: probe.dirty_files > 0 || probe.unpushed_commits > 0,
+            now,
+        });
+    // Stray untracked files (logs, scratch) that the rescue deliberately left out must not wedge a
+    // respawn: block on tracked changes, on untracked work the rescue captured, or when the
+    // state is unknowable (a failed rescue counts everything as dirty).
+    const rescuedUntracked = work?.untracked_included ?? 0;
+    const dirty = outcome.kind === 'failed'
+        ? probe.dirty_files > 0
+        : probe.tracked_dirty_files > 0 || rescuedUntracked > 0;
+    if (dirty || gate !== null) {
+        // Its own event: `work-preserved` above already said (once) what was saved, or
+        // `work-preserve-failed` said it was not — this line must not claim otherwise.
+        journalEvent(deps, 'tail-respawn-refused', unitId, {
+            worktree,
+            reason: 'tail-dirty-worktree',
+            detail: `tail respawn refused: ${probe.dirty_files} uncommitted file(s) at head ${probe.head}${gate ? `; a gate.batch ok row at ${gate.timestamp} ran on a dirty tree newer than the last pushed head` : ''}${work ? `; a rescue exists at ${work.ref} (${work.sha})` : outcome.kind === 'failed' ? '; NO rescue could be made' : ''}. Commit or discard in ${worktree}, then \`sched resume --batch ${batch.id}\``,
+        });
+        return { block: 'tail-dirty-worktree', instruction: null };
+    }
+    return { block: null, instruction: work ? (0, preserve_1.preservedWorkInstruction)(work) : null };
+}
+/** HEAD's tree id (for gate-evidence comparison), null when unreadable. */
+function headTreeOf(deps, worktree) {
+    const tree = deps.exec('git', ['rev-parse', 'HEAD^{tree}'], worktree);
+    return tree === null || tree.trim() === '' ? null : tree.trim();
+}
 /** Whether the slot's agent is still alive (pid-start-safe: a reused pid reads dead). */
 function agentAlive(deps, slot) {
     return slot.pid !== null && deps.spawnDeps.isAlive(slot.pid, slot.pid_start ?? undefined);
@@ -1160,7 +1254,9 @@ function spawnMemberAgent(deps, dispatch, state, slot, batchId, now, result, tar
         // #822: a member respawned after running the wrong procedure.
         (batch.reprompted_members.some((r) => r.issue === memberIssue)
             ? (0, dispatch_1.wrongProcedureDirective)(memberIssue, batchId)
-            : '');
+            : '') +
+        // #945: a respawn onto a reused worktree resumes from what was preserved there.
+        (target.member.preserved ? `\n\n${(0, preserve_1.preservedWorkInstruction)(target.member.preserved)}` : '');
     const logFile = (0, dispatch_1.batchMemberLogPath)(deps.store.runsDir, batchId, target.index, memberIssue);
     // #629: captured BEFORE spawning, mirroring `engine.ts`'s own
     // `spawnAndRecord` — the log is per-role and append-mode, so the size at
@@ -1451,6 +1547,10 @@ function spawnMemberContinuation(deps, config, dispatch, batchId, now, result) {
             worktree: batch.member_worktree,
             poolClaimed: batch.member_pool_claimed,
         };
+        // #945: preserve whatever the previous agent left BEFORE the respawn, outside the lock.
+        const preserved = preserveForRespawn(deps, `batch:${batchId}#${memberIssue}`, member.worktree, now);
+        if (preserved)
+            member.preserved = preserved;
     }
     else {
         if (batch.member_worktree !== null) {
@@ -1514,12 +1614,23 @@ function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
     // #887: read outside the store lock (a cache miss runs `gh api`).
     const mechanism = deps.groundTruth.mergeMechanism?.();
     const pending = (0, state_1.findBatch)(before, batchId);
+    // #945/#940: a RESPAWN (the previous tail exited unverified) never lands on
+    // work it cannot see — preserve first, outside the store lock.
+    let resumeNote = null;
     if (pending) {
         const refusal = tailDispatchRefusal(before, pending);
         if (refusal !== null) {
             blockBatchForOperator(deps, config, batchId, { reason: refusal, milestonePhase: 'batch-review' }, now, result);
             return;
         }
+        if (pending.agent_exits?.phase === 'tail' && pending.agent_exits.count >= 1) {
+            const guard = guardTailRespawn(deps, pending, now);
+            if (guard.block !== null) {
+                blockBatchForOperator(deps, config, batchId, { reason: guard.block, milestonePhase: 'batch-review' }, now, result);
+                return;
+            }
+            resumeNote = guard.instruction;
+        }
     }
     claimAndSpawn(deps, config, batchId, 'reviewing', now, (state, slot) => {
         const batch = (0, state_1.findBatch)(state, batchId);
@@ -1545,7 +1656,7 @@ function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
         const cmd = spawnSpec.cmd;
         const prompt = (0, dispatch_1.buildBatchTailPrompt)(dispatch.batchTailPrompt, batchId, batch.anchor, landed, batch.worktree, 
         // #887: the repo's detected merge mechanism decides detached vs attached ship.
-        mechanism);
+        mechanism) + (resumeNote === null ? '' : `\n\n${resumeNote}`);
         const logFile = (0, dispatch_1.batchTailLogPath)(deps.store.runsDir, batchId);
         // #629: fences `handleDeadDispatchApiError`'s classification to this
         // dispatch's slice — see `spawnMember`'s identical comment.
@@ -4480,6 +4591,9 @@ function spawnParallelMembers(deps, config, dispatch, batchId, now, result) {
                 worktree: next.run.worktree,
                 poolClaimed: next.run.pool_claimed,
             };
+            const preserved = preserveForRespawn(deps, (0, state_1.batchMemberUnit)(batchId, next.issue), member.worktree, now);
+            if (preserved)
+                member.preserved = preserved;
         }
         else {
             // The serial-member fields describe no member of a parallel batch —