pi-better-harness 0.42.1 → 0.43.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.43.0] - 2026-11-11
+
+### Changed
+
+- Bundle Subagents 0.30.0 for the 60-minute default hard timeout, its session setting, and preserved timing across resumes.
+
 ## [0.42.1] - 2026-11-10
 
 ### Changed

package/node_modules/pi-better-subagents/README.md

@@ -18,7 +18,7 @@ Use `pi-better-subagents` when you want Pi to launch independent agent work with
 - Explicit tool allowlists for child sessions, and `skills` for prompt exposure: omit it to keep user-catalog discovery, pass `[]` for no skills, or pass absolute `SKILL.md` paths for exactly those. See [skill exposure](docs/usage.md#skill-exposure).
 - Durable logs, result retrieval, and [failure observations](docs/failure-observations.md) independent of lifecycle status. A live child handles its own tool errors; the parent is woken only for actionable incidents, and children can classify handled failures with `failure_disposition`.
 - Live background-work navigator for active runs.
-- Harness-owned run timing: every run gets independent factual alerts for a tool call left open (5 min) and for no progress (10 min), while wall-clock soft deadlines and hard ceilings are opt-in so productive agents are not stopped solely for taking a long time. Configure per spawn with `deadline_minutes`, `grace_minutes`, `max_minutes`, `tool_wait_minutes`, `stuck_minutes`, globally in `config.json` / `PI_SUBAGENT_*_MINUTES`, or in `/subagents settings`. See [usage notes](docs/usage.md#run-timing-deadline-ceiling-tool-wait-stuck).
+- Harness-owned run timing: every run gets independent factual alerts for a tool call left open (5 min) and for no progress (10 min), plus a 60-minute hard timeout. Change the timeout in `/subagents settings`; `0` disables it. Soft deadlines remain opt-in. Configure per spawn with `deadline_minutes`, `grace_minutes`, `max_minutes`, `tool_wait_minutes`, `stuck_minutes`, globally in `config.json` / `PI_SUBAGENT_*_MINUTES`, or in `/subagents settings`. See [usage notes](docs/usage.md#run-timing-deadline-ceiling-tool-wait-stuck).
 
 Every single or batch launch automatically joins one shared supervision watcher in the
 foreground Pi process. The last active run's exit or stop tears it down; a later

package/node_modules/pi-better-subagents/config.ts

@@ -195,6 +195,7 @@ export function writeSubagentSettings(
     settings: {
         delegationMode: DelegationMode;
         maxConcurrent: number;
+        maxMinutes?: number;
         /** Omit to preserve the saved value; `null` explicitly records discovery. */
         defaultSkills?: string[] | null;
         /** Omit to preserve the saved value. `0` disables that alert. */
@@ -207,12 +208,15 @@ export function writeSubagentSettings(
     if (!isDelegationMode(settings.delegationMode)) throw new Error("Invalid delegation mode.");
     if (!isConcurrencyCap(settings.maxConcurrent)) throw new Error("Concurrent subagents must be a positive whole number.");
     const next: {
-        delegationMode: DelegationMode; maxConcurrent: number; defaultSkills?: string[] | null;
+        delegationMode: DelegationMode; maxConcurrent: number; maxMinutes?: number; defaultSkills?: string[] | null;
         toolWaitMinutes?: number; stuckMinutes?: number;
     } = {
         delegationMode: settings.delegationMode,
         maxConcurrent: settings.maxConcurrent,
     };
+    if (settings.maxMinutes !== undefined) {
+        next.maxMinutes = validatedTimingMinutes(settings.maxMinutes, "maxMinutes");
+    }
     if (Object.hasOwn(settings, "defaultSkills")) {
         if (settings.defaultSkills === null) {
             next.defaultSkills = null;

package/node_modules/pi-better-subagents/docs/usage.md

@@ -283,15 +283,18 @@ by the existing harness runtime.
 Timeout control belongs to the harness, not to the prompt or the skill that
 launched the run. A time limit written into a prompt is enforced by nothing, and
 a parent that only notices late tends to kill a child that was still making
-progress. Every run gets a tool-wait alert and stall detection by default.
-Elapsed-time limits are opt-in because total runtime does not distinguish a slow
-agent from a stalled one.
+progress. Every run gets a tool-wait alert, stall detection, and a 60-minute hard
+timeout by default. Soft deadlines remain opt-in because total runtime does not
+distinguish a slow agent from a stalled one.
+Use Timeout (minutes) in `/subagents settings` to change the session default;
+Ctrl+S saves it for future sessions. `0` disables the timeout. Changes apply to
+new attempts, not runs already in progress.
 
 | Control | Default | What happens |
 |---------|---------|--------------|
 | Soft deadline (`deadline_minutes`) | Off | When configured, the child gets one steering message (delivered through Pi's steer queue after its current tool call finishes): stop starting new work, commit or save what is done, and report what is complete, what is not, and where the work is. The parent gets one wake saying so. |
 | Grace (`grace_minutes`) | 5 | Grace starts when the steering message actually reaches the child, which is after its current tool call. While the message is still waiting behind a running tool call, the deadline stop is held, so a test run that began just before the deadline is not killed mid-run. If the child has not finished by the end of grace, the harness stops it; the ordinary completion callback reports `killed; stopped: deadline`. A child that completes inside grace is not stopped; its surfaces say `deadline: finished in grace`. |
-| Hard ceiling (`max_minutes`) | Off | When configured, the run is stopped at once, without grace or a steer, and reported as `stopped: ceiling`. The ceiling bounds the run, including a tool call that never ends and an orphaned run (child gone, its process group still alive). |
+| Hard ceiling (`max_minutes`) | 60 | When configured, the run is stopped at once, without grace or a steer, and reported as `stopped: ceiling`. The ceiling bounds the run, including a tool call that never ends and an orphaned run (child gone, its process group still alive). |
 | Tool-wait window (`tool_wait_minutes`) | 5 | One tool call that stays open this long sends one factual parent wake for that call, including when it is a normal long test. Parallel calls alert independently. The alert never stops, cancels, or restarts the run, and a later call can alert on its own. |
 | Stuck window (`stuck_minutes`) | 10 | No progress (see below) for this long wakes the parent once (`stuck`). It never stops the run. After new progress, a later stuck spell wakes again. Time inside a running tool call is excluded, so tool waiting and no-progress are reported separately. |
 
@@ -351,8 +354,9 @@ three times wakes the parent once as an `Action required` incident
 deadline), `deadline: passed` (ended some other way after the deadline, for
 example it crashed or a user stopped it), `stopped: ceiling`, or `stuck`. The spawn response lists the limits in force.
 
-**Global defaults.** Precedence is spawn parameter, then environment, then
-`config.json`, then the built-in default:
+**Global defaults.** Precedence is spawn parameter, then the session timeout
+choice (for `max_minutes`), then environment, then `config.json`, then the
+built-in default:
 
 | Setting | Environment | `config.json` |
 |---------|-------------|---------------|

package/node_modules/pi-better-subagents/index.ts

@@ -41,6 +41,7 @@ import { createSubagentSettingsPage } from "./settings-page.ts";
 import { deliverSubagentPrompt, effectiveSubagentSettings, formatSubagentSettings, subagentSettingsTool, SUBAGENT_SETTINGS_CONTEXT } from "./effective-settings.ts";
 import { STEER_FILE_ENV, readSteerReceipt } from "./child-steer.ts";
 import {
+    continuationTimingParams,
     decideTiming,
     describeTiming,
     DEFAULT_TIMING_MINUTES,
@@ -2082,7 +2083,7 @@ export default function (pi: ExtensionAPI) {
     let catalogModelRegistry: ExtensionContext["modelRegistry"] | undefined;
     let delegationOverride: DelegationMode | undefined;
     let capOverride: number | undefined;
-    let timingOverride: { toolWaitMinutes?: number; stuckMinutes?: number } = {};
+    let timingOverride: { maxMinutes?: number; toolWaitMinutes?: number; stuckMinutes?: number } = {};
     interface SkillSelection { mode: SkillExposureMode; paths: string[] }
     let skillsOverride: SkillSelection | undefined;
     const savedSkills = (): SkillSelection & { source: "config" | "default"; error?: string } => {
@@ -2128,11 +2129,19 @@ export default function (pi: ExtensionAPI) {
     };
     const activeConcurrencyCap = (): number => capOverride ?? normalizeConcurrencyCap(loadConfig().maxConcurrent);
     const timingSettingsFor = (cfg = loadConfig()): TimingSettings => ({ ...cfg, ...timingOverride });
+    /** A per-run max_minutes wins; otherwise a session timeout choice beats the environment. */
+    const launchTimingParams = (params: TimingParams = {}): TimingParams => ({
+        ...params,
+        max_minutes: params.max_minutes ?? timingOverride.maxMinutes,
+    });
     interface TimingMinutesState {
+        maxMinutes: number;
         toolWaitMinutes: number;
         stuckMinutes: number;
+        timeoutSource: "environment" | "session" | "config" | "default";
         toolWaitSource: "environment" | "session" | "config" | "default";
         stuckSource: "environment" | "session" | "config" | "default";
+        defaultMaxMinutes: number;
         defaultToolWaitMinutes: number;
         defaultStuckMinutes: number;
         timingError?: string;
@@ -2147,24 +2156,36 @@ export default function (pi: ExtensionAPI) {
             envFor(key) !== undefined ? "environment"
                 : timingOverride[key] !== undefined ? "session"
                     : cfg[key] !== undefined && cfg[key] !== null ? "config" : "default";
+        const timeoutEnv = process.env[TIMING_ENV.max];
+        const timeoutSource = (): "environment" | "session" | "config" | "default" =>
+            timingOverride.maxMinutes !== undefined ? "session"
+                : timeoutEnv !== undefined && timeoutEnv.trim() !== "" ? "environment"
+                    : cfg.maxMinutes !== undefined && cfg.maxMinutes !== null ? "config" : "default";
         try {
-            const effective = resolveRunTiming({ settings: timingSettingsFor(cfg), env: process.env, startedAt: 0 });
+            const sessionTimeout = timingOverride.maxMinutes !== undefined ? { max_minutes: timingOverride.maxMinutes } : {};
+            const effective = resolveRunTiming({ params: sessionTimeout, settings: timingSettingsFor(cfg), env: process.env, startedAt: 0 });
             const defaults = resolveRunTiming({ settings: cfg, env: process.env, startedAt: 0 });
             const minutes = (ms: number | undefined): number => ms === undefined ? 0 : ms / 60_000;
             return {
+                maxMinutes: minutes(effective.ceilingAt),
                 toolWaitMinutes: minutes(effective.toolWaitMs),
                 stuckMinutes: minutes(effective.stuckMs),
+                timeoutSource: timeoutSource(),
                 toolWaitSource: sourceFor("toolWaitMinutes"),
                 stuckSource: sourceFor("stuckMinutes"),
+                defaultMaxMinutes: minutes(defaults.ceilingAt),
                 defaultToolWaitMinutes: minutes(defaults.toolWaitMs),
                 defaultStuckMinutes: minutes(defaults.stuckMs),
             };
         } catch (error) {
             return {
+                maxMinutes: DEFAULT_TIMING_MINUTES.max,
                 toolWaitMinutes: DEFAULT_TIMING_MINUTES.toolWait,
                 stuckMinutes: DEFAULT_TIMING_MINUTES.stuck,
+                timeoutSource: timeoutSource(),
                 toolWaitSource: sourceFor("toolWaitMinutes"),
                 stuckSource: sourceFor("stuckMinutes"),
+                defaultMaxMinutes: DEFAULT_TIMING_MINUTES.max,
                 defaultToolWaitMinutes: DEFAULT_TIMING_MINUTES.toolWait,
                 defaultStuckMinutes: DEFAULT_TIMING_MINUTES.stuck,
                 timingError: error instanceof Error ? error.message : String(error),
@@ -2176,7 +2197,7 @@ export default function (pi: ExtensionAPI) {
         capOverride = cap;
         pi.appendEntry("pi-better-subagents-cap", { version: 1, maxConcurrent: cap });
     };
-    const changeTiming = (key: "toolWaitMinutes" | "stuckMinutes", minutes: number): void => {
+    const changeTiming = (key: "maxMinutes" | "toolWaitMinutes" | "stuckMinutes", minutes: number): void => {
         const value = validatedTimingMinutes(minutes, key);
         timingOverride = { ...timingOverride, [key]: value };
         pi.appendEntry("pi-better-subagents-timing", { version: 1, ...timingOverride });
@@ -2192,7 +2213,7 @@ export default function (pi: ExtensionAPI) {
         skillsOverride = undefined;
         pi.appendEntry("pi-better-subagents-cap", { version: 1, maxConcurrent: null });
         pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: null });
-        pi.appendEntry("pi-better-subagents-timing", { version: 1, toolWaitMinutes: null, stuckMinutes: null });
+        pi.appendEntry("pi-better-subagents-timing", { version: 1, maxMinutes: null, toolWaitMinutes: null, stuckMinutes: null });
         pi.appendEntry("pi-better-subagents-skills", { version: 1, mode: null });
     };
     const activeDelegationMode = (): DelegationMode => delegationOverride ?? normalizeDelegationMode(loadConfig().delegationMode);
@@ -2254,7 +2275,12 @@ export default function (pi: ExtensionAPI) {
             const hasSavedSkillChoice = savedSkillValue !== undefined && savedSkillValue !== null;
             // Like skills, only save a timing key this session overrides or the
             // config already carries; built-in defaults need no stored copy.
-            const savedTiming: { toolWaitMinutes?: number; stuckMinutes?: number } = {};
+            const savedTiming: { maxMinutes?: number; toolWaitMinutes?: number; stuckMinutes?: number } = {};
+            if (timingOverride.maxMinutes !== undefined) {
+                savedTiming.maxMinutes = timingOverride.maxMinutes;
+            } else if (isTimingMinutes(cfg.maxMinutes)) {
+                savedTiming.maxMinutes = cfg.maxMinutes;
+            }
             if (timingOverride.toolWaitMinutes !== undefined) {
                 savedTiming.toolWaitMinutes = timingOverride.toolWaitMinutes;
             } else if (isTimingMinutes(cfg.toolWaitMinutes)) {
@@ -2307,6 +2333,16 @@ export default function (pi: ExtensionAPI) {
         const branch = ctx.sessionManager?.getBranch?.();
         if (!Array.isArray(branch)) return;
         for (const entry of branch) {
+            if (entry.type === "custom" && entry.customType === "pi-better-subagents-timeout") {
+                const data = entry.data as { version?: unknown; maxMinutes?: unknown } | null;
+                if (data?.version === 1) {
+                    const next = { ...timingOverride };
+                    if (data.maxMinutes === null) delete next.maxMinutes;
+                    else if (isTimingMinutes(data.maxMinutes)) next.maxMinutes = data.maxMinutes;
+                    timingOverride = next;
+                }
+                continue;
+            }
             if (entry.type === "custom" && entry.customType === "pi-better-subagents-cap") {
                 const data = entry.data as { version?: unknown; maxConcurrent?: unknown } | null;
                 if (data?.version === 1) {
@@ -2329,10 +2365,11 @@ export default function (pi: ExtensionAPI) {
             }
             if (entry.type === "custom" && entry.customType === "pi-better-subagents-timing") {
                 const data = entry.data as {
-                    version?: unknown; toolWaitMinutes?: unknown; stuckMinutes?: unknown;
+                    version?: unknown; maxMinutes?: unknown; toolWaitMinutes?: unknown; stuckMinutes?: unknown;
                 } | null;
                 if (data?.version !== 1) continue;
-                const next: { toolWaitMinutes?: number; stuckMinutes?: number } = {};
+                const next: { maxMinutes?: number; toolWaitMinutes?: number; stuckMinutes?: number } = {};
+                if (isTimingMinutes(data.maxMinutes)) next.maxMinutes = data.maxMinutes;
                 if (isTimingMinutes(data.toolWaitMinutes)) next.toolWaitMinutes = data.toolWaitMinutes;
                 if (isTimingMinutes(data.stuckMinutes)) next.stuckMinutes = data.stuckMinutes;
                 timingOverride = next;
@@ -2538,7 +2575,7 @@ export default function (pi: ExtensionAPI) {
         }
         const cfg = loadConfig();
         // Harness-owned timing (soft deadline, ceiling, tool-wait and stuck windows); validated before any side effect.
-        resolveRunTiming({ params: p, settings: timingSettingsFor(cfg), env: process.env, startedAt: 0 });
+        resolveRunTiming({ params: launchTimingParams(p), settings: timingSettingsFor(cfg), env: process.env, startedAt: 0 });
         let model: string | undefined;
         let thinking: ThinkingLevel | undefined;
         if (resume) {
@@ -2935,7 +2972,7 @@ export default function (pi: ExtensionAPI) {
                     authorityReference: "",
                     // The assignment deadline the attempt was admitted with; a
                     // continuation must not silently extend it.
-                    deadlineAt: resolveRunTiming({ params: p, settings: timingSettingsFor(cfg), env: process.env, startedAt: Date.now() }).deadlineAt ?? null,
+                    deadlineAt: resolveRunTiming({ params: launchTimingParams(p), settings: timingSettingsFor(cfg), env: process.env, startedAt: Date.now() }).deadlineAt ?? null,
                     taskPolicy: taskRuntime?.policy ?? null,
                 });
                 const authorityReference = `worker-policy:${createHash("sha256")
@@ -3074,7 +3111,7 @@ export default function (pi: ExtensionAPI) {
                         tools: bridgePlan.tools,
                     },
                 } : {}),
-                timing: resolveRunTiming({ params: p, settings: timingSettingsFor(cfg), env: process.env, startedAt }),
+                timing: resolveRunTiming({ params: launchTimingParams(p), settings: timingSettingsFor(cfg), env: process.env, startedAt }),
             };
             // This instance holds the exit observer for a run it actually
             // started; only it can finalize on the exit event (#625).
@@ -3316,17 +3353,7 @@ export default function (pi: ExtensionAPI) {
     function continuationTiming(prior: RunMeta): TimingParams {
         const timing = prior.timing;
         if (!timing) return {};
-        const minutes = (at: number | undefined): number | undefined => {
-            if (at === undefined) return undefined;
-            return Math.max(1, at - Date.now()) / 60_000;
-        };
-        return {
-            ...(timing.deadlineAt !== undefined ? { deadline_minutes: minutes(timing.deadlineAt) } : {}),
-            ...(timing.ceilingAt !== undefined ? { max_minutes: minutes(timing.ceilingAt) } : {}),
-            ...(timing.graceMs !== undefined ? { grace_minutes: timing.graceMs / 60_000 } : {}),
-            ...(timing.toolWaitMs !== undefined ? { tool_wait_minutes: timing.toolWaitMs / 60_000 } : {}),
-            ...(timing.stuckMs !== undefined ? { stuck_minutes: timing.stuckMs / 60_000 } : {}),
-        };
+        return continuationTimingParams(timing, Date.now());
     }
 
     /**
@@ -3415,7 +3442,7 @@ export default function (pi: ExtensionAPI) {
             "The tools param is both the tool allowlist AND what determines which extensions load in the child (e.g. tools='read,bash,web_fetch' loads only the web-tools package). Ask for the tools the task needs and nothing more; clean:true gives a built-ins-only child. When the task already names its SKILL.md by path, pass skills with those absolute paths (or [] for none) so the child does not advertise the whole skills catalog. Without an agent or role, pick a model with the model param (e.g. 'xai/grok-4.5@high'); providerless model patterns are resolved by Pi, while provider/model is deterministic and loads mapped provider extensions.",
             ...CATALOG_GUIDELINES,
             "Subagent sandboxing defaults to off. Human settings in /sandbox control file, credential-file, command, and network permissions; sandbox:false cannot override an enabled human profile. Set sandbox:true to request kernel confinement, including without published settings. Set callback:false to finish quietly — then read the result on demand via subagent_result.",
-            "Every launch automatically joins one shared harness-owned watcher, including batch launches; it stops when the last active run ends. Do not start a separate heartbeat or background watcher for subagents. A tool call still open for tool_wait_minutes (default 5) or no progress for stuck_minutes (default 10) sends one factual alert; these alerts never stop, cancel, or restart the run. Elapsed-time limits are opt-in for work with a real wall-clock bound: deadline_minutes steers the child to wrap up and later stops it after grace_minutes, while max_minutes stops it without grace.",
+            "Every launch automatically joins one shared harness-owned watcher, including batch launches; it stops when the last active run ends. Do not start a separate heartbeat or background watcher for subagents. A tool call still open for tool_wait_minutes (default 5) or no progress for stuck_minutes (default 10) sends one factual alert; these alerts never stop, cancel, or restart the run. Hard timeouts default to 60 minutes; max_minutes overrides that default (0 disables). Soft deadlines remain opt-in for work with a real wall-clock bound: deadline_minutes steers the child to wrap up and later stops it after grace_minutes, while max_minutes stops it without grace. Do not set elapsed-time limits merely because a task may take a while; use them only when the work needs a real wall-clock bound.",
             "Use git_clone_workspace:true when the subagent will mutate Git in a sandbox. The parent prepares a disposable, self-contained clone with a real .git/ directory inside the sandbox root, so linked-worktree metadata outside the sandbox cannot stall the child.",
             "Saved conversations persist automatically. To continue a completed or stopped worker in its own history, call subagent_spawn with session_id (the native session id reported for the saved conversation) and the new feedback as prompt. Omit session_id for a brand-new conversation.",
             "On a continuation, pass prompt, session_id, and only optional model, thinking, callback, or timing overrides. Launch-only options (name, agent, role, alias, tools, exclude_tools, skills, clean, sandbox, sandbox_dir, cwd, git_clone_workspace, approve, allow_nested) keep the saved recipe; repeat them only with the same value, otherwise the launch is refused.",
@@ -3914,6 +3941,7 @@ export default function (pi: ExtensionAPI) {
                     const timing = timingState();
                     return {
                         mode: settings.delegationMode, maxConcurrent: settings.maxConcurrent,
+                        maxMinutes: timing.maxMinutes,
                         modeSource: settings.sources.delegationMode,
                         capSource: settings.sources.maxConcurrent,
                         defaultMode: normalizeDelegationMode(loadConfig().delegationMode),
@@ -3940,7 +3968,8 @@ export default function (pi: ExtensionAPI) {
                 : skills.mode === "none" ? "no skills" : `${skills.paths.length} selected skills`;
             const timing = timingState();
             ctx.ui.notify(`Delegation mode: ${activeDelegationMode()}. Concurrent subagents: ${activeConcurrencyCap()}. ` +
-                `Tool-wait alert: ${timing.toolWaitMinutes} min. No-progress alert: ${timing.stuckMinutes} min. Skills: ${skillChoice}. ` +
+                `Timeout: ${timing.maxMinutes} minutes (0 disables). Tool-wait alert: ${timing.toolWaitMinutes} min. ` +
+                `No-progress alert: ${timing.stuckMinutes} min. Skills: ${skillChoice}. ` +
                 `Use /subagents mode <mode>, cap <number>, tool-wait <minutes>, stuck <minutes>, or settings; /subagents save persists them.`, "info");
         }
     };
@@ -3976,7 +4005,8 @@ export default function (pi: ExtensionAPI) {
                     const timing = timingState();
                     if (ctx.hasUI && !(await ctx.ui.confirm("Save subagent defaults?",
                         `Future sessions will start in ${activeDelegationMode()} with a cap of ${activeConcurrencyCap()}, ` +
-                        `tool-wait alert ${timing.toolWaitMinutes} min, no-progress alert ${timing.stuckMinutes} min, and ${skillChoice}.`))) {
+                        `timeout ${timing.maxMinutes} minutes (0 disables), tool-wait alert ${timing.toolWaitMinutes} min, ` +
+                        `no-progress alert ${timing.stuckMinutes} min, and ${skillChoice}.`))) {
                         ctx.ui.notify("Subagent defaults unchanged.", "info");
                         return;
                     }

package/node_modules/pi-better-subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-subagents/settings-page.ts

@@ -6,11 +6,12 @@ import type { SkillExposureMode } from "./skills.ts";
 import { createSkillPicker, type DiscoveredSkill } from "./skill-picker.ts";
 import { validatedTimingMinutes } from "./timing.ts";
 
-export type TimingSettingKey = "toolWaitMinutes" | "stuckMinutes";
+export type TimingSettingKey = "maxMinutes" | "toolWaitMinutes" | "stuckMinutes";
 
 export interface SubagentSettingsSnapshot {
     mode: DelegationMode;
     maxConcurrent: number;
+    maxMinutes: number;
     modeSource: "session" | "config";
     capSource: "session" | "config";
     defaultMode: DelegationMode;
@@ -45,13 +46,14 @@ export interface SubagentSettingsHandlers {
     openAgents?(): void;
 }
 
-type EditTarget = { kind: "cap" } | { kind: "toolWait" } | { kind: "stuck" };
+type EditTarget = { kind: "cap" } | { kind: "toolWait" } | { kind: "stuck" } | { kind: "timeout" };
 
 type Row =
     | { kind: "mode" }
     | { kind: "cap" }
     | { kind: "toolWait" }
     | { kind: "stuck" }
+    | { kind: "timeout" }
     | { kind: "skills" }
     | { kind: "choose" }
     | { kind: "agents" }
@@ -110,7 +112,7 @@ export function createSubagentSettingsPage(
 
     function rowsOf(settings: SubagentSettingsSnapshot): Row[] {
         const rows: Row[] = [
-            { kind: "mode" }, { kind: "cap" }, { kind: "toolWait" }, { kind: "stuck" },
+            { kind: "mode" }, { kind: "cap" }, { kind: "toolWait" }, { kind: "stuck" }, { kind: "timeout" },
             { kind: "skills" }, { kind: "choose" },
         ];
         rows.push({ kind: "agents" }, { kind: "reset" });
@@ -178,6 +180,8 @@ export function createSubagentSettingsPage(
                 startEditing({ kind: "toolWait" }, String(settings.toolWaitMinutes));
             } else if (selected.kind === "stuck") {
                 startEditing({ kind: "stuck" }, String(settings.stuckMinutes));
+            } else if (selected.kind === "timeout") {
+                startEditing({ kind: "timeout" }, String(settings.maxMinutes));
             } else if (selected.kind === "skills") {
                 if (settings.skillsMode === "explicit") rememberedSkillPaths = [...settings.skillsPaths];
                 const next = cycleSkillMode(settings.skillsMode);
@@ -219,11 +223,13 @@ export function createSubagentSettingsPage(
             }
             return;
         }
-        const key = target.kind === "toolWait" ? "toolWaitMinutes" : "stuckMinutes";
+        const key = target.kind === "toolWait" ? "toolWaitMinutes"
+            : target.kind === "stuck" ? "stuckMinutes" : "maxMinutes";
         try {
             const minutes = validatedTimingMinutes(value.trim(), key);
             handlers.changeTiming(key, minutes);
-            finishEditing(`${target.kind === "toolWait" ? "Tool-wait" : "No-progress"} alert updated.`);
+            finishEditing(target.kind === "toolWait" ? "Tool-wait alert updated."
+                : target.kind === "stuck" ? "No-progress alert updated." : "Timeout updated.");
         } catch (cause) {
             report(cause instanceof Error ? cause.message : String(cause), true);
         }
@@ -302,12 +308,15 @@ export function createSubagentSettingsPage(
             rows.forEach((entry, index) => {
                 const selected = index === row;
                 if (selected) selectedStart = lines.length;
-                if (entry.kind === "mode" || entry.kind === "cap" || entry.kind === "toolWait" || entry.kind === "stuck") {
+                if (entry.kind === "mode" || entry.kind === "cap" || entry.kind === "toolWait"
+                    || entry.kind === "stuck" || entry.kind === "timeout") {
                     const label = entry.kind === "mode" ? "Delegation mode"
                         : entry.kind === "cap" ? "Concurrent subagents"
-                        : entry.kind === "toolWait" ? "Tool-wait alert" : "No-progress alert";
+                        : entry.kind === "toolWait" ? "Tool-wait alert"
+                        : entry.kind === "stuck" ? "No-progress alert" : "Timeout (minutes)";
                     const value = entry.kind === "mode" ? settings.mode
                         : entry.kind === "cap" ? String(settings.maxConcurrent)
+                        : entry.kind === "timeout" ? String(settings.maxMinutes)
                         : `${entry.kind === "toolWait" ? settings.toolWaitMinutes : settings.stuckMinutes} min`;
                     const active = editing?.kind === entry.kind
                         ? input.render(compact ? Math.max(1, w - 2) : valueWidth)[0]!

package/node_modules/pi-better-subagents/timing.ts

@@ -58,7 +58,7 @@ export interface OpenCallRecord {
 export const DEFAULT_TIMING_MINUTES = Object.freeze({
     deadline: 0,
     grace: 5,
-    max: 0,
+    max: 60,
     toolWait: 5,
     stuck: 10,
 });
@@ -111,6 +111,18 @@ export interface TimingParams {
     stuck_minutes?: number | null;
 }
 
+/** Carry a parked run's remaining limits, including an explicitly disabled ceiling. */
+export function continuationTimingParams(timing: RunTiming, now: number): TimingParams {
+    const remaining = (at: number): number => Math.max(1, at - now) / 60_000;
+    return {
+        ...(timing.deadlineAt !== undefined ? { deadline_minutes: remaining(timing.deadlineAt) } : {}),
+        max_minutes: timing.ceilingAt === undefined ? 0 : remaining(timing.ceilingAt),
+        grace_minutes: timing.graceMs / 60_000,
+        ...(timing.toolWaitMs !== undefined ? { tool_wait_minutes: timing.toolWaitMs / 60_000 } : {}),
+        ...(timing.stuckMs !== undefined ? { stuck_minutes: timing.stuckMs / 60_000 } : {}),
+    };
+}
+
 export interface TimingSettings {
     deadlineMinutes?: number | null;
     graceMinutes?: number | null;
@@ -148,11 +160,6 @@ export function validatedTimingMinutes(value: unknown, label = "minutes"): numbe
     return parsed;
 }
 
-/**
- * One optional minutes value. `undefined`, `null`, and (for env) an empty
- * string mean "not set". Anything else must be a finite number from 0 to a
- * week; `0` disables.
- */
 function minutes(value: unknown, label: string): number | undefined {
     if (value === undefined || value === null) return undefined;
     if (typeof value === "string") {
@@ -212,7 +219,7 @@ export function resolveRunTiming(input: {
 const TIMING_DESCRIPTIONS = {
     deadline_minutes: "Optional soft deadline in minutes (default: none; 0 = none; null or omitted = inherit: in a batch job the shared value, otherwise the default). At the deadline the child is told to stop starting new work, commit what is done, and report, and you get one wake. Grace starts when the message reaches the child (after its current tool call); if it has not finished by then, the harness stops it with reason deadline.",
     grace_minutes: "Minutes after the wrap-up message reaches the child before the run is stopped (default 5; null or omitted = inherit).",
-    max_minutes: "Optional hard ceiling in minutes (default: none; 0 = none; null or omitted = inherit). The run is stopped at once, without grace, with reason ceiling.",
+    max_minutes: "Optional hard ceiling in minutes (default: 60; 0 = none; null or omitted = inherit). The run is stopped at once, without grace, with reason ceiling.",
     tool_wait_minutes: "Tool-call wait alert in minutes (default 5; 0 = off; null or omitted = inherit). While a tool call stays open this long you get one factual wake for that call, including a normal long test. Parallel calls alert independently. The alert does not stop or cancel the run.",
     stuck_minutes: "No-progress window in minutes (default 10; 0 = off; null or omitted = inherit). Progress is any successful tool call that is not an exact repeat of an earlier one (same tool, same arguments); edits, writes, commits, and a success after a failure always count. Time inside a running tool call does not count. Wakes you once per stuck spell; never stops the run.",
 } as const;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.42.1",
+  "version": "0.43.0",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, model routing, and Outcome & Todo.",
   "license": "MIT",
   "type": "module",
@@ -64,7 +64,7 @@
     "pi-ollama-cloud": "0.13.1",
     "pi-better-sandbox": "0.14.1",
     "pi-better-ssh": "0.1.5",
-    "pi-better-subagents": "0.29.1",
+    "pi-better-subagents": "0.30.0",
     "proper-lockfile": "^4.1.2",
     "shell-quote": "1.12.0",
     "smol-toml": "1.9.0",