@joshuafolkken/kit 1.1229.0 → 1.1370.0

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

@@ -8,7 +8,7 @@ import {
 } from './run-wake'
 import type { LaunchResult } from './run-wake-session'
 
-// The supervisor's body: read the carry record, decide, act, sleep, repeat (joshuafolkken/kit#1719).
+// The supervisor's body: read the carry record, decide, act, sleep, repeat.
 //
 // **Everything it touches is a port**, so the loop is testable without a real process, a real clock or
 // a real Telegram. What is left here is the sequencing, which is the part worth pinning: a run that
@@ -24,7 +24,7 @@ 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** (joshuafolkken/kit#2417). While a launch is
+// **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
@@ -35,14 +35,13 @@ interface LoopPorts {
 	// The carry record, re-read every pass rather than cached: it is written by the parent loop of a
 	// different session, which is the whole point of reading it here.
 	read_carry: () => CarryRead
-	// Whether the process named on the carry record is still running. The cutting session writes
-	// `--cut` and then exits, so the two moments are not the same one and the supervisor has to wait
-	// out the second — `run-wake.ts` → `WakeDecisionInput.is_owner_live`.
+	// Whether the process named on the carry record is still running, which tells a session at work
+	// from a crashed one — `run-wake.ts` → `WakeDecisionInput.is_owner_live`.
 	is_owner_live: (read: CarryRead) => boolean
 	// A compatibility probe for the wake decision. Production lets the resident driver inspect work,
 	// including an empty idle watch, without starting an AI session.
 	has_work: (read: CarryRead) => Promise<boolean | undefined>
-	// **The forced transcript id is generated here and handed to `wake`** (joshuafolkken/kit#2407), so
+	// **The forced transcript id is generated here and handed to `wake`**, so
 	// the loop stays deterministic under test — a fixture returns a known id — while production draws a
 	// fresh UUID. The same id is recorded on the wake record, which is how `josh time --run` later knows
 	// the session was one this supervisor started.
@@ -108,19 +107,13 @@ async function wake_step(wake: RunWake, ports: LoopPorts): Promise<StepOutcome>
 }
 
 // A `wait` means the woken session has claimed the carry record, so the wake mark is cleared and the
-// next cut starts the grace window afresh — **and it is the only pass on which `woke` may grow**
-// (joshuafolkken/kit#1746), because arriving here is the supervisor observing that a record it was
-// waiting on has been taken over. A `hold` starts the ceiling on a wait without launching
-// anything — the bounded wait on a predecessor that has cut but not yet exited, which ends the moment
-// that predecessor does. A `pending` keeps what is there, because the window it is measured from is
-// still open.
+// next cut starts the grace window afresh — **and it is the only pass on which `woke` may grow**,
+// because arriving here is the supervisor observing that a record it was
+// waiting on has been taken over. A `pending` keeps what is there, because the window it is measured
+// from is still open.
 function continue_step(wake: RunWake, decision: WakeDecision, ports: LoopPorts): StepOutcome {
 	if (decision.kind === 'wait') return { kind: 'continue', wake: run_wake.count_claim(wake) }
 
-	if (decision.kind === 'hold') {
-		return { kind: 'continue', wake: run_wake.mark_wait(wake, ports.now()) }
-	}
-
 	if (decision.kind === 'idle') {
 		return { kind: 'continue', wake: run_wake.mark_idle(wake, ports.now()) }
 	}
@@ -146,16 +139,15 @@ function decision_input(wake: RunWake, ports: LoopPorts): WakeDecisionInput {
 		woke_at: wake.woke_at,
 		attempts: wake.attempts ?? NO_ATTEMPTS,
 		is_owner_live: ports.is_owner_live(read),
-		held_at: wake.held_at,
 		has_work: undefined,
 		idle_since: wake.idle_since,
 		now: ports.now(),
 	}
 }
 
-// **Work is asked about only where the answer could change the decision** (joshuafolkken/kit#2417):
-// on a pass the record alone would launch from. Every other pass — the in-flight wait, the pending
-// grace window, the hold — decides from the record as before and costs no backlog read.
+// **Work is asked about only where the answer could change the decision**: on a pass the record alone
+// would launch from. Every other pass — the in-flight wait, the pending grace window — decides from
+// the record alone and costs no backlog read.
 async function decide_pass(wake: RunWake, ports: LoopPorts): Promise<WakeDecision> {
 	const input = decision_input(wake, ports)
 	const decision = run_wake.decide(input)
@@ -195,7 +187,7 @@ 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.
 //
-// **`read_own_wake` rather than `read_wake`, and the difference is a whole pass** (joshuafolkken/kit#1727).
+// **`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
 // supervisor is already serving, and only then finding the write-back refused. Read as owned or not

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

@@ -1,10 +1,9 @@
 import { run_wake_loop, type LoopStop } from './run-wake-loop'
 
-// **A supervisor that fails while the run is still resumable restarts itself** (joshuafolkken/kit#3332).
-// A `backlog:drive` that exited on a transient `main:sync` failure ended the supervisor as `failed`,
-// and the run then sat for forty minutes with a valid carry record, waiting for one `run:wake --start`
-// that only a person was left to type — joshuafolkken/kit#3297's "resume it yourself" rule binds an AI
-// session, and once the supervisor is gone there is none to read it.
+// **A supervisor that fails while the run is still resumable restarts itself.** Otherwise a
+// `backlog:drive` that exited on a transient failure would leave a valid carry record waiting for a
+// `run:wake --start` that only a person is left to type — once the supervisor is gone, no AI session
+// remains to resume it.
 //
 // **Bounded, and only the bound reaches a person.** A failure that is not transient fails again on
 // every pass, so the restarts stop at `RESTART_LIMIT` and the last failure is handed back for the

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

@@ -5,34 +5,28 @@ import { detached_launch, type LaunchArgv } from '#scripts/run/detached-launch'
 import { run_invocation } from '#scripts/run/run-invocation'
 
 // How the supervisor starts things: the next agent session, and — at `--start` — its own detached
-// self. Both go through one `launch`, because the two differ only in what is being run
-// (joshuafolkken/kit#1719).
+// self. Both go through one `launch`, because the two differ only in what is being run.
 //
-// **The launch itself is no longer this file's** (joshuafolkken/kit#1749). `detached-launch.ts` holds
-// it, because a delegated child dispatched into a lane needs the same mechanism and none of the
-// invocation parsing this supervisor needs. What stays here is the constants naming the agent CLI and
-// the two argument vectors this supervisor composes.
+// **The launch itself is `detached-launch.ts`'s**, because a delegated child dispatched into a lane
+// needs the same mechanism and none of the invocation parsing this supervisor needs. What stays here
+// is the constants naming the agent CLI and the two argument vectors this supervisor composes.
 //
-// **The invocation grammar is no longer this file's either** (joshuafolkken/kit#1774; folded into
-// `backlogrun` by joshuafolkken/kit#1984). `run-carry.ts` reads the same grammar to say which of a
-// `backlogrun`'s named issues are still outstanding — so it is `run-invocation.ts`'s, imported
-// rather than restated. What that move does **not** change is the rebuild-from-constants design: the
-// invocation handed to the agent CLI is still composed out of that module's own constants and
-// validated integers; a judgment handoff adds the driver's result after that validated invocation.
+// **The invocation grammar is `run-invocation.ts`'s**, imported rather than restated, because
+// `run-carry.ts` reads the same grammar to say which of a `backlogrun`'s named issues are still
+// outstanding. The invocation handed to the agent CLI is composed out of that module's own constants
+// and validated integers; a judgment handoff adds the driver's result after that validated invocation.
 //
-// **The agent CLI is a constant, not configuration, and it is the Claude adapter's constant.** It was
-// an environment variable first (`JOSH_WAKE_COMMAND`), which put the choice of *which binary runs* in
-// reach of anything that can set an environment — and this binary runs unattended, overnight, in the
-// person's own checkout with the person's own credentials. Shape-checking the name does not address
-// that; removing the choice does. The two names below are aliases of that one constant rather than a
-// second copy of it (joshuafolkken/kit#1749).
+// **The agent CLI is a constant, not configuration, and it is the Claude adapter's constant.** An
+// environment variable would put the choice of *which binary runs* in reach of anything that can set
+// an environment — and this binary runs unattended, overnight, in the person's own checkout with the
+// person's own credentials. Shape-checking the name does not address that; removing the choice does.
+// The two names below are aliases of that one constant rather than a second copy of it.
 //
 // **The waker adds nothing to what may be run.** The argument vector is the constant command plus an
 // invocation rebuilt to say exactly what the record said, and nothing here writes a label: `auto-ok`
 // arrives only through `issue:file`'s default, so a woken session is offered by exactly the rules the
-// first one was. A
-// pool that grew across the seam is `backlogrun-steps.md` → "What one invocation approves", not the
-// waker's doing (joshuafolkken/kit#1675).
+// first one was. A pool that grew across the seam is `backlogrun-steps.md` → "What one invocation
+// approves", not the waker's doing.
 const WAKE_COMMAND = claude_agent_argv.AGENT_COMMAND
 const WAKE_FLAGS = claude_agent_argv.AGENT_FLAGS
 const LOOP_FLAG = '--loop'
@@ -43,6 +37,8 @@ const CONTROL_CHARACTERS = /[\u{0}-\u{1F}\u{7F}]/gu
 
 function scheduler_profile(): AgentProfile | undefined {
 	const resolved = agent_role_profile.resolve(agent_role_profile.SCHEDULER)
+
+	agent_role_profile.warn_of_default()
 	if (resolved.kind === 'profile') return resolved.profile
 
 	console.error(resolved.note)
@@ -75,12 +71,12 @@ function safe_invocation(invocation: string): string | undefined {
 	return rebuilt === invocation ? rebuilt : undefined
 }
 
-// **The two failure modes are kept apart, not folded into one `undefined`** (joshuafolkken/kit#1932).
+// **The two failure modes are kept apart, not folded into one `undefined`.**
 // An unmatched or unsafe invocation is `undefined` and the caller names it as one; a rejected effort
 // override carries the role resolver's own note through the `rejected` variant, so a
 // `JOSH_SCHEDULER_EFFORT` typo is reported as the env typo it is rather than as unreadable carried text.
-// **`session_id` forces the woken session's transcript id, and only where a work tree is given**
-// (joshuafolkken/kit#2407). A wake always resolves both a profile and the primary checkout, so it
+// **`session_id` forces the woken session's transcript id, and only where a work tree is given.** A
+// wake always resolves both a profile and the primary checkout, so it
 // reaches the `with_profile_in` branch; the cwd-less branch stays for callers that force nothing.
 function profiled_argv(
 	invocation: string,
@@ -99,7 +95,7 @@ function resolved_argv(invocation: string, cwd?: string): AgentArgvResult {
 		: agent_argv.resolve_in(invocation, agent_role_profile.SCHEDULER, cwd)
 }
 
-// **Handoff material is made safe to launch rather than refused** (joshuafolkken/kit#2931). It is the
+// **Handoff material is made safe to launch rather than refused.** It is the
 // driver's own output, not the record, so it is flattened — a newline becomes a separator, any other
 // control character a space — and the prompt is cut at the cap `is_safe_value` enforces. The driver puts
 // its verdict and resume line first, so the cut only ever shortens the details. The check itself is
@@ -143,8 +139,8 @@ function supervisor_argv(script_path: string, interval?: string): LaunchArgv {
 }
 
 // **`ensure_log`, `is_safe_argv` and `launch` are re-exported rather than reimplemented.** They are
-// `detached-launch.ts`'s now; naming them here keeps `run:wake`'s own callers reading one namespace,
-// and there is exactly one implementation behind both names (joshuafolkken/kit#1749).
+// `detached-launch.ts`'s; naming them here keeps `run:wake`'s own callers reading one namespace, and
+// there is exactly one implementation behind both names.
 const run_wake_session = {
 	INTERVAL_FLAG,
 	LOOP_FLAG,