@joshuafolkken/kit 1.1379.0 → 1.1383.0

package/scripts/run/run-stop-notify.ts

@@ -28,7 +28,7 @@ const STOP_RECOVERY =
 // nothing readable there is no run this can honestly say stopped.
 function plan(read: CarryRead, reason: string | undefined): StopNotice | undefined {
 	if (reason === undefined || reason.length === 0) return undefined
-	if (read.kind !== 'carried' && read.kind !== 'expired') return undefined
+	if (read.kind !== 'carried') return undefined
 
 	return { reason }
 }

package/scripts/run/run-stranded-detect.ts

@@ -18,7 +18,7 @@ import {
 //
 // **Cheap and local.** Every read is a file on disk — the carry record, the wake record — and a process
 // liveness probe; there is no network call, so unlike the stall detector this makes every read every
-// time. The gate is the carry record itself: nothing carried, or a record that is expired or unreadable,
+// time. The gate is the carry record itself: nothing carried, or a record that is unreadable,
 // returns before the wake record is even read.
 
 // The recovery line names the command that hands the run to a fresh supervisor — the same one the pure
@@ -74,8 +74,8 @@ const DEFAULT_PORTS: DetectPorts = {
 	notify_stranded: real_notify_stranded,
 }
 
-// The three facts, assembled behind the carry-record gate. A non-`carried` read — nothing carried, a
-// spent bound, or an unreadable record — is `undefined`: there is no live budget to be stranded, so the
+// The three facts, assembled behind the carry-record gate. A non-`carried` read — nothing carried, or
+// an unreadable record — is `undefined`: there is no live budget to be stranded, so the
 // wake record is never read and the judge is never asked.
 async function gather(ports: DetectPorts): Promise<StrandedInput | undefined> {
 	const targets = await ports.resolve_targets()

package/scripts/run/run-stranded.ts

@@ -2,10 +2,10 @@ import { process_identity } from '#scripts/josh/process-identity'
 import { run_carry, type CarryRead, type RunCarry } from '#scripts/run/carry/run-carry'
 import type { RunWake } from '#scripts/run/wake/run-wake'
 
-// The mechanical judge of a *stranded* run: a handed-off budget whose cutting session died, with no
-// successor claiming it and no supervisor watching, so lanes run on with nobody driving. Three facts,
-// read and never weighed, are what say that state has been reached: the budget was handed off, its
-// owner is gone, and no supervisor is alive to wake a successor.
+// The mechanical judge of a *stranded* run: a budget whose owning session died — at a cut it handed
+// off, or with no hand-off at all — with no successor holding it and no supervisor watching, so lanes
+// run on with nobody driving. Three facts, read and never weighed, are what say that state has been
+// reached: the record names a driver, that owner is gone, and no supervisor is alive to wake a successor.
 //
 // **Pure by design, exactly as `backlog-stalled.ts` is.** The carry read, the owner's liveness and the
 // supervisor's are handed in, so the four acceptance cases — all three holding, a live owner, a claimed
@@ -72,19 +72,27 @@ function supervisor_liveness(
 	return is_same ? LIVE : GONE
 }
 
-// **The whole of the judgement, in four reads.** The carry record must be `carried` — an `expired`,
-// `none` or `unreadable` read is never a strand, because there is either no budget to strand or no way
-// to trust what the record says. It must be handed off and *not* yet adopted — `adopt_carry` spends
-// `is_handed_off` the instant a successor claims it, so a claimed successor reads `false` here. The owner
-// must be gone — a live owner is a session still spending the budget, the ordinary in-flight state. And
-// the supervisor must be `gone` — `live` or `unknown` both count as something that could still wake a
-// successor, so only a proven-absent supervisor completes the strand.
+// Whether the record names a driver whose absence can be proven: a hand-off waiting for its successor,
+// or an owner process. A record with neither was begun by nobody this machine can probe, and an
+// unprovable owner is never a strand.
+function had_driver(carry: RunCarry): boolean {
+	return carry.is_handed_off === true || carry.owner_pid !== undefined
+}
+
+// **The whole of the judgement, in four reads.** The carry record must be `carried` — a `none` or
+// `unreadable` read is never a strand, because there is either no run to strand or no way to trust
+// what the record says. The owner must be gone — a live owner is a session still spending the budget,
+// the ordinary in-flight state, and a successor that claimed a hand-off is that live owner, since
+// `adopt_carry` rewrites the owner as it spends `is_handed_off`. The record must name the driver that
+// is gone (`had_driver`). And the supervisor must be `gone` — `live` or `unknown` both count as
+// something that could still wake a successor, so only a proven-absent supervisor completes the strand.
+//
+// **A hand-off is not required.** An owner that died between its claim and the next cut — the
+// supervisor killed mid-drive, an interactive parent's terminal closed — leaves a record no cut handed
+// off, and with no supervisor nothing drives it either. `run-wake.ts` → `decide_not_handed_off`
+// recovers exactly that record, so the recovery the notification names holds for it too.
 function is_stranded(input: StrandedInput): boolean {
-	if (
-		input.read.kind !== 'carried' ||
-		input.read.carry.is_handed_off !== true ||
-		input.is_owner_live
-	) {
+	if (input.read.kind !== 'carried' || input.is_owner_live || !had_driver(input.read.carry)) {
 		return false
 	}
 
@@ -94,7 +102,7 @@ function is_stranded(input: StrandedInput): boolean {
 // The one line a person reads in the notification and on the stream: which run is stranded, and why. The
 // carry record's own summary carries the counts; this frames it as the strand it is.
 function describe(carry: RunCarry): string {
-	return `Run stranded — ${run_carry.describe_carry(carry)}. The owner is gone, no cut successor claimed the budget, and no supervisor is watching.`
+	return `Run stranded — ${run_carry.describe_carry(carry)}. The owner is gone, no successor holds the budget, and no supervisor is watching.`
 }
 
 function verdict_of(is_run_stranded: boolean): StrandedVerdict {

package/scripts/run/wake/run-wake-cli.ts

@@ -3,6 +3,7 @@ import { randomUUID } from 'node:crypto'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { AgentProfile } from '#scripts/agent/agent-role-profile'
+import { backlog_budget } from '#scripts/backlog/backlog-budget'
 import { cli_flags } from '#scripts/lib/cli-flags'
 import { poll } from '#scripts/lib/poll'
 import { telegram_notify } from '#scripts/notify/telegram-notify'
@@ -34,7 +35,6 @@ const FAILURE_EXIT_CODE = 1
 const ARGV_OFFSET = 2
 const ONE_GROUP = 1
 const MS_PER_SECOND = 1000
-const DEFAULT_INTERVAL_SECONDS = 60
 // Whole and positive. A zero interval is a busy loop against the temp directory, not a faster
 // supervisor.
 const INTERVAL_PATTERN = /^[1-9]\d*$/u
@@ -71,17 +71,15 @@ const WARNING_RECOVERY = `Check the wake command, then restart with \`pnpm josh
 // `stopped` is a person's own `--stop` or a supervisor being superseded, and a warning channel that
 // fired on those is one that stops being read.
 //
-// **`expired` and `unreadable` warn**, because both end the supervisor while a carry record is still
-// sitting there handed off, so the run would otherwise be left asleep with nothing anywhere saying so.
+// **`unreadable` warns**, because it ends the supervisor while a carry record is still sitting there
+// handed off, so the run would otherwise be left asleep with nothing anywhere saying so.
 // **Every reason is listed, and the silent two are listed as `undefined`.** A partial map would let a
-// sixth stop reason compile straight past this and reach nobody, which is the defect class this
+// fifth stop reason compile straight past this and reach nobody, which is the defect class this
 // section exists to close.
 const STOP_BODIES: Record<WakeStopReason, string | undefined> = {
 	ended: undefined,
 	stopped: undefined,
 	failed: 'The supervisor could not continue the run and has stopped.',
-	expired:
-		'The carried run passed its whole-run bound, so the supervisor stopped without continuing it.',
 	unreadable:
 		'The carry record could not be read, so the supervisor stopped rather than guess at it.',
 }
@@ -118,7 +116,7 @@ function note_to_stderr(note: string): void {
 }
 
 function to_interval_ms(value: string | boolean | undefined): number | undefined {
-	if (typeof value !== 'string') return DEFAULT_INTERVAL_SECONDS * MS_PER_SECOND
+	if (typeof value !== 'string') return backlog_budget.OFFER_INTERVAL_MS
 	if (!INTERVAL_PATTERN.test(value)) return undefined
 
 	const seconds = Number(value)
@@ -221,9 +219,9 @@ async function warn_of_stop(stop: LoopStop, body: string, context: WakeContext):
 	})
 }
 
-// **Only a failed wake exits non-zero; `expired` and `unreadable` warn but exit zero.** The
+// **Only a failed wake exits non-zero; `unreadable` warns but exits zero.** The
 // verdict-and-exit-code table in `docs/josh-commands-automation.md` is a contract callers branch on,
-// and what those two need is the notification, not a different exit code.
+// and what that one needs is the notification, not a different exit code.
 function exit_code_of(reason: WakeStopReason): number {
 	return reason === run_wake_loop.FAILED_REASON ? FAILURE_EXIT_CODE : SUCCESS_EXIT_CODE
 }

package/scripts/run/wake/run-wake-describe.ts

@@ -32,7 +32,7 @@ interface WakeContext {
 }
 
 function carry_cuts(read: CarryRead): string {
-	if (read.kind === 'carried' || read.kind === 'expired') return String(read.carry.cuts)
+	if (read.kind === 'carried') return String(read.carry.cuts)
 
 	return UNKNOWN_CUTS
 }
@@ -70,15 +70,13 @@ function deadline(marked_at: string | undefined, limit_ms: number): string {
 }
 
 // A live owner that is this supervisor is its own driver at work; any other is a session spending the
-// budget, which has no deadline of its own short of the carry record's whole-run expiry.
+// budget, which has no deadline of its own.
 function owner_wait(wake: RunWake, carry: RunCarry): string {
 	if (carry.owner_pid === wake.pid) {
 		return 'waiting: the driver holds the carry record and is running'
 	}
 
-	const expiry = deadline(carry.started_at, run_carry.CARRY_MAX_AGE_MS)
-
-	return `waiting: process ${String(carry.owner_pid)} holds the carry record; the driver starts at its next cut or once it exits, and the record expires at ${expiry}`
+	return `waiting: process ${String(carry.owner_pid)} holds the carry record; the driver starts at its next cut or once it exits`
 }
 
 const WAIT_LINES: Partial<Record<WakeDecision['kind'], (wake: RunWake) => string>> = {

package/scripts/run/wake/run-wake-driver.ts

@@ -159,9 +159,9 @@ function is_mechanical(result: JoshResult): boolean {
 	)
 }
 
-// A record that expired or was removed during the pause answers `undefined`: its stale verdict must not
-// reach a session, so the supervisor's own next pass re-reads the record and ends the run as `expired`
-// or `stopped`; a rerun would only fail on it and report the run as `failed`.
+// A record that was removed during the pause answers `undefined`: its stale verdict must not reach a
+// session, so the supervisor's own next pass re-reads the record and ends the run as `ended` or
+// `stopped`; a rerun would only fail on it and report the run as `failed`.
 async function run_driver(
 	target: string,
 	args: ReadonlyArray<string>,

package/scripts/run/wake/run-wake-loop.ts

@@ -24,12 +24,6 @@ const STOPPED_REASON: WakeStopReason = 'stopped'
 const FAILED_REASON: WakeStopReason = 'failed'
 const NO_ATTEMPTS = 0
 const STOPPED_BY_PERSON: LoopStop = { reason: STOPPED_REASON, note: undefined }
-// **The back-off after repeated whiffs, and its ceiling.** While a launch is
-// deferred for want of work, each wait is as long as the idle stretch so far — so the polling interval
-// doubles pass by pass — capped at this multiple of the configured one. Eight times the one-minute
-// default is eight minutes: far fewer backlog reads over a long empty stretch, and still well inside
-// the idle ceiling, so work that appears is picked up within one capped wait.
-const MAX_BACKOFF_FACTOR = 8
 
 interface LoopPorts {
 	// The carry record, re-read every pass rather than cached: it is written by the parent loop of a
@@ -157,18 +151,6 @@ async function decide_pass(wake: RunWake, ports: LoopPorts): Promise<WakeDecisio
 	return run_wake.decide({ ...input, has_work: await ports.has_work(input.read) })
 }
 
-// The wait before the next pass: the configured interval, stretched while a launch is being deferred
-// to the length of the idle stretch so far and capped at `MAX_BACKOFF_FACTOR` times the interval.
-function next_interval(wake: RunWake | undefined, interval_ms: number, now: Date): number {
-	const idle_since = wake?.idle_since === undefined ? NaN : Date.parse(wake.idle_since)
-
-	if (Number.isNaN(idle_since)) return interval_ms
-
-	const stretched = Math.max(interval_ms, now.getTime() - idle_since)
-
-	return Math.min(stretched, interval_ms * MAX_BACKOFF_FACTOR)
-}
-
 // The record is re-read at the top of every pass rather than carried in a variable, so a `--stop` that
 // removed it ends the loop at the next interval and a `--list` reads what the loop actually wrote.
 // One pass: decide, act, write the result back. `undefined` means carry on to the next interval.
@@ -187,6 +169,9 @@ async function run_pass(
 // The record is re-read at the top of every pass rather than carried in a variable, so a `--stop` that
 // removed it ends the loop at the next interval and a `--list` reads what the loop actually wrote.
 //
+// **The wait between two passes is the configured interval, however long the run has been idle**: a
+// launch deferred for want of work is asked about again as soon as a running one would be.
+//
 // **`read_own_wake` rather than `read_wake`, and the difference is a whole pass.**
 // A record that has become a *successor's* is not this loop's to act on, and reading it back would
 // have this pass decide from another supervisor's counters — spawning a session for a cut that
@@ -203,7 +188,7 @@ async function run_loop(target: string, ports: LoopPorts, interval_ms: number):
 		if (stop !== undefined) return stop
 
 		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
-		await ports.sleep(next_interval(run_wake.read_own_wake(target), interval_ms, ports.now()))
+		await ports.sleep(interval_ms)
 		wake = run_wake.read_own_wake(target)
 	}
 
@@ -212,8 +197,6 @@ async function run_loop(target: string, ports: LoopPorts, interval_ms: number):
 
 const run_wake_loop = {
 	FAILED_REASON,
-	MAX_BACKOFF_FACTOR,
-	next_interval,
 	run_loop,
 }
 

package/scripts/run/wake/run-wake-restart.ts

@@ -15,7 +15,7 @@ interface RestartPorts {
 	// One run of the loop over the record the caller claimed once and holds across every restart, so a
 	// `--stop` landing in the pause is read by the next pass as the person's stop.
 	pass: () => Promise<LoopStop>
-	// Whether the carry record can still be continued — `carried`, neither `expired` nor gone.
+	// Whether the carry record can still be continued — `carried`, neither unreadable nor gone.
 	is_resumable: () => boolean
 	pause: () => Promise<void>
 	note: (text: string) => void

package/scripts/run/wake/run-wake.ts

@@ -9,7 +9,7 @@ import { z } from 'zod'
 
 // The process outside the conversation that starts the next session after a `backlogrun` cut.
 // Whether to wake is the carry record's answer, never a judgement: `carried` and handed off wakes;
-// `none`, `expired` (the whole-run bound) and `unreadable` stop. A hand-off is set by `run:carry --cut`,
+// `none` and `unreadable` stop. A hand-off is set by `run:carry --cut`,
 // or by this supervisor when it recovers a record whose owner died, so a live session never reads as
 // waiting. The supervisor owns the record while its deterministic driver spends the budget; a judgment
 // branch hands it off so one AI session can adopt it.
@@ -23,8 +23,8 @@ const WAKE_LOG_SUFFIX = '.log'
 const WAKE_GRACE_MS = 600_000
 // Retried before failing: stopping ends a run nobody is watching.
 const MAX_WAKE_ATTEMPTS = 3
-// An empty backlog still needs one session to finish the run, so a deferral is bounded by the
-// `backlogrun` idle watch's own default.
+// A run with nothing to start still needs one session to finish it, so a deferral is bounded by the
+// `backlogrun` idle wait itself.
 const IDLE_CEILING_MS = backlog_budget.DEFAULT_IDLE_MS
 const NO_WAKES = 0
 const ONE_WAKE = 1
@@ -49,11 +49,11 @@ interface RunWake {
 	woke_pid?: number | undefined
 	// Every `--session-id` this forced, so `josh time --run` attributes whiffs only to its own sessions.
 	spawned?: ReadonlyArray<string> | undefined
-	// Start of one unbroken idle stretch: bounds the deferral and backs off the polling interval.
+	// Start of one unbroken idle stretch: bounds the deferral.
 	idle_since?: string | undefined
 }
 
-type WakeStopReason = 'ended' | 'expired' | 'unreadable' | 'failed' | 'stopped'
+type WakeStopReason = 'ended' | 'unreadable' | 'failed' | 'stopped'
 
 // `superseded`: another supervisor holds the record and this process is the replaced one.
 type WakeTidyResult = 'absent' | 'removed' | 'superseded'
@@ -87,9 +87,8 @@ const WAIT_DECISION: WakeDecision = { kind: 'wait' }
 const PENDING_DECISION: WakeDecision = { kind: 'pending' }
 const FAILED_DECISION: WakeDecision = { kind: 'failed' }
 
-const STOP_REASONS: Record<'none' | 'expired' | 'unreadable', WakeStopReason> = {
+const STOP_REASONS: Record<'none' | 'unreadable', WakeStopReason> = {
 	none: 'ended',
-	expired: 'expired',
 	unreadable: 'unreadable',
 }
 

package/scripts/backlog/backlog-idle.ts

@@ -1,88 +0,0 @@
-import { backlog_budget, type BudgetInput } from './backlog-budget'
-
-// The idle watch as a window a person can read: when the run began waiting on
-// an empty backlog, when the wait ends, and which bound ends it. Without it the moment the wait began
-// would live only in `backlog:drive`'s memory as `--active`, so a reader of the event stream could
-// tell the run was waiting but not until when. The budget names the
-// window, `backlog:offer` records it as an `idle` event, and `run:board` reads it back — all through the
-// text written and parsed here, so the three never spell it differently.
-
-type IdleBound = 'idle' | 'whole-run'
-
-interface IdleWindow {
-	since_ms: number
-	until_ms: number
-	// Which bound ends the wait: the idle budget running out, or the whole-run bound arriving first.
-	bound: IdleBound
-	// When the watching loop last asked the backlog — the poll the next one is counted from.
-	asked_ms: number
-}
-
-const TEXT_PATTERN =
-	/^idle since (?<since>\S+) until (?<until>\S+) \((?<bound>idle|whole-run)\) asked (?<asked>\S+)$/u
-const IDLE_BOUND: IdleBound = 'idle'
-const WHOLE_RUN_BOUND: IdleBound = 'whole-run'
-
-// The window an idle watch opened at `active_at_ms` runs for, as asked at `now_ms`, or `undefined` when
-// the watch is off. The wait ends at the earlier of the idle budget and the whole-run bound — the order
-// `decide` applies.
-function window_of(input: BudgetInput): IdleWindow | undefined {
-	if (input.idle_budget_ms === undefined) return undefined
-
-	const idle_until = input.active_at_ms + input.idle_budget_ms
-	const run_until = input.started_at_ms + backlog_budget.WHOLE_RUN_BUDGET_MS
-	const bound = run_until < idle_until ? WHOLE_RUN_BOUND : IDLE_BOUND
-
-	return {
-		since_ms: input.active_at_ms,
-		until_ms: Math.min(idle_until, run_until),
-		bound,
-		asked_ms: input.now_ms,
-	}
-}
-
-function iso_of(ms: number): string {
-	return new Date(ms).toISOString()
-}
-
-function text_of(window: IdleWindow): string {
-	const { since_ms, until_ms, bound, asked_ms } = window
-
-	return `idle since ${iso_of(since_ms)} until ${iso_of(until_ms)} (${bound}) asked ${iso_of(asked_ms)}`
-}
-
-function is_bound(value: string | undefined): value is IdleBound {
-	return value === IDLE_BOUND || value === WHOLE_RUN_BOUND
-}
-
-// A malformed stamp reads as no window rather than as `NaN`, so a mangled line is never drawn.
-function window_from(groups: Record<string, string>, bound: IdleBound): IdleWindow | undefined {
-	const since_ms = Date.parse(String(groups['since']))
-	const until_ms = Date.parse(String(groups['until']))
-	const asked_ms = Date.parse(String(groups['asked']))
-
-	return Number.isNaN(since_ms + until_ms + asked_ms)
-		? undefined
-		: { since_ms, until_ms, bound, asked_ms }
-}
-
-function parse(text: string): IdleWindow | undefined {
-	const groups = TEXT_PATTERN.exec(text)?.groups
-
-	if (groups === undefined || !is_bound(groups['bound'])) return undefined
-
-	return window_from(groups, groups['bound'])
-}
-
-// The next time the watching loop asks the backlog again: one `IDLE_POLL_MINUTES` after the ask the
-// stream recorded, never past the end of the wait — the interval `idle_watch_reason` tells the loop.
-function next_check_ms(window: IdleWindow): number {
-	const poll_ms = backlog_budget.IDLE_POLL_MINUTES * backlog_budget.MS_PER_MINUTE
-
-	return Math.min(window.asked_ms + poll_ms, window.until_ms)
-}
-
-const backlog_idle = { next_check_ms, parse, text_of, window_of }
-
-export { backlog_idle }
-export type { IdleBound, IdleWindow }