@selesai/code 0.6.3 → 0.8.0

package/dist/extensions/pi-subagents/test/unit/scheduled-runs.test.ts

@@ -1,525 +1,488 @@
 import assert from "node:assert/strict";
-import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { after, before, describe, it } from "node:test";
+import { afterEach, describe, it } from "node:test";
+import type { ExtensionContext } from "@selesai/code";
 import {
-	SCHEDULED_RUNS_DIR,
-	ScheduledRunManager,
+	SCHEDULED_RUN_ACTIONS,
 	createScheduledRunManager,
 	isScheduledRunAction,
+	listScheduledRunSummaries,
+	parseScheduleInterval,
 	parseScheduledRunTime,
 	scheduledRunStorePath,
 	scheduledRunsEnabled,
+	type ScheduledRunManager,
 } from "../../src/runs/background/scheduled-runs.ts";
 import type { ExtensionConfig } from "../../src/shared/types.ts";
-import { encodeSubagentCapabilityCeiling, resolveCurrentSubagentCapabilityCeiling } from "../../src/api/capability-ceiling.ts";
-import type { ExtensionContext } from "@selesai/code";
-
-type TimerHandle = number;
 
+type Timer = { callback: () => void; delay: number };
 class FakeTimers {
-	readonly scheduled = new Map<TimerHandle, { cb: () => void; delay: number }>();
-	private nextHandle = 1;
-
-	setTimeout = (cb: () => void, delay: number): TimerHandle => {
-		const handle = this.nextHandle++;
-		this.scheduled.set(handle, { cb, delay });
-		return handle;
+	readonly values = new Map<number, Timer>();
+	private id = 0;
+	setTimeout = (callback: () => void, delay: number) => {
+		const id = ++this.id;
+		this.values.set(id, { callback, delay });
+		return id as unknown as ReturnType<typeof setTimeout>;
 	};
-
-	clearTimeout = (handle: TimerHandle): void => {
-		this.scheduled.delete(handle);
-	};
-
+	clearTimeout = (id: ReturnType<typeof setTimeout>) => void this.values.delete(id as unknown as number);
 	fireAll(): void {
-		// Snapshot first: fire() re-arms by clearing the fired handle and adding a new one.
-		const entries = [...this.scheduled.values()];
-		for (const entry of entries) entry.cb();
-	}
-
-	pendingCount(): number {
-		return this.scheduled.size;
+		const pending = [...this.values.entries()];
+		for (const [id, timer] of pending) {
+			this.values.delete(id);
+			timer.callback();
+		}
 	}
 }
 
-type LaunchRecord = {
+type Launch = {
 	params: Record<string, unknown>;
 	ctx: ExtensionContext;
-	signal: AbortSignal;
-	resolve: (result: { content: Array<{ type: "text"; text: string }>; details: Record<string, unknown>; isError?: boolean }) => void;
-	promise: Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown>; isError?: boolean }>;
+	resolve(result: { content: Array<{ type: "text"; text: string }>; details: Record<string, unknown>; isError?: boolean }): void;
 };
 
-type TestHarness = {
+type Harness = {
 	manager: ScheduledRunManager;
-	timers: FakeTimers;
-	launches: LaunchRecord[];
-	clock: { now: number };
-	storeRoot: string;
 	ctx: ExtensionContext;
+	clock: { now: number };
+	timers: FakeTimers;
+	launches: Launch[];
+	root: string;
 };
 
-function makeCtx(cwd = "/project", sessionFile = "/sessions/abc.jsonl"): ExtensionContext {
+const roots: string[] = [];
+afterEach(() => {
+	for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function context(cwd: string, sessionId = "session-a"): ExtensionContext {
 	return {
 		cwd,
 		sessionManager: {
-			getSessionFile: () => sessionFile,
-			getSessionId: () => path.basename(sessionFile, ".jsonl"),
+			getSessionId: () => sessionId,
+			getSessionFile: () => path.join(cwd, `${sessionId}.jsonl`),
 		},
 	} as unknown as ExtensionContext;
 }
 
-function makeConfig(overrides: Partial<ExtensionConfig["scheduledRuns"]> = {}): ExtensionConfig {
-	return { scheduledRuns: { enabled: true, ...overrides } };
-}
-
-async function flushMicrotasks(times = 10): Promise<void> {
-	for (let i = 0; i < times; i++) await Promise.resolve();
-}
-
-function createHarness(options: { config?: ExtensionConfig; storeRoot?: string; now?: number; resolveCapabilityCeiling?: (sessionId: string) => { version: 1; allowedTools?: string[]; denyExtensions: boolean; sources: string[] } | undefined } = {}): TestHarness {
+function harness(options: { cwd?: string; sessionId?: string; now?: number; config?: ExtensionConfig } = {}): Harness {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-test-"));
+	roots.push(root);
+	const project = options.cwd ?? path.join(root, "project");
+	fs.mkdirSync(project, { recursive: true });
+	const ctx = context(project, options.sessionId);
+	const clock = { now: options.now ?? Date.parse("2030-01-01T00:00:00Z") };
 	const timers = new FakeTimers();
-	const launches: LaunchRecord[] = [];
-	const clock = { now: options.now ?? 1_000_000 };
-	const storeRoot = options.storeRoot ?? fs.mkdtempSync(path.join(os.tmpdir(), "sched-test-"));
+	const launches: Launch[] = [];
+	let id = 0;
 	const manager = createScheduledRunManager({
-		config: options.config ?? makeConfig(),
-		storeRoot,
+		config: options.config ?? { scheduledRuns: { enabled: true } },
+		storeRoot: path.join(root, "stores"),
 		now: () => clock.now,
-		randomId: () => "id-" + randomUUID().slice(0, 4),
+		randomId: () => `id-${++id}`,
 		timers,
-		resolveCapabilityCeiling: options.resolveCapabilityCeiling,
-		launch: (params, ctx, signal) => {
-			let resolve!: LaunchRecord["resolve"];
-			const promise = new Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown>; isError?: boolean }>((res) => {
-				resolve = res;
-			});
-			launches.push({ params: params as unknown as Record<string, unknown>, ctx, signal, resolve, promise });
-			return promise as ReturnType<TestHarness["manager"]["handleToolCall"]>;
-		},
+		launch: (params, launchCtx) => new Promise((resolve) => launches.push({ params: params as Record<string, unknown>, ctx: launchCtx, resolve: resolve as Launch["resolve"] })) as never,
 	});
-	const ctx = makeCtx();
-	return { manager, timers, launches, clock, storeRoot, ctx };
+	manager.bindSession(ctx);
+	return { manager, ctx, clock, timers, launches, root };
 }
 
-function extractId(result: { content: Array<{ type: "text"; text: string }> }): string {
-	const text = result.content[0]!.text;
-	const match = text.match(/Scheduled subagent run (id-[a-z0-9]+)/);
-	assert.ok(match, `expected scheduled run id in: ${text}`);
-	return match[1]!;
+function text(result: Awaited<ReturnType<ScheduledRunManager["handleToolCall"]>>): string {
+	return result.content[0]?.type === "text" ? result.content[0].text : "";
 }
 
-function isError(result: { isError?: boolean }): boolean {
-	return result.isError === true;
+async function flush(): Promise<void> {
+	for (let i = 0; i < 8; i++) await Promise.resolve();
 }
 
-describe("scheduled-runs helpers", () => {
-	it("isScheduledRunAction narrows the four actions", () => {
-		assert.equal(isScheduledRunAction("schedule"), true);
-		assert.equal(isScheduledRunAction("schedule-cancel"), true);
-		assert.equal(isScheduledRunAction("status"), false);
-		assert.equal(isScheduledRunAction(undefined), false);
-	});
-
-	it("scheduledRunsEnabled is true only when explicitly enabled", () => {
-		assert.equal(scheduledRunsEnabled({}), false);
-		assert.equal(scheduledRunsEnabled({ scheduledRuns: {} }), false);
-		assert.equal(scheduledRunsEnabled({ scheduledRuns: { enabled: false } }), false);
-		assert.equal(scheduledRunsEnabled({ scheduledRuns: { enabled: true } }), true);
+describe("schedule helpers", () => {
+	it("recognizes only the dot-action schedule API", () => {
+		assert.deepEqual(SCHEDULED_RUN_ACTIONS, ["schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"]);
+		assert.equal(isScheduledRunAction("schedule.create"), true);
+		assert.equal(isScheduledRunAction("schedule"), false);
 	});
 
-	it("scheduledRunStorePath is stable per cwd+session and distinct otherwise", () => {
-		const root = path.join("tmp", "sched-root");
-		const project = path.join("project");
-		const other = path.join("other");
-		const a = scheduledRunStorePath(project, "sess1", root);
-		const aAgain = scheduledRunStorePath(project, "sess1", root);
-		const b = scheduledRunStorePath(project, "sess2", root);
-		const c = scheduledRunStorePath(other, "sess1", root);
-		assert.equal(a, aAgain);
-		assert.notEqual(a, b);
-		assert.notEqual(a, c);
-		assert.ok(a.startsWith(root));
-		assert.ok(a.endsWith(".json"));
+	it("uses a stable project store independent of session id", () => {
+		const root = path.join("tmp", "schedules");
+		assert.equal(scheduledRunStorePath("project", "a", root), scheduledRunStorePath("project", "b", root));
+		assert.notEqual(scheduledRunStorePath("project", "a", root), scheduledRunStorePath("other", "a", root));
+		assert.equal(scheduledRunStorePath("/project"), path.join(path.resolve("/project"), ".pi-subagents", "schedules"));
 	});
 
-	it("parseScheduledRunTime handles relative delays and ISO timestamps", () => {
-		const base = 1_000_000;
-		assert.equal(parseScheduledRunTime("+10m", base), base + 10 * 60_000);
-		assert.equal(parseScheduledRunTime("+1h", base), base + 3_600_000);
-		assert.equal(parseScheduledRunTime("+2d", base), base + 2 * 86_400_000);
-		assert.equal(parseScheduledRunTime("+30s", base), base + 30_000);
-		assert.equal(parseScheduledRunTime("2030-01-01T00:00:00Z", base), new Date("2030-01-01T00:00:00Z").getTime());
-		assert.equal(parseScheduledRunTime("2030-01-01T09:00:00+05:30", base), new Date("2030-01-01T09:00:00+05:30").getTime());
+	it("parses one-shot and fixed interval forms strictly", () => {
+		const now = Date.parse("2030-01-01T00:00:00Z");
+		assert.equal(parseScheduledRunTime("+10m", now), now + 600_000);
+		assert.equal(parseScheduledRunTime("2030-01-02T00:00:00Z", now), now + 86_400_000);
+		assert.equal(parseScheduledRunTime("2030-01-02T09:00:00+05:30", now), Date.parse("2030-01-02T09:00:00+05:30"));
+		assert.equal(parseScheduleInterval("30m"), 1_800_000);
+		assert.equal(parseScheduleInterval("2w"), 1_209_600_000);
+		assert.throws(() => parseScheduleInterval("day"), /fixed intervals/);
+		assert.throws(() => parseScheduledRunTime("2030-01-01T00:00:00", now), /timezone/);
 	});
 
-	it("parseScheduledRunTime rejects past, zero, malformed, and ambiguous schedules", () => {
-		assert.throws(() => parseScheduledRunTime("+0m", 1_000_000), /positive/);
-		assert.throws(() => parseScheduledRunTime("+9000000000000d", 1_000_000), /too large/);
-		assert.throws(() => parseScheduledRunTime("2020-01-01T00:00:00Z", Date.now() + 60_000), /in the past/);
-		assert.throws(() => parseScheduledRunTime("2030-01-01T00:00:00", 1_000_000), /must include a timezone/);
-		assert.throws(() => parseScheduledRunTime("2030-02-30T00:00:00Z", 1_000_000), /valid future ISO/);
-		assert.throws(() => parseScheduledRunTime("next tuesday", 1_000_000), /Invalid schedule/);
-		assert.throws(() => parseScheduledRunTime("+5w", 1_000_000), /Invalid schedule/);
+	it("honors the explicit feature opt-out", () => {
+		assert.equal(scheduledRunsEnabled({}), true);
+		assert.equal(scheduledRunsEnabled({ scheduledRuns: { enabled: false } }), false);
 	});
 });
 
-describe("ScheduledRunManager create/list/status/cancel", () => {
-	let storeRoots: string[] = [];
-	after(() => {
-		for (const root of storeRoots) {
-			try {
-				fs.rmSync(root, { recursive: true, force: true });
-			} catch {
-				// best-effort cleanup of temp test dirs
-			}
-		}
-	});
-
-	function freshHarness(options: { config?: ExtensionConfig; now?: number } = {}): TestHarness {
-		const harness = createHarness(options);
-		storeRoots.push(harness.storeRoot);
-		return harness;
-	}
-
-	it("rejects schedule actions when the feature is disabled", async () => {
-		const harness = freshHarness({ config: makeConfig({ enabled: false }) });
-		const result = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
-		assert.equal(isError(result), true);
-		assert.match(result.content[0]!.text, /disabled/);
-		assert.equal(harness.timers.pendingCount(), 0);
-	});
-
-	it("rejects capability-ceiling-restricted schedules instead of persisting policy-less jobs", async () => {
-		const harness = createHarness({ resolveCapabilityCeiling: () => ({ version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["plan"] }) });
-		const result = await harness.manager.handleToolCall({ action: "schedule", agent: "worker", task: "review", schedule: "+10m" }, harness.ctx);
-		assert.equal(isError(result), true);
-		assert.match(result.content[0]!.text, /does not yet persist ceilings/);
-		assert.equal(harness.launches.length, 0);
-	});
-
-
-	it("rejects schedules restricted only by inherited process policy", async () => {
-		const previous = process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1;
-		try {
-			process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1 = encodeSubagentCapabilityCeiling({ version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["ancestor"] });
-			const harness = createHarness({ resolveCapabilityCeiling: resolveCurrentSubagentCapabilityCeiling });
-			const result = await harness.manager.handleToolCall({ action: "schedule", agent: "worker", task: "review", schedule: "+10m" }, harness.ctx);
-			assert.equal(isError(result), true);
-			assert.match(result.content[0]!.text, /does not yet persist ceilings/);
-			assert.equal(harness.launches.length, 0);
-		} finally {
-			if (previous === undefined) delete process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1;
-			else process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1 = previous;
-		}
-	});
-
-	it("creates a scheduled job and arms a timer", async () => {
-		const harness = freshHarness();
-		const result = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "review later", schedule: "+10m", scheduleName: "nightly review" }, harness.ctx);
-		assert.equal(isError(result), false);
-		assert.match(result.content[0]!.text, /Scheduled subagent run id-/);
-		assert.match(result.content[0]!.text, /nightly review/);
-		assert.equal(harness.timers.pendingCount(), 1);
-		const list = await harness.manager.handleToolCall({ action: "schedule-list" }, harness.ctx);
-		assert.match(list.content[0]!.text, /nightly review/);
+describe("project schedule management", () => {
+	it("creates a project one-shot schedule and restores it in another session", async () => {
+		const first = harness();
+		const result = await first.manager.handleToolCall({ action: "schedule.create", id: "night-review", name: "Night review", at: "+10m", agent: "commentator", task: "Review the diff" }, first.ctx);
+		assert.equal(result.isError, undefined);
+		assert.match(text(result), /Created schedule night-review/);
+		assert.equal(first.timers.values.size, 1);
+		const records = listScheduledRunSummaries(first.ctx.cwd, path.join(first.root, "stores"));
+		assert.equal(records[0]?.name, "Night review");
+		assert.equal(records[0]?.cwd, first.ctx.cwd);
+
+		first.manager.stop();
+		const secondTimers = new FakeTimers();
+		const second = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(first.root, "stores"),
+			now: () => first.clock.now,
+			timers: secondTimers,
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		second.bindSession(context(first.ctx.cwd, "session-b"));
+		assert.equal(secondTimers.values.size, 1, "a different session restores the project schedule");
+		const shown = await second.handleToolCall({ action: "schedule.show", id: "night-review" }, context(first.ctx.cwd, "session-b"));
+		assert.match(text(shown), /Night review/);
 	});
 
-	it("requires exactly one execution mode", async () => {
-		const harness = freshHarness();
-		// tasks + chain is genuinely ambiguous (both are execution arrays)
-		const chainAndTasks = await harness.manager.handleToolCall({ action: "schedule", tasks: [{ agent: "scout", task: "x" }], chain: [{ agent: "scout", task: "y" }], schedule: "+10m" }, harness.ctx);
-		assert.match(chainAndTasks.content[0]!.text, /exactly one execution mode/);
-		// no execution mode at all
-		const none = await harness.manager.handleToolCall({ action: "schedule", schedule: "+10m" }, harness.ctx);
-		assert.match(none.content[0]!.text, /exactly one execution mode/);
+	it("stores explicit cwd schedules in the target project", async () => {
+		const h = harness();
+		const target = path.join(h.root, "other-project");
+		fs.mkdirSync(target);
+		h.manager.bindSession(context(target, "target-session"));
+		h.manager.bindSession(h.ctx);
+		await h.manager.handleToolCall({ action: "schedule.create", id: "other", cwd: target, every: "1h", agent: "builder" }, h.ctx);
+		assert.equal(listScheduledRunSummaries(h.ctx.cwd, path.join(h.root, "stores")).length, 0);
+		assert.equal(listScheduledRunSummaries(target, path.join(h.root, "stores"))[0]?.cwd, target);
+		const listed = await h.manager.handleToolCall({ action: "schedule.list", cwd: target }, h.ctx);
+		assert.match(text(listed), /other/);
 	});
 
-	it("rejects explicit reviewed acceptance at every scheduled nesting level before persisting a job", async () => {
-		const harness = freshHarness();
-		const cases = [
-			{ agent: "scout", task: "review later", acceptance: "reviewed" },
-			{ agent: "scout", task: "review later", acceptance: { level: "reviewed" } },
-			{ tasks: [{ agent: "scout", task: "review later", acceptance: "reviewed" }] },
-			{ chain: [{ agent: "scout", task: "review later", acceptance: { level: "reviewed" } }] },
-			{ chain: [{ parallel: [{ agent: "scout", task: "review later", acceptance: "reviewed" }] }] },
-		];
-		for (const params of cases) {
-			const result = await harness.manager.handleToolCall({
-				action: "schedule",
-				schedule: "+10m",
-				...params,
-			}, harness.ctx);
-			assert.equal(isError(result), true);
-			assert.match(result.content[0]!.text, /achieved status.*omit acceptance.*acceptance\.review\.required/i);
+	it("supports workflowScript targets and rejects unsafe or deferred shapes", async () => {
+		const h = harness();
+		const workflow = await h.manager.handleToolCall({ action: "schedule.create", id: "workflow", every: "6h", workflowScript: "return await runs.run('review', {agent:'commentator'})" }, h.ctx);
+		assert.equal(workflow.isError, undefined);
+		assert.match(text(workflow), /workflowScript/);
+		for (const params of [
+			{ action: "schedule.create", id: "../escape", every: "1h", agent: "builder" },
+			{ action: "schedule.create", id: "both", at: "+1h", every: "1h", agent: "builder" },
+			{ action: "schedule.create", id: "calendar", every: "day", at: "09:00", timezone: "UTC", agent: "builder" },
+			{ action: "schedule.create", id: "two-targets", every: "1h", agent: "builder", workflowScript: "return 1" },
+			{ action: "schedule.create", id: "fork", every: "1h", agent: "builder", context: "fork" },
+			{ action: "schedule.create", id: "mission-id", every: "1h", agent: "builder", missionId: "mission-1" },
+			{ action: "schedule.create", id: "mission-off", every: "1h", agent: "builder", mission: false },
+		] as const) {
+			const result = await h.manager.handleToolCall(params, h.ctx);
+			assert.equal(result.isError, true, JSON.stringify(params));
 		}
-		assert.equal(harness.timers.pendingCount(), 0);
-	});
-
-	it("requires a schedule and rejects fork/async-false/clarify-true", async () => {
-		const harness = freshHarness();
-		const noSchedule = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x" }, harness.ctx);
-		assert.match(noSchedule.content[0]!.text, /requires schedule/);
-		const fork = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m", context: "fork" }, harness.ctx);
-		assert.match(fork.content[0]!.text, /fresh context/);
-		const sync = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m", async: false }, harness.ctx);
-		assert.match(sync.content[0]!.text, /always async/);
-		const clarify = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m", clarify: true }, harness.ctx);
-		assert.match(clarify.content[0]!.text, /clarify/);
-	});
-
-	it("rejects a past schedule time", async () => {
-		const harness = freshHarness({ now: Date.now() + 60_000 });
-		const result = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "2020-01-01T00:00:00Z" }, harness.ctx);
-		assert.match(result.content[0]!.text, /in the past/);
-	});
-
-	it("enforces maxPending", async () => {
-		const harness = freshHarness({ config: makeConfig({ maxPending: 1 }) });
-		const first = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
-		assert.equal(isError(first), false);
-		const second = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "y", schedule: "+20m" }, harness.ctx);
-		assert.match(second.content[0]!.text, /limit reached/);
 	});
 
-	it("status resolves by exact id and prefix, and rejects ambiguous/missing", async () => {
-		const harness = freshHarness();
-		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
-		const id = extractId(created);
-		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
-		assert.match(status.content[0]!.text, /State: scheduled/);
-		assert.match(status.content[0]!.text, /Cancel: subagent/);
-		const byPrefix = await harness.manager.handleToolCall({ action: "schedule-status", id: id.slice(0, 4) }, harness.ctx);
-		assert.match(byPrefix.content[0]!.text, /State: scheduled/);
-		const missing = await harness.manager.handleToolCall({ action: "schedule-status", id: "nope" }, harness.ctx);
-		assert.match(missing.content[0]!.text, /not found/);
-		const noId = await harness.manager.handleToolCall({ action: "schedule-status" }, harness.ctx);
-		assert.match(noId.content[0]!.text, /requires id/);
+	it("pauses, resumes, lists, and deletes an inactive schedule", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "maintenance", every: "1h", agent: "builder" }, h.ctx);
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.list" }, h.ctx)), /maintenance/);
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.pause", id: "maintenance" }, h.ctx)), /Paused/);
+		assert.equal(h.timers.values.size, 0);
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.resume", id: "maintenance" }, h.ctx)), /Resumed/);
+		assert.equal(h.timers.values.size, 1);
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.delete", id: "maintenance" }, h.ctx)), /Deleted/);
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.list" }, h.ctx)), /No project schedules/);
 	});
 
-	it("cancel clears the timer and marks the job canceled", async () => {
-		const harness = freshHarness();
-		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
-		const id = extractId(created);
-		assert.equal(harness.timers.pendingCount(), 1);
-		const canceled = await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
-		assert.match(canceled.content[0]!.text, /Canceled scheduled subagent run/);
-		assert.equal(harness.timers.pendingCount(), 0);
-		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
-		assert.match(status.content[0]!.text, /State: canceled/);
+	it("reports corrupt project schedule records instead of dropping them", async () => {
+		const h = harness();
+		const root = scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores"));
+		const dir = path.join(root, "broken");
+		fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(path.join(dir, "schedule.json"), "{ bad", "utf-8");
+		const result = await h.manager.handleToolCall({ action: "schedule.list" }, h.ctx);
+		assert.equal(result.isError, true);
+		assert.match(text(result), /Failed to read schedule record/);
 	});
 
-	it("cancel refuses a terminal job", async () => {
-		const harness = freshHarness();
-		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
-		const id = extractId(created);
-		await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
-		const again = await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
-		assert.match(again.content[0]!.text, /already canceled/);
+	it("rejects schedule directories that escape through a symlink", async () => {
+		const h = harness();
+		const root = scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores"));
+		const outside = path.join(h.root, "outside");
+		fs.mkdirSync(root, { recursive: true });
+		fs.mkdirSync(outside);
+		fs.symlinkSync(outside, path.join(root, "escaped"), process.platform === "win32" ? "junction" : "dir");
+		const result = await h.manager.handleToolCall({ action: "schedule.create", id: "escaped", every: "1h", agent: "builder" }, h.ctx);
+		assert.equal(result.isError, true);
+		assert.match(text(result), /must be a real directory/);
+		assert.equal(fs.existsSync(path.join(outside, "schedule.json")), false);
 	});
 
-	it("reports malformed persisted job records instead of dropping them", async () => {
-		const harness = freshHarness();
-		const sessionId = harness.ctx.sessionManager.getSessionFile()!;
-		const storePath = scheduledRunStorePath(harness.ctx.cwd, sessionId, harness.storeRoot);
-		fs.mkdirSync(path.dirname(storePath), { recursive: true });
-		fs.writeFileSync(storePath, JSON.stringify({ version: 1, cwd: harness.ctx.cwd, sessionId, jobs: [{ id: "bad" }] }), "utf-8");
-		const result = await harness.manager.handleToolCall({ action: "schedule-list" }, harness.ctx);
-		assert.equal(isError(result), true);
-		assert.match(result.content[0]!.text, /job 0 has invalid string fields/);
-	});
+	it("rejects a default project schedule root that escapes through .pi-subagents", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-schedule-root-link-"));
+		roots.push(root);
+		const project = path.join(root, "project");
+		const outside = path.join(root, "outside");
+		fs.mkdirSync(project);
+		fs.mkdirSync(outside);
+		const ctx = context(project);
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		manager.bindSession(ctx);
+		fs.symlinkSync(outside, path.join(project, ".pi-subagents"), process.platform === "win32" ? "junction" : "dir");
 
-	it("reports JSON parse errors from a corrupted persisted store", async () => {
-		const harness = freshHarness();
-		const sessionId = harness.ctx.sessionManager.getSessionFile()!;
-		const storePath = scheduledRunStorePath(harness.ctx.cwd, sessionId, harness.storeRoot);
-		fs.mkdirSync(path.dirname(storePath), { recursive: true });
-		fs.writeFileSync(storePath, "{ not-json", "utf-8");
-		const result = await harness.manager.handleToolCall({ action: "schedule-list" }, harness.ctx);
-		assert.equal(isError(result), true);
-		assert.match(result.content[0]!.text, /Failed to parse scheduled subagent store/);
-		assert.match(result.content[0]!.text, /JSON/);
+		const result = await manager.handleToolCall({ action: "schedule.create", id: "escaped-root", every: "1h", agent: "builder" }, ctx);
+		assert.equal(result.isError, true);
+		assert.match(text(result), /resolves outside the real project/);
+		assert.equal(fs.existsSync(path.join(outside, "schedules")), false);
 	});
 });
 
-describe("ScheduledRunManager firing", () => {
-	let storeRoots: string[] = [];
-	after(() => {
-		for (const root of storeRoots) {
-			try {
-				fs.rmSync(root, { recursive: true, force: true });
-			} catch {
-				// best-effort cleanup of temp test dirs
-			}
-		}
+describe("recurring schedule execution", () => {
+	it("launches a fixed interval from its planned time and records durable history/events", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "hourly", every: "1h", agent: "builder", task: "Maintain backlog" }, h.ctx);
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		assert.equal(h.launches.length, 1);
+		assert.deepEqual(h.launches[0]?.params, { agent: "builder", task: "Maintain backlog", async: true, clarify: false, context: "fresh", cwd: h.ctx.cwd, mission: false });
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async builder" }], details: { mode: "single", results: [], asyncId: "async-1", asyncDir: "/tmp/async-1" } });
+		await flush();
+
+		let history = await h.manager.handleToolCall({ action: "schedule.history", id: "hourly" }, h.ctx);
+		assert.match(text(history), /running.*async async-1/);
+		const scheduleRoot = scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores"));
+		const dir = path.join(scheduleRoot, "hourly");
+		assert.equal(fs.existsSync(path.join(dir, "history.json")), true);
+		assert.equal(fs.existsSync(path.join(dir, "events.jsonl")), true);
+		assert.equal(fs.readdirSync(path.join(dir, "runs")).length, 1);
+
+		h.manager.handleAsyncCompletion({ runId: "async-1", success: true, summary: "Done" });
+		history = await h.manager.handleToolCall({ action: "schedule.history", id: "hourly" }, h.ctx);
+		assert.match(text(history), /completed.*async async-1/);
+		assert.equal(fs.existsSync(path.join(dir, "active.lock")), false);
+		const shown = await h.manager.handleToolCall({ action: "schedule.show", id: "hourly" }, h.ctx);
+		assert.match(text(shown), /2030-01-01T02:00:00.000Z/, "next occurrence advances from the planned time without completion drift");
 	});
 
-	function freshHarness(options: { config?: ExtensionConfig; now?: number } = {}): TestHarness {
-		const harness = createHarness(options);
-		storeRoots.push(harness.storeRoot);
-		return harness;
-	}
-
-	it("launches the sanitized async run when the timer fires", async () => {
-		const harness = freshHarness();
-		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "review", schedule: "+10m", scheduleName: "rev" }, harness.ctx);
-		const id = extractId(created);
-		harness.clock.now += 10 * 60_000; // advance to runAt so fire() launches instead of re-arming
-		harness.timers.fireAll();
-		assert.equal(harness.launches.length, 1, "launch should be invoked once when the timer fires");
-		const launch = harness.launches[0]!;
-		assert.equal(launch.params.async, true);
-		assert.equal(launch.params.clarify, false);
-		assert.equal(launch.params.context, "fresh");
-		assert.equal(launch.params.agent, "scout");
-		assert.equal(launch.params.task, "review");
-		assert.equal((launch.params as { action?: string }).action, undefined, "action must be stripped before launch");
-		assert.equal((launch.params as { schedule?: string }).schedule, undefined, "schedule must be stripped before launch");
-
-		launch.resolve({
-			content: [{ type: "text", text: "Async: scout [run-xyz]" }],
-			details: { mode: "single", runId: "run-xyz", asyncId: "run-xyz", asyncDir: "/tmp/async-xyz", results: [] },
-		});
-		await flushMicrotasks();
+	it("run-due launches the latest missed occurrence while catchUp none records a miss", async () => {
+		const latest = harness();
+		await latest.manager.handleToolCall({ action: "schedule.create", id: "latest", every: "1h", catchUp: "latest", agent: "builder" }, latest.ctx);
+		latest.manager.stop();
+		latest.clock.now += 3 * 3_600_000;
+		latest.manager.bindSession(latest.ctx);
+		const duePromise = latest.manager.handleToolCall({ action: "schedule.run-due" }, latest.ctx);
+		await flush();
+		assert.equal(latest.launches.length, 1);
+		latest.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "late-1" } });
+		assert.match(text(await duePromise), /Processed 1 due schedule/);
+		assert.match(text(await latest.manager.handleToolCall({ action: "schedule.history", id: "latest" }, latest.ctx)), /2030-01-01T03:00:00.000Z/, "latest catch-up selects the latest missed slot");
+
+		const none = harness();
+		await none.manager.handleToolCall({ action: "schedule.create", id: "none", every: "1h", catchUp: "none", agent: "builder" }, none.ctx);
+		none.manager.stop();
+		none.clock.now += 3 * 3_600_000;
+		none.manager.bindSession(none.ctx);
+		assert.match(text(await none.manager.handleToolCall({ action: "schedule.history", id: "none" }, none.ctx)), /missed/);
+		assert.equal(none.launches.length, 0);
+	});
 
-		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
-		assert.match(status.content[0]!.text, /State: fired/);
-		assert.match(status.content[0]!.text, /Launched async run: run-xyz/);
-		assert.match(status.content[0]!.text, /Async dir: \/tmp\/async-xyz/);
+	it("keeps project timers, contexts, and completion ownership across session_start bindings", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "project-a", every: "1h", agent: "builder" }, h.ctx);
+
+		const projectB = path.join(h.root, "project-b");
+		fs.mkdirSync(projectB);
+		const projectBCtx = context(projectB, "session-b");
+		const sourceSessionManager = h.ctx.sessionManager as { getSessionId(): string | null; getSessionFile(): string | null };
+		const getSourceSessionId = sourceSessionManager.getSessionId;
+		const getSourceSessionFile = sourceSessionManager.getSessionFile;
+		sourceSessionManager.getSessionId = () => "session-b";
+		sourceSessionManager.getSessionFile = () => path.join(projectB, "session-b.jsonl");
+		h.manager.bindSession(projectBCtx);
+		await h.manager.handleToolCall({ action: "schedule.create", id: "project-b", every: "1h", agent: "builder" }, projectBCtx);
+		assert.equal(h.timers.values.size, 2, "both project timers remain armed after session_start binds project B");
+
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 2);
+		assert.equal(h.launches[0]!.ctx.cwd, h.ctx.cwd);
+		assert.equal(h.launches[0]!.ctx.sessionManager.getSessionId(), "session-a");
+		assert.equal(h.launches[0]!.ctx.sessionManager.getSessionFile(), path.join(h.ctx.cwd, "session-a.jsonl"));
+		assert.equal(h.launches[1]!.ctx.cwd, projectB);
+		assert.equal(h.launches[1]!.ctx.sessionManager.getSessionId(), "session-b");
+		assert.equal(h.launches[1]!.ctx.sessionManager.getSessionFile(), path.join(projectB, "session-b.jsonl"));
+		sourceSessionManager.getSessionId = getSourceSessionId;
+		sourceSessionManager.getSessionFile = getSourceSessionFile;
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "async-a" } });
+		h.launches[1]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "async-b" } });
+		await flush();
+
+		h.manager.handleAsyncCompletion({ runId: "async-a", success: true });
+		const history = await h.manager.handleToolCall({ action: "schedule.history", id: "project-a" }, h.ctx);
+		assert.match(text(history), /completed.*async async-a/);
+		const projectARoot = scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores"));
+		assert.equal(fs.existsSync(path.join(projectARoot, "project-a", "active.lock")), false);
 	});
 
-	it("marks the job failed when launch returns an error result", async () => {
-		const harness = freshHarness();
-		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+1m" }, harness.ctx);
-		const id = extractId(created);
-		harness.clock.now += 60_000; // advance to runAt
-		harness.timers.fireAll();
-		assert.equal(harness.launches.length, 1);
-		harness.launches[0]!.resolve({
-			content: [{ type: "text", text: "Async mode requires jiti" }],
-			details: { mode: "single", results: [] },
-			isError: true,
-		});
-		await flushMicrotasks();
-		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
-		assert.match(status.content[0]!.text, /State: failed/);
-		assert.match(status.content[0]!.text, /Async mode requires jiti/);
+	it("uses only a bound target session for an explicit cross-project cwd", async () => {
+		const h = harness();
+		const target = path.join(h.root, "explicit-target");
+		fs.mkdirSync(target);
+		const unbound = await h.manager.handleToolCall({ action: "schedule.create", id: "targeted", cwd: target, every: "1h", agent: "builder" }, h.ctx);
+		assert.equal(unbound.isError, true);
+		assert.match(text(unbound), /until that project has been opened/);
+
+		const targetCtx = context(target, "target-session");
+		h.manager.bindSession(targetCtx);
+		h.manager.bindSession(h.ctx);
+		await h.manager.handleToolCall({ action: "schedule.create", id: "targeted", cwd: target, every: "1h", agent: "builder" }, h.ctx);
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 1);
+		assert.equal(h.launches[0]!.ctx.cwd, target);
+		assert.equal(h.launches[0]!.ctx.sessionManager.getSessionId(), "target-session");
+		assert.equal(h.launches[0]!.ctx.sessionManager.getSessionFile(), path.join(target, "target-session.jsonl"));
+		assert.equal(h.launches[0]!.params.cwd, target);
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "target-async" } });
+		await flush();
 	});
 
-	it("marks the job failed when launch throws", async () => {
-		const storeRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sched-throw-"));
-		storeRoots.push(storeRoot);
-		const ctx = makeCtx();
+	it("reconciles owner completion after an unrelated store becomes malformed", async () => {
+		const h = harness();
+		const badProject = path.join(h.root, "bad-project");
+		fs.mkdirSync(badProject);
+		const badCtx = context(badProject, "bad-session");
+		const ownerCtx = context(h.ctx.cwd, "owner-session");
 		const timers = new FakeTimers();
-		const clock = { now: 1_000_000 };
-		const throwingManager = createScheduledRunManager({
-			config: makeConfig(),
-			storeRoot,
-			now: () => clock.now,
-			randomId: () => "id-" + randomUUID().slice(0, 4),
+		const launches: Launch[] = [];
+		let id = 0;
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(h.root, "isolated-stores"),
+			now: () => h.clock.now,
+			randomId: () => `isolated-${++id}`,
 			timers,
-			launch: () => Promise.reject(new Error("spawn ENOENT")),
+			launch: (params, launchCtx) => new Promise((resolve) => launches.push({ params: params as Record<string, unknown>, ctx: launchCtx, resolve: resolve as Launch["resolve"] })) as never,
 		});
-		throwingManager.bindSession(ctx);
-		const created = await throwingManager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+1m" }, ctx);
-		const id = extractId(created);
-		clock.now += 60_000; // advance to runAt
-		timers.fireAll();
-		await flushMicrotasks();
-		const status = await throwingManager.handleToolCall({ action: "schedule-status", id }, ctx);
-		assert.match(status.content[0]!.text, /State: failed/);
-		assert.match(status.content[0]!.text, /spawn ENOENT/);
+		manager.bindSession(badCtx);
+		manager.bindSession(ownerCtx);
+		await manager.handleToolCall({ action: "schedule.create", id: "owner", every: "1h", agent: "builder" }, ownerCtx);
+		const manual = manager.handleToolCall({ action: "schedule.run", id: "owner" }, ownerCtx);
+		await flush();
+		launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "owner-async" } });
+		await manual;
+
+		const badDir = path.join(scheduledRunStorePath(badProject, undefined, path.join(h.root, "isolated-stores")), "broken");
+		fs.mkdirSync(badDir, { recursive: true });
+		fs.writeFileSync(path.join(badDir, "schedule.json"), "{ bad", "utf-8");
+		const ownerRoot = scheduledRunStorePath(ownerCtx.cwd, undefined, path.join(h.root, "isolated-stores"));
+		const badSiblingDir = path.join(ownerRoot, "broken-sibling");
+		fs.mkdirSync(badSiblingDir, { recursive: true });
+		fs.writeFileSync(path.join(badSiblingDir, "schedule.json"), "{ bad", "utf-8");
+		const originalError = console.error;
+		console.error = () => {};
+		try {
+			manager.handleAsyncCompletion({ runId: "owner-async", success: true });
+		} finally {
+			console.error = originalError;
+		}
+		const history = await manager.handleToolCall({ action: "schedule.history", id: "owner" }, ownerCtx);
+		assert.match(text(history), /completed.*async owner-async/);
+		assert.equal(fs.existsSync(path.join(ownerRoot, "owner", "active.lock")), false);
 	});
 
-	it("re-arms instead of launching when a capped timer fires before runAt", async () => {
-		const harness = freshHarness({ now: 1_000_000 });
-		// +25d exceeds MAX_TIMER_DELAY_MS so the armed timer is capped and would fire "early" in fake time.
-		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+25d" }, harness.ctx);
-		const id = extractId(created);
-		harness.timers.fireAll();
-		assert.equal(harness.launches.length, 0, "must not launch before runAt");
-		assert.equal(harness.timers.pendingCount(), 1, "must re-arm a new timer");
-		// Advance time to runAt and fire again -> now it launches.
-		harness.clock.now = 1_000_000 + 25 * 86_400_000;
-		harness.timers.fireAll();
-		assert.equal(harness.launches.length, 1, "must launch once runAt is reached");
-		harness.launches[0]!.resolve({
-			content: [{ type: "text", text: "Async: scout [run-1]" }],
-			details: { mode: "single", runId: "run-1", asyncId: "run-1", results: [] },
+	it("reconciles a terminal async status after a new session binds", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "restart", every: "1h", agent: "builder" }, h.ctx);
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		const asyncDir = path.join(h.root, "async-restart");
+		fs.mkdirSync(asyncDir);
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "async-restart", asyncDir } });
+		await flush();
+		h.manager.stop();
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "async-restart", mode: "single", state: "complete", startedAt: h.clock.now, endedAt: h.clock.now }), "utf-8");
+
+		const next = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(h.root, "stores"),
+			now: () => h.clock.now,
+			randomId: () => "reconciled-id",
+			timers: new FakeTimers(),
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
 		});
-		await flushMicrotasks();
-		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
-		assert.match(status.content[0]!.text, /State: fired/);
-	});
-
-	it("cancel before fire prevents the launch", async () => {
-		const harness = freshHarness();
-		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
-		const id = extractId(created);
-		await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
-		harness.timers.fireAll();
-		assert.equal(harness.launches.length, 0, "a canceled job must not launch");
+		const nextCtx = context(h.ctx.cwd, "session-b");
+		next.bindSession(nextCtx);
+		const history = await next.handleToolCall({ action: "schedule.history", id: "restart" }, nextCtx);
+		assert.match(text(history), /completed.*async async-restart/);
 	});
-});
 
-describe("ScheduledRunManager restart restore", () => {
-	let storeRoots: string[] = [];
-	after(() => {
-		for (const root of storeRoots) {
-			try {
-				fs.rmSync(root, { recursive: true, force: true });
-			} catch {
-				// best-effort cleanup of temp test dirs
-			}
-		}
+	it("records elapsed overlap and catch-up-none slots without an immediate rerun", async () => {
+		const latest = harness();
+		await latest.manager.handleToolCall({ action: "schedule.create", id: "overlap", every: "1h", catchUp: "latest", agent: "builder" }, latest.ctx);
+		latest.clock.now += 3_600_000;
+		latest.timers.fireAll();
+		latest.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "long-run" } });
+		await flush();
+		latest.clock.now += 3 * 3_600_000;
+		latest.timers.fireAll();
+		assert.equal(latest.launches.length, 1, "an overlapping occurrence is skipped instead of queued");
+		latest.manager.handleAsyncCompletion({ runId: "long-run", success: true });
+		const latestHistory = await latest.manager.handleToolCall({ action: "schedule.history", id: "overlap" }, latest.ctx);
+		assert.match(text(latestHistory), /skipped/);
+		assert.match(text(latestHistory), /completed.*async long-run/);
+		assert.match(text(await latest.manager.handleToolCall({ action: "schedule.show", id: "overlap" }, latest.ctx)), /2030-01-01T05:00:00.000Z/);
+
+		const none = harness();
+		await none.manager.handleToolCall({ action: "schedule.create", id: "none-overlap", every: "1h", catchUp: "none", agent: "builder" }, none.ctx);
+		none.clock.now += 3_600_000;
+		none.timers.fireAll();
+		none.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "none-long-run" } });
+		await flush();
+		none.clock.now += 3 * 3_600_000;
+		none.timers.fireAll();
+		assert.equal(none.launches.length, 1);
+		none.manager.handleAsyncCompletion({ runId: "none-long-run", success: true });
+		assert.match(text(await none.manager.handleToolCall({ action: "schedule.history", id: "none-overlap" }, none.ctx)), /skipped/);
+		assert.match(text(await none.manager.handleToolCall({ action: "schedule.show", id: "none-overlap" }, none.ctx)), /2030-01-01T05:00:00.000Z/);
 	});
 
-	it("re-arms pending jobs and marks stale jobs missed after a restart", async () => {
-		const storeRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sched-restore-"));
-		storeRoots.push(storeRoot);
-		const ctx = makeCtx();
-		const clock = { now: 1_000_000 };
-		const timersA = new FakeTimers();
-		const managerA = createScheduledRunManager({
-			config: makeConfig({ maxLatenessMs: 60_000 }),
-			storeRoot,
-			now: () => clock.now,
-			randomId: () => "id-" + randomUUID().slice(0, 4),
-			timers: timersA,
-			launch: () => Promise.resolve({ content: [{ type: "text", text: "ok" }], details: { mode: "single", results: [] } }),
-		});
-		managerA.bindSession(ctx);
-		const soon = await managerA.handleToolCall({ action: "schedule", agent: "scout", task: "soon", schedule: "+10m" }, ctx);
-		const later = await managerA.handleToolCall({ action: "schedule", agent: "scout", task: "later", schedule: "+1h" }, ctx);
-		const soonId = extractId(soon);
-		const laterId = extractId(later);
-		assert.equal(timersA.pendingCount(), 2);
-		managerA.stop();
-
-		// Simulate Pi being offline past the first job's window but before the second fires.
-		clock.now = 1_000_000 + 20 * 60_000; // +20m: soon is 10m overdue (> maxLateness 1m), later is still 40m out.
-		const timersB = new FakeTimers();
-		const managerB = createScheduledRunManager({
-			config: makeConfig({ maxLatenessMs: 60_000 }),
-			storeRoot,
-			now: () => clock.now,
-			randomId: () => "id-" + randomUUID().slice(0, 4),
-			timers: timersB,
-			launch: () => Promise.resolve({ content: [{ type: "text", text: "ok" }], details: { mode: "single", results: [] } }),
-		});
-		managerB.bindSession(ctx);
-		const soonStatus = await managerB.handleToolCall({ action: "schedule-status", id: soonId }, ctx);
-		assert.match(soonStatus.content[0]!.text, /State: missed/);
-		const laterStatus = await managerB.handleToolCall({ action: "schedule-status", id: laterId }, ctx);
-		assert.match(laterStatus.content[0]!.text, /State: scheduled/);
-		assert.equal(timersB.pendingCount(), 1, "only the still-future job should be re-armed");
-		managerB.stop();
+	it("manual run uses the normal async target and overlap skip prevents a second launch", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "manual", every: "1h", workflowScript: "return 1" }, h.ctx);
+		const firstPromise = h.manager.handleToolCall({ action: "schedule.run", id: "manual" }, h.ctx);
+		await flush();
+		assert.equal(h.launches.length, 1);
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "workflow", results: [], asyncId: "workflow-1" } });
+		assert.match(text(await firstPromise), /async workflow-1/);
+		const second = await h.manager.handleToolCall({ action: "schedule.run", id: "manual" }, h.ctx);
+		assert.match(text(second), /skipped/);
+		assert.equal(h.launches.length, 1);
 	});
 
-	it("store path lives under the scheduled runs dir by default", () => {
-		const p = scheduledRunStorePath("/project", "sess1");
-		assert.ok(p.startsWith(SCHEDULED_RUNS_DIR), `${p} should be under ${SCHEDULED_RUNS_DIR}`);
+	it("distinguishes failed launch from failed async completion", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "failures", every: "1h", agent: "builder" }, h.ctx);
+		const first = h.manager.handleToolCall({ action: "schedule.run", id: "failures" }, h.ctx);
+		await flush();
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "spawn failed" }], details: { mode: "management", results: [] }, isError: true });
+		assert.match(text(await first), /failed_launch/);
+
+		const second = h.manager.handleToolCall({ action: "schedule.run", id: "failures" }, h.ctx);
+		await flush();
+		h.launches[1]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "async-fail" } });
+		await second;
+		h.manager.handleAsyncCompletion({ id: "async-fail", success: false, summary: "child failed" });
+		const history = await h.manager.handleToolCall({ action: "schedule.history", id: "failures" }, h.ctx);
+		assert.match(text(history), /failed_run.*async async-fail/);
+		assert.match(text(history), /failed_launch/);
 	});
 });