@selesai/code 0.13.40 → 0.14.3

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

@@ -17,6 +17,7 @@ import {
 	type ScheduledRunManager,
 } from "../../src/runs/background/scheduled-runs.ts";
 import type { ExtensionConfig } from "../../src/shared/types.ts";
+import { createMission, readMission, resolveMissionStoreLocation } from "../../src/missions/store.ts";
 
 type Timer = { callback: () => void; delay: number };
 class FakeTimers {
@@ -105,6 +106,150 @@ async function flush(): Promise<void> {
 	for (let i = 0; i < 8; i++) await Promise.resolve();
 }
 
+describe("calendar schedule execution", () => {
+	const script = "return runs.run('main', { agent: 'reviewer' })";
+	async function daily(h: Harness, extra: Record<string, unknown> = {}) {
+		const result = await h.manager.handleToolCall({ action: "schedule.create", id: "calendar", every: "day", at: "09:00", timezone: "Asia/Taipei", workflowScript: script, ...extra }, h.ctx);
+		assert.equal(result.isError, undefined, text(result));
+		return result;
+	}
+	async function trigger(h: Harness) {
+		return detailRecords(await h.manager.handleToolCall({ action: "schedule.show", id: "calendar" }, h.ctx))[0]!.trigger as Record<string, unknown>;
+	}
+	it("persists daily and weekly rules, displays the zone, and rearms an early timer", async () => {
+		const h = harness();
+		await daily(h, { every: "week", on: ["fri", "tue", "fri"], quiet: true });
+		assert.deepEqual((await trigger(h)).on, ["tue", "fri"]);
+		assert.equal((await trigger(h)).nextLocalDate, "2030-01-01");
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.show", id: "calendar" }, h.ctx)), /every week.*09:00 Asia\/Taipei/);
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 0);
+		assert.equal(h.timers.values.size, 1);
+		h.clock.now = Date.parse("2030-01-01T01:00:00Z");
+		h.timers.fireAll();
+		await flush();
+		assert.equal((h.launches[0]!.params.scheduleOrigin as Record<string, unknown>).quiet, true);
+		h.launches[0]!.resolve({ content: [], details: { asyncId: "calendar-run" } });
+		await flush();
+		assert.equal((await trigger(h)).nextLocalDate, "2030-01-04");
+	});
+	it("runs only the latest missed date after a long pause", async () => {
+		const h = harness();
+		await daily(h);
+		await h.manager.handleToolCall({ action: "schedule.pause", id: "calendar" }, h.ctx);
+		h.clock.now = Date.parse("2035-01-01T02:00:00Z");
+		await h.manager.handleToolCall({ action: "schedule.resume", id: "calendar" }, h.ctx);
+		const due = h.manager.handleToolCall({ action: "schedule.run-due" }, h.ctx);
+		await flush();
+		h.launches[0]!.resolve({ content: [], details: { asyncId: "latest" } });
+		const result = await due;
+		assert.equal(result.details?.schedules?.runs?.[0]?.plannedAt, "2035-01-01T01:00:00.000Z");
+		assert.equal(h.launches.length, 1);
+		assert.equal((await trigger(h)).nextLocalDate, "2035-01-02");
+	});
+	it("records one missed receipt for catchUp:none and advances past downtime", async () => {
+		const h = harness();
+		await daily(h, { catchUp: "none" });
+		await h.manager.handleToolCall({ action: "schedule.pause", id: "calendar" }, h.ctx);
+		h.clock.now = Date.parse("2035-01-01T02:00:00Z");
+		await h.manager.handleToolCall({ action: "schedule.resume", id: "calendar" }, h.ctx);
+		const history = await h.manager.handleToolCall({ action: "schedule.history", id: "calendar" }, h.ctx);
+		assert.equal(history.details?.schedules?.runs?.length, 1);
+		assert.equal(history.details?.schedules?.runs?.[0]?.state, "missed");
+		assert.equal(h.launches.length, 0);
+		assert.equal((await trigger(h)).nextLocalDate, "2035-01-02");
+	});
+	it("successful manual attachment satisfies the pending future date", async () => {
+		const h = harness();
+		await daily(h);
+		const manual = h.manager.handleToolCall({ action: "schedule.run", id: "calendar" }, h.ctx);
+		await flush();
+		h.launches[0]!.resolve({ content: [], details: { asyncId: "manual" } });
+		await manual;
+		assert.equal((await trigger(h)).nextLocalDate, "2030-01-02");
+		assert.equal((await trigger(h)).nextRunAt, "2030-01-02T01:00:00.000Z");
+	});
+	it("failed manual attachment preserves both pending fields", async () => {
+		const h = harness();
+		await daily(h);
+		const before = await trigger(h);
+		const manual = h.manager.handleToolCall({ action: "schedule.run", id: "calendar" }, h.ctx);
+		await flush();
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "launch rejected" }], details: {}, isError: true });
+		assert.equal((await manual).isError, true);
+		assert.deepEqual(await trigger(h), before);
+	});
+	for (const paused of [false, true]) it(`restores an overlapped calendar fire after failed manual attachment, paused: ${paused}`, async () => {
+		const h = harness();
+		await daily(h);
+		const before = await trigger(h);
+		const manual = h.manager.handleToolCall({ action: "schedule.run", id: "calendar" }, h.ctx);
+		await flush();
+		h.clock.now = Date.parse("2030-01-01T01:00:00Z");
+		h.timers.fireAll();
+		await flush();
+		assert.equal((await trigger(h)).nextLocalDate, "2030-01-02");
+		if (paused) await h.manager.handleToolCall({ action: "schedule.pause", id: "calendar" }, h.ctx);
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "launch rejected" }], details: {}, isError: true });
+		assert.equal((await manual).isError, true);
+		assert.deepEqual(await trigger(h), before);
+		assert.equal(detailRecords(await h.manager.handleToolCall({ action: "schedule.show", id: "calendar" }, h.ctx))[0]!.paused, paused);
+		assert.equal(h.launches.length, 1);
+		if (paused) assert.equal(h.timers.values.size, 0);
+		else {
+			h.timers.fireAll();
+			await flush();
+			assert.equal(h.launches.length, 2);
+			h.launches[1]!.resolve({ content: [], details: { asyncId: "natural-retry" } });
+			await flush();
+			assert.equal((await trigger(h)).nextLocalDate, "2030-01-02");
+			assert.equal((await trigger(h)).nextRunAt, "2030-01-02T01:00:00.000Z");
+		}
+	});
+	it("does not consume an extra date when a natural fire overlaps manual attachment", async () => {
+		const h = harness();
+		await daily(h);
+		const manual = h.manager.handleToolCall({ action: "schedule.run", id: "calendar" }, h.ctx);
+		await flush();
+		h.clock.now = Date.parse("2030-01-01T01:00:00Z");
+		h.timers.fireAll();
+		await flush();
+		h.launches[0]!.resolve({ content: [], details: { asyncId: "manual-overlap" } });
+		await manual;
+		assert.equal((await trigger(h)).nextLocalDate, "2030-01-02");
+		assert.equal(h.launches.length, 1);
+	});
+	it("re-resolves the pending date on restoration without list rewriting the cache", async () => {
+		const h = harness();
+		await daily(h);
+		const file = path.join(scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores")), "calendar", "schedule.json");
+		const saved = JSON.parse(fs.readFileSync(file, "utf-8"));
+		saved.trigger.nextRunAt = "2030-01-01T03:00:00.000Z";
+		fs.writeFileSync(file, JSON.stringify(saved));
+		await h.manager.handleToolCall({ action: "schedule.list" }, h.ctx);
+		assert.equal(JSON.parse(fs.readFileSync(file, "utf-8")).trigger.nextRunAt, saved.trigger.nextRunAt);
+		h.manager.stop();
+		h.manager.bindSession(h.ctx);
+		assert.equal(JSON.parse(fs.readFileSync(file, "utf-8")).trigger.nextRunAt, "2030-01-01T01:00:00.000Z");
+	});
+	it("does not fire twice during a repeated hour, including restoration", async () => {
+		const h = harness({ now: Date.parse("2026-11-01T04:00:00Z") });
+		await daily(h, { at: "01:30", timezone: "America/New_York" });
+		h.clock.now = Date.parse("2026-11-01T05:30:00Z");
+		h.timers.fireAll();
+		await flush();
+		h.launches[0]!.resolve({ content: [], details: { asyncId: "fold" } });
+		await flush();
+		h.manager.handleAsyncCompletion({ id: "fold", success: true });
+		h.clock.now = Date.parse("2026-11-01T06:45:00Z");
+		h.manager.bindSession(h.ctx);
+		await h.manager.handleToolCall({ action: "schedule.run-due" }, h.ctx);
+		assert.equal(h.launches.length, 1);
+		assert.equal((await trigger(h)).nextRunAt, "2026-11-02T06:30:00.000Z");
+	});
+});
+
 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"]);
@@ -290,11 +435,11 @@ describe("project schedule management", () => {
 		assert.doesNotThrow(() => manager.bindSession(context(project)));
 	});
 
-	it("rejects direct schedule targets and requires workflowScript", async () => {
+	it("rejects direct schedule targets and requires a workflow script", async () => {
 		const h = harness();
 		const result = await h.manager.handleToolCall({ action: "schedule.create", id: "direct", every: "1h", agent: "worker", task: "Review" }, h.ctx);
 		assert.equal(result.isError, true);
-		assert.match(text(result), /requires workflowScript/);
+		assert.match(text(result), /requires workflow: true or a workflow script path/);
 	});
 
 	it("fails closed on persisted legacy agent targets", () => {
@@ -324,27 +469,28 @@ describe("project schedule management", () => {
 			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
 		});
 
-		assert.throws(() => manager.bindSession(context(h.ctx.cwd, "session-b")), /removed legacy agent target.*target\.workflowScript/i);
+		assert.throws(() => manager.bindSession(context(h.ctx.cwd, "session-b")), /removed legacy agent target.*schedule\.create and workflow: true or a workflow script path/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:'reviewer'})" }, h.ctx);
 		assert.equal(workflow.isError, undefined);
-		assert.match(text(workflow), /workflowScript -> agent reviewer/);
+		assert.match(text(workflow), /workflow -> agent reviewer/);
 		const dynamic = await h.manager.handleToolCall({ action: "schedule.create", id: "dynamic", every: "6h", workflowScript: "const agent = 'worker'; return runs.run('main', { agent })" }, h.ctx);
 		assert.equal(dynamic.isError, undefined);
-		assert.match(text(dynamic), /workflowScript \(dynamic\)/);
+		assert.match(text(dynamic), /workflow \(dynamic\)/);
 		for (const params of [
 			{ action: "schedule.create", id: "../escape", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" },
 			{ action: "schedule.create", id: "both", at: "+1h", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" },
-			{ action: "schedule.create", id: "calendar", every: "day", at: "09:00", timezone: "UTC", workflowScript: "return runs.run('main', { agent: 'worker' })" },
+			{ action: "schedule.create", id: "calendar", every: "day", at: "09:00", workflowScript: "return runs.run('main', { agent: 'worker' })" },
 			{ action: "schedule.create", id: "two-targets", every: "1h", agent: "worker", workflowScript: "return 1" },
 			{ action: "schedule.create", id: "fork", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", context: "fork" },
 			{ action: "schedule.create", id: "invalid-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "unsafe..ref" },
 			{ action: "schedule.create", id: "revision-alias-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "@" },
 			{ action: "schedule.create", id: "object-id-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "a".repeat(40) },
 			{ action: "schedule.create", id: "sha256-object-id-base-ref", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", baseRef: "a".repeat(64) },
+			{ action: "schedule.create", id: "invalid-args", every: "1h", workflowScript: "return 1", args: { task: "" } },
 			{ action: "schedule.create", id: "mission-id", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", missionId: "mission-1" },
 			{ action: "schedule.create", id: "mission-off", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })", mission: false },
 		] as const) {
@@ -353,26 +499,141 @@ describe("project schedule management", () => {
 		}
 	});
 
-	it("persists and forwards a scheduled workflow baseRef", async () => {
+	it("persists and forwards scheduled workflow arguments and baseRef", async () => {
 		const h = harness();
+		const args = { task: "review", nested: { retries: 2 } };
 		const created = await h.manager.handleToolCall({
 			action: "schedule.create",
 			id: "base-ref",
 			every: "1h",
 			baseRef: "@/foo",
+			args,
 			workflowScript: "return runs.run('main', { agent: 'worker' })",
 		}, h.ctx);
 		assert.equal(created.isError, undefined);
+		assert.doesNotMatch(text(created), /review|retries/);
 		assert.equal(listScheduledRunSummaries(h.ctx.cwd, path.join(h.root, "stores"))[0]?.target.baseRef, "@/foo");
+		assert.deepEqual(listScheduledRunSummaries(h.ctx.cwd, path.join(h.root, "stores"))[0]?.target.args, args);
+		args.nested.retries = 99;
 
-		const running = h.manager.handleToolCall({ action: "schedule.run", id: "base-ref" }, h.ctx);
+		h.manager.stop();
+		const restoredLaunches: Launch[] = [];
+		const restored = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(h.root, "stores"),
+			now: () => h.clock.now,
+			timers: new FakeTimers(),
+			launch: (params, launchCtx) => new Promise((resolve) => restoredLaunches.push({ params: params as Record<string, unknown>, ctx: launchCtx, resolve: resolve as Launch["resolve"] })) as never,
+		});
+		restored.bindSession(h.ctx);
+		const running = restored.handleToolCall({ action: "schedule.run", id: "base-ref" }, h.ctx);
 		await flush();
-		assert.equal(h.launches[0]?.params.baseRef, "@/foo");
-		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "workflow", results: [], asyncId: "base-ref-async" } });
+		assert.equal(restoredLaunches[0]?.params.baseRef, "@/foo");
+		assert.deepEqual(restoredLaunches[0]?.params.args, { task: "review", nested: { retries: 2 } });
+		restoredLaunches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "workflow", results: [], asyncId: "base-ref-async" } });
 		const result = await running;
 		assert.equal(result.isError, undefined);
 	});
 
+	it("attaches an existing mission without activating it and forwards it on manual and due fires", async () => {
+		const config: ExtensionConfig = { missions: { directory: ".missions", globalIndex: false, enabled: false } };
+		const h = harness({ config });
+		const location = resolveMissionStoreLocation({ projectRoot: h.ctx.cwd, config: config.missions });
+		const mission = createMission(location, { title: "Backlog", objective: "Track progress" });
+		const created = await h.manager.handleToolCall({ action: "schedule.create", id: "mission", every: "1h", workflowScript: "return 1", missionId: mission.id }, h.ctx);
+		assert.equal(created.isError, undefined);
+		assert.deepEqual(readMission(location, mission.id), mission, "scheduling must not activate the mission");
+		assert.equal((detailRecords(created)[0]?.target as { missionId?: string }).missionId, mission.id);
+		assert.equal(detailRecords(created)[0]?.schemaVersion, 2, "old readers must reject a mission-bound definition");
+		assert.match(text(created), new RegExp(`Mission: ${mission.id}`));
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.show", id: "mission" }, h.ctx)), new RegExp(`Mission: ${mission.id}`));
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.list" }, h.ctx)), new RegExp(`mission ${mission.id}`));
+		for (const [index, action] of ["schedule.run", "schedule.run-due"].entries()) {
+			if (index) h.clock.now += 3_600_000;
+			const pending = h.manager.handleToolCall({ action, id: "mission" }, h.ctx);
+			await flush();
+			const launch = h.launches[index]!;
+			assert.equal(launch.params.missionId, mission.id);
+			assert.equal(Object.hasOwn(launch.params, "mission"), false, "mission:false conflicts with an explicit ID");
+			const asyncId = `mission-${index}`;
+			launch.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "workflow", results: [], asyncId } });
+			assert.equal((await pending).isError, undefined);
+			h.manager.handleAsyncCompletion({ id: asyncId, success: true });
+		}
+	});
+
+	it("rejects missing or invalid mission attachment without persisting a schedule", async () => {
+		const h = harness({ config: { missions: { directory: ".missions", globalIndex: false } } });
+		for (const missionId of ["missing", "../escape", "", null]) {
+			const result = await h.manager.handleToolCall({ action: "schedule.create", id: "rejected", every: "1h", workflowScript: "return 1", missionId } as never, h.ctx);
+			assert.equal(result.isError, true);
+			assert.match(text(result), /missionId|was not found/);
+		}
+		assert.deepEqual(listScheduledRunSummaries(h.ctx.cwd, path.join(h.root, "stores")), []);
+		assert.equal(h.launches.length, 0);
+	});
+
+	it("resolves mission attachment from the target cwd and configured store", async () => {
+		const h = harness({ config: { missions: { directory: ".missions", globalIndex: false } } });
+		const targetCwd = path.join(h.root, "target-project");
+		fs.mkdirSync(targetCwd);
+		const location = resolveMissionStoreLocation({ projectRoot: targetCwd, config: { directory: ".missions", globalIndex: false } });
+		const mission = createMission(location, { title: "Target project", objective: "Keep project state" });
+		const request = { action: "schedule.create", id: "target-mission", every: "1h", workflowScript: "return 1", missionId: mission.id };
+		const wrongStore = await h.manager.handleToolCall(request, h.ctx);
+		assert.equal(wrongStore.isError, true);
+		h.manager.bindSession(context(targetCwd, "target-session"));
+		h.manager.bindSession(h.ctx);
+		const created = await h.manager.handleToolCall({ ...request, cwd: targetCwd }, h.ctx);
+		assert.equal(created.isError, undefined, text(created));
+		assert.equal(detailRecords(created)[0]?.cwd, targetCwd);
+		assert.deepEqual(readMission(location, mission.id), mission);
+
+		const shared = harness({ config: { missions: { directory: location.missionDir, globalIndex: false } } });
+		const sharedResult = await shared.manager.handleToolCall(request, shared.ctx);
+		assert.equal(sharedResult.isError, undefined, "an explicit shared store retains ordinary mission lookup semantics");
+		assert.deepEqual(readMission(location, mission.id), mission);
+	});
+
+	it("rejects a malformed persisted mission ID instead of dropping the attachment", async () => {
+		const config: ExtensionConfig = { missions: { directory: ".missions", globalIndex: false } };
+		const h = harness({ config });
+		const location = resolveMissionStoreLocation({ projectRoot: h.ctx.cwd, config: config.missions });
+		const mission = createMission(location, { title: "Backlog", objective: "Track progress" });
+		await h.manager.handleToolCall({ action: "schedule.create", id: "tampered-mission", every: "1h", workflowScript: "return 1", missionId: mission.id }, h.ctx);
+		h.manager.stop();
+		const file = path.join(scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores")), "tampered-mission", "schedule.json");
+		const record = JSON.parse(fs.readFileSync(file, "utf-8"));
+		record.target.missionId = null;
+		fs.writeFileSync(file, JSON.stringify(record));
+		assert.throws(() => h.manager.bindSession(h.ctx), /invalid missionId/);
+		assert.equal(h.timers.values.size, 0);
+		assert.equal(h.launches.length, 0);
+	});
+
+	it("keeps unbound definitions readable and rejects inconsistent attachment versions", async () => {
+		const config: ExtensionConfig = { missions: { directory: ".missions", globalIndex: false } };
+		const h = harness({ config });
+		const plain = await h.manager.handleToolCall({ action: "schedule.create", id: "plain", every: "1h", workflowScript: "return 1" }, h.ctx);
+		assert.equal(detailRecords(plain)[0]?.schemaVersion, 1);
+		const location = resolveMissionStoreLocation({ projectRoot: h.ctx.cwd, config: config.missions });
+		const mission = createMission(location, { title: "Backlog", objective: "Track progress" });
+		await h.manager.handleToolCall({ action: "schedule.create", id: "bound", every: "1h", workflowScript: "return 1", missionId: mission.id }, h.ctx);
+		h.manager.stop();
+		const file = path.join(scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores")), "bound", "schedule.json");
+		const record = JSON.parse(fs.readFileSync(file, "utf-8"));
+		for (const malformed of [
+			{ ...record, schemaVersion: 1 },
+			{ ...record, target: { workflowScript: record.target.workflowScript, args: record.target.args } },
+		]) {
+			fs.writeFileSync(file, JSON.stringify(malformed));
+			const rejected = await h.manager.handleToolCall({ action: "schedule.run", id: "bound" }, h.ctx);
+			assert.equal(rejected.isError, true);
+			assert.match(text(rejected), /requires schemaVersion 2/);
+		}
+		assert.equal(h.launches.length, 0);
+	});
+
 	it("pauses, resumes, lists, and deletes an inactive schedule", async () => {
 		const h = harness();
 		await h.manager.handleToolCall({ action: "schedule.create", id: "maintenance", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
@@ -385,6 +646,41 @@ describe("project schedule management", () => {
 		assert.match(text(await h.manager.handleToolCall({ action: "schedule.list" }, h.ctx)), /No project schedules/);
 	});
 
+	it("deletes a foreign session-only schedule only after its exact async run is terminal", async () => {
+		const owner = harness({ sessionId: "owner-session" });
+		await owner.manager.handleToolCall({ action: "schedule.create", id: "owner-only", every: "1h", sessionOnly: true, workflowScript: "return runs.run('main', { agent: 'worker' })" }, owner.ctx);
+		const running = owner.manager.handleToolCall({ action: "schedule.run", id: "owner-only" }, owner.ctx);
+		await flush();
+		const asyncDir = path.join(owner.root, "async-owner-only");
+		fs.mkdirSync(asyncDir);
+		owner.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "async-owner-only", asyncDir } });
+		await running;
+		owner.manager.stop();
+
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "async-owner-only", mode: "single", state: "running", startedAt: owner.clock.now }), "utf-8");
+		const other = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(owner.root, "stores"),
+			now: () => owner.clock.now,
+			timers: new FakeTimers(),
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		const otherCtx = context(owner.ctx.cwd, "other-session");
+		other.bindSession(otherCtx);
+		const refused = await other.handleToolCall({ action: "schedule.delete", id: "owner-only" }, otherCtx);
+		assert.equal(refused.isError, true);
+		assert.match(text(refused), /has active run/);
+
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "async-owner-only", mode: "single", state: ["failed"], startedAt: owner.clock.now, endedAt: owner.clock.now }), "utf-8");
+		const malformed = await other.handleToolCall({ action: "schedule.delete", id: "owner-only" }, otherCtx);
+		assert.equal(malformed.isError, true);
+		assert.match(text(malformed), /has active run/);
+
+		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: "async-owner-only", mode: "single", state: "failed", startedAt: owner.clock.now, endedAt: owner.clock.now }), "utf-8");
+		assert.match(text(await other.handleToolCall({ action: "schedule.delete", id: "owner-only" }, otherCtx)), /Deleted/);
+		assert.match(text(await other.handleToolCall({ action: "schedule.list" }, otherCtx)), /No project schedules/);
+	});
+
 	it("ignores schedules deleted by another session while a timer is still armed", async () => {
 		const first = harness();
 		await first.manager.handleToolCall({ action: "schedule.create", id: "stale", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, first.ctx);
@@ -431,6 +727,23 @@ describe("project schedule management", () => {
 		assert.match(text(result), /Failed to read schedule record/);
 	});
 
+	it("fails closed when persisted schedule arguments are invalid", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "tampered-args", every: "1h", workflowScript: "return 1", args: { task: "valid" } }, h.ctx);
+		h.manager.stop();
+		const schedulePath = path.join(scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores")), "tampered-args", "schedule.json");
+		const record = JSON.parse(fs.readFileSync(schedulePath, "utf-8")) as { target: { args: unknown } };
+		record.target.args = { task: "" };
+		fs.writeFileSync(schedulePath, JSON.stringify(record));
+
+		const restored = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(h.root, "stores"),
+			launch: async () => ({ content: [{ type: "text", text: "unused" }], details: { mode: "management", results: [] } }),
+		});
+		assert.throws(() => restored.bindSession(h.ctx), /workflow args\.task must not be empty/);
+	});
+
 	it("skips orphan schedule directories during restore and listing", async () => {
 		const h = harness();
 		h.manager.stop();
@@ -606,6 +919,61 @@ describe("project schedule management", () => {
 	});
 });
 
+describe("quiet schedules", () => {
+	const script = "return runs.run('main', { agent: 'worker', task: 'Maintain backlog' })";
+
+	it("persists quiet only on recurring create and applies it to automatic fires", async () => {
+		const h = harness();
+		const created = await h.manager.handleToolCall({ action: "schedule.create", id: "quiet-hourly", every: "1h", quiet: true, workflowScript: script }, h.ctx);
+		assert.equal(detailRecords(created)[0]?.quiet, true);
+		const onDisk = JSON.parse(fs.readFileSync(path.join(scheduledRunStorePath(h.ctx.cwd, undefined, path.join(h.root, "stores")), "quiet-hourly", "schedule.json"), "utf-8")) as { quiet?: unknown };
+		assert.equal(onDisk.quiet, true);
+
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		assert.deepEqual(h.launches[0]?.params.scheduleOrigin, { id: "quiet-hourly", name: "workflow -> agent worker", quiet: true });
+	});
+
+	it("rejects a non-boolean quiet value", async () => {
+		const h = harness();
+		const rejected = await h.manager.handleToolCall({ action: "schedule.create", id: "bad-quiet", every: "1h", quiet: "yes" as unknown as boolean, workflowScript: script }, h.ctx);
+		assert.equal(rejected.isError, true);
+		assert.match(text(rejected), /quiet must be a boolean/);
+	});
+
+	it("keeps one-shot at schedules noisy", async () => {
+		const h = harness();
+		const rejected = await h.manager.handleToolCall({ action: "schedule.create", id: "quiet-once", at: "+10m", quiet: true, workflowScript: script }, h.ctx);
+		assert.equal(rejected.isError, true);
+		assert.match(text(rejected), /quiet is only supported for recurring schedules/);
+
+		const created = await h.manager.handleToolCall({ action: "schedule.create", id: "once", at: "+10m", workflowScript: script }, h.ctx);
+		assert.equal("quiet" in detailRecords(created)[0]!, false);
+		h.clock.now += 10 * 60_000;
+		h.timers.fireAll();
+		await flush();
+		assert.equal("quiet" in (h.launches[0]?.params.scheduleOrigin as Record<string, unknown>), false);
+	});
+
+	it("keeps schedule.run noisy unless that launch asks for quiet", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "quiet-hourly", every: "1h", quiet: true, workflowScript: script }, h.ctx);
+
+		const manual = h.manager.handleToolCall({ action: "schedule.run", id: "quiet-hourly" }, h.ctx);
+		await flush();
+		assert.equal("quiet" in (h.launches[0]?.params.scheduleOrigin as Record<string, unknown>), false);
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "manual-loud" } });
+		await manual;
+		h.manager.handleAsyncCompletion({ runId: "manual-loud", success: true, summary: "Done" });
+
+		const explicit = h.manager.handleToolCall({ action: "schedule.run", id: "quiet-hourly", quiet: true }, h.ctx);
+		await flush();
+		assert.deepEqual(h.launches[1]?.params.scheduleOrigin, { id: "quiet-hourly", name: "workflow -> agent worker", quiet: true });
+		h.launches[1]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "manual-quiet" } });
+		await explicit;
+	});
+});
+
 describe("recurring schedule execution", () => {
 	it("launches a fixed interval from its planned time and records durable history/events", async () => {
 		const h = harness();
@@ -613,7 +981,7 @@ describe("recurring schedule execution", () => {
 		h.clock.now += 3_600_000;
 		h.timers.fireAll();
 		assert.equal(h.launches.length, 1);
-		assert.deepEqual(h.launches[0]?.params, { workflowScript: "return runs.run('main', { agent: 'worker', task: 'Maintain backlog' })", async: true, context: "fresh", cwd: h.ctx.cwd, mission: false, scheduleOrigin: { id: "hourly", name: "workflowScript -> agent worker" } });
+		assert.deepEqual(h.launches[0]?.params, { workflowScript: "return runs.run('main', { agent: 'worker', task: 'Maintain backlog' })", args: {}, async: true, context: "fresh", cwd: h.ctx.cwd, mission: false, scheduleOrigin: { id: "hourly", name: "workflow -> agent worker" } });
 		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async worker" }], details: { mode: "single", results: [], asyncId: "async-1", asyncDir: "/tmp/async-1" } });
 		await flush();
 		assert.deepEqual([...h.manager.observedCompletionRunIds()], ["async-1"]);
@@ -907,6 +1275,39 @@ describe("recurring schedule execution", () => {
 		assert.equal(h.launches.length, 1);
 	});
 
+	it("a successful manual launch satisfies the next natural fire", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "manual-interval", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
+		h.clock.now += 5 * 60_000;
+		const manual = h.manager.handleToolCall({ action: "schedule.run", id: "manual-interval" }, h.ctx);
+		await flush();
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "manual-async" } });
+		await manual;
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.show", id: "manual-interval" }, h.ctx)), /Next: 2030-01-01T01:05:00.000Z/);
+		h.manager.handleAsyncCompletion({ runId: "manual-async", success: true });
+		h.clock.now = Date.parse("2030-01-01T01:00:00.000Z");
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 1);
+	});
+
+	it("a failed manual launch still honors a natural fire that overlapped while attachment was pending", async () => {
+		const h = harness();
+		await h.manager.handleToolCall({ action: "schedule.create", id: "overlap-fail", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);
+		const manual = h.manager.handleToolCall({ action: "schedule.run", id: "overlap-fail" }, h.ctx);
+		await flush();
+		h.clock.now += 3_600_000;
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 1);
+		h.launches[0]!.resolve({ content: [{ type: "text", text: "spawn failed" }], details: { mode: "management", results: [] }, isError: true });
+		assert.match(text(await manual), /failed_launch/);
+		assert.match(text(await h.manager.handleToolCall({ action: "schedule.show", id: "overlap-fail" }, h.ctx)), /Next: 2030-01-01T01:00:00.000Z/);
+		h.timers.fireAll();
+		await flush();
+		assert.equal(h.launches.length, 2);
+	});
+
 	it("distinguishes failed launch from failed async completion", async () => {
 		const h = harness();
 		await h.manager.handleToolCall({ action: "schedule.create", id: "failures", every: "1h", workflowScript: "return runs.run('main', { agent: 'worker' })" }, h.ctx);

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

@@ -45,13 +45,7 @@ describe("config.scheduledRuns.storeRoot", () => {
 
 	it("rejects project-relative paths during config load", () => {
 		saveConfig({ scheduledRuns: { storeRoot: "schedules" } });
-		const originalError = console.error;
-		console.error = () => {};
-		try {
-			assert.deepEqual(loadConfig(), {});
-		} finally {
-			console.error = originalError;
-		}
+		assert.throws(() => loadConfig(), /absolute path/);
 	});
 
 	it("rejects project-relative paths during config update", () => {
@@ -64,4 +58,4 @@ describe("config.scheduledRuns.storeRoot", () => {
 		saveConfig({ scheduledRuns: { storeRoot } });
 		assert.equal(loadConfig().scheduledRuns?.storeRoot, storeRoot);
 	});
-});
+});