@oh-my-pi/pi-coding-agent 15.1.2 → 15.1.4

package/src/async/job-manager.ts

@@ -37,6 +37,8 @@ interface AsyncJobDelivery {
 	attempt: number;
 	nextAttemptAt: number;
 	lastError?: string;
+	ownerId?: string;
+	promise?: Promise<void>;
 }
 
 export interface AsyncJobDeliveryState {
@@ -82,6 +84,7 @@ export class AsyncJobManager {
 
 	readonly #jobs = new Map<string, AsyncJob>();
 	readonly #deliveries: AsyncJobDelivery[] = [];
+	readonly #inFlightDeliveries: AsyncJobDelivery[] = [];
 	readonly #suppressedDeliveries = new Set<string>();
 	readonly #watchedJobs = new Set<string>();
 	readonly #evictionTimers = new Map<string, NodeJS.Timeout>();
@@ -219,22 +222,24 @@ export class AsyncJobManager {
 		return this.#filterJobs(this.#jobs.values(), filter);
 	}
 
-	getDeliveryState(): AsyncJobDeliveryState {
-		const nextRetryAt = this.#deliveries.reduce<number | undefined>((next, delivery) => {
+	getDeliveryState(filter?: AsyncJobFilter): AsyncJobDeliveryState {
+		const deliveries = this.#filterDeliveries(filter);
+		const inFlightDeliveries = this.#filterInFlightDeliveries(filter);
+		const nextRetryAt = deliveries.reduce<number | undefined>((next, delivery) => {
 			if (next === undefined) return delivery.nextAttemptAt;
 			return Math.min(next, delivery.nextAttemptAt);
 		}, undefined);
 
 		return {
-			queued: this.#deliveries.length,
-			delivering: this.#deliveryLoop !== undefined,
+			queued: deliveries.length + inFlightDeliveries.length,
+			delivering: inFlightDeliveries.length > 0 || (this.#deliveryLoop !== undefined && deliveries.length > 0),
 			nextRetryAt,
-			pendingJobIds: this.#deliveries.map(delivery => delivery.jobId),
+			pendingJobIds: deliveries.concat(inFlightDeliveries).map(delivery => delivery.jobId),
 		};
 	}
 
-	hasPendingDeliveries(): boolean {
-		return this.#deliveries.length > 0;
+	hasPendingDeliveries(filter?: AsyncJobFilter): boolean {
+		return this.getDeliveryState(filter).queued > 0;
 	}
 
 	watchJobs(jobIds: string[]): number {
@@ -290,12 +295,25 @@ export class AsyncJobManager {
 		await Promise.all(Array.from(this.#jobs.values()).map(job => job.promise));
 	}
 
-	async drainDeliveries(options?: { timeoutMs?: number }): Promise<boolean> {
+	async drainDeliveries(options?: { timeoutMs?: number; filter?: AsyncJobFilter }): Promise<boolean> {
 		const timeoutMs = options?.timeoutMs;
+		const filter = options?.filter;
 		const hasDeadline = timeoutMs !== undefined;
 		const deadline = hasDeadline ? Date.now() + Math.max(timeoutMs, 0) : Number.POSITIVE_INFINITY;
 
-		while (this.hasPendingDeliveries()) {
+		while (this.hasPendingDeliveries(filter)) {
+			if (filter?.ownerId) {
+				const delivered = await this.#deliverNextFiltered(filter, deadline);
+				if (delivered) continue;
+				return false;
+			}
+			const inFlightDeliveries = this.#filterInFlightDeliveries();
+			if (inFlightDeliveries.length > 0 && this.#filterDeliveries().length === 0) {
+				const delivered = await this.#waitForDeliveryPromise(inFlightDeliveries[0]?.promise, deadline);
+				if (delivered) continue;
+				return false;
+			}
+
 			this.#ensureDeliveryLoop();
 			const loop = this.#deliveryLoop;
 			if (!loop) {
@@ -313,7 +331,7 @@ export class AsyncJobManager {
 			}
 
 			await Promise.race([loop, Bun.sleep(remainingMs)]);
-			if (Date.now() >= deadline && this.hasPendingDeliveries()) {
+			if (Date.now() >= deadline && this.hasPendingDeliveries(filter)) {
 				return false;
 			}
 		}
@@ -330,6 +348,7 @@ export class AsyncJobManager {
 		this.#clearEvictionTimers();
 		this.#jobs.clear();
 		this.#deliveries.length = 0;
+		this.#inFlightDeliveries.length = 0;
 		this.#suppressedDeliveries.clear();
 		this.#watchedJobs.clear();
 		return drained;
@@ -388,6 +407,55 @@ export class AsyncJobManager {
 		this.#evictionTimers.clear();
 	}
 
+	#filterDeliveries(filter?: AsyncJobFilter): AsyncJobDelivery[] {
+		const ownerId = filter?.ownerId;
+		if (!ownerId) return this.#deliveries.filter(delivery => !this.isDeliverySuppressed(delivery.jobId));
+		return this.#deliveries.filter(
+			delivery => delivery.ownerId === ownerId && !this.isDeliverySuppressed(delivery.jobId),
+		);
+	}
+
+	#filterInFlightDeliveries(filter?: AsyncJobFilter): AsyncJobDelivery[] {
+		const ownerId = filter?.ownerId;
+		if (!ownerId) return this.#inFlightDeliveries.filter(delivery => !this.isDeliverySuppressed(delivery.jobId));
+		return this.#inFlightDeliveries.filter(
+			delivery => delivery.ownerId === ownerId && !this.isDeliverySuppressed(delivery.jobId),
+		);
+	}
+
+	async #deliverNextFiltered(filter: AsyncJobFilter, deadline: number): Promise<boolean> {
+		while (true) {
+			let selected: AsyncJobDelivery | undefined;
+			for (const delivery of this.#deliveries) {
+				if (delivery.ownerId !== filter.ownerId) continue;
+				if (this.isDeliverySuppressed(delivery.jobId)) continue;
+				if (!selected || delivery.nextAttemptAt < selected.nextAttemptAt) {
+					selected = delivery;
+				}
+			}
+
+			if (!selected) {
+				const inFlight = this.#filterInFlightDeliveries(filter);
+				if (inFlight.length === 0) return true;
+				return this.#waitForDeliveryPromise(inFlight[0]?.promise, deadline);
+			}
+
+			const now = Date.now();
+			if (selected.nextAttemptAt > now) {
+				if (selected.nextAttemptAt > deadline) return false;
+				await Bun.sleep(selected.nextAttemptAt - now);
+				continue;
+			}
+
+			const index = this.#deliveries.indexOf(selected);
+			if (index === -1) continue;
+			this.#deliveries.splice(index, 1);
+			if (this.isDeliverySuppressed(selected.jobId)) continue;
+
+			return this.#waitForDeliveryPromise(this.#deliverDelivery(selected), deadline);
+		}
+	}
+
 	isDeliverySuppressed(jobId: string): boolean {
 		return this.#suppressedDeliveries.has(jobId) || this.#watchedJobs.has(jobId);
 	}
@@ -402,6 +470,7 @@ export class AsyncJobManager {
 			text,
 			attempt: 0,
 			nextAttemptAt: Date.now(),
+			ownerId: this.#jobs.get(jobId)?.ownerId,
 		});
 		this.#ensureDeliveryLoop();
 	}
@@ -437,20 +506,25 @@ export class AsyncJobManager {
 			if (this.#deliveries[0] !== delivery) {
 				continue;
 			}
-			// Check again after sleep
 			if (this.isDeliverySuppressed(delivery.jobId)) {
 				this.#deliveries.shift();
 				continue;
 			}
 
+			this.#deliveries.shift();
+			await this.#deliverDelivery(delivery);
+		}
+	}
+
+	#deliverDelivery(delivery: AsyncJobDelivery): Promise<void> {
+		const promise = (async () => {
+			this.#inFlightDeliveries.push(delivery);
 			try {
 				await this.#onJobComplete(delivery.jobId, delivery.text, this.#jobs.get(delivery.jobId));
-				this.#deliveries.shift();
 			} catch (error) {
 				delivery.attempt += 1;
 				delivery.lastError = error instanceof Error ? error.message : String(error);
 				delivery.nextAttemptAt = Date.now() + this.#getRetryDelay(delivery.attempt);
-				this.#deliveries.shift();
 				if (!this.isDeliverySuppressed(delivery.jobId)) {
 					this.#deliveries.push(delivery);
 				}
@@ -460,8 +534,32 @@ export class AsyncJobManager {
 					nextRetryAt: delivery.nextAttemptAt,
 					error: delivery.lastError,
 				});
+			} finally {
+				const index = this.#inFlightDeliveries.indexOf(delivery);
+				if (index !== -1) this.#inFlightDeliveries.splice(index, 1);
+				if (this.#deliveries.length > 0) this.#ensureDeliveryLoop();
 			}
+		})();
+		delivery.promise = promise;
+		return promise;
+	}
+
+	async #waitForDeliveryPromise(promise: Promise<void> | undefined, deadline: number): Promise<boolean> {
+		if (!promise) return true;
+		if (deadline === Number.POSITIVE_INFINITY) {
+			await promise;
+			return true;
 		}
+		const remainingMs = deadline - Date.now();
+		if (remainingMs <= 0) return false;
+		let timedOut = false;
+		await Promise.race([
+			promise,
+			Bun.sleep(remainingMs).then(() => {
+				timedOut = true;
+			}),
+		]);
+		return !timedOut;
 	}
 
 	#getRetryDelay(attempt: number): number {

package/src/autoresearch/tools/init-experiment.ts

@@ -17,42 +17,20 @@ export const DEFAULT_HARNESS_COMMAND = `bash ${HARNESS_FILENAME}`;
 const HARNESS_COMMIT_TITLE = "autoresearch: harness setup";
 
 const initExperimentSchema = z.object({
-	name: z.string().describe("Human-readable experiment name."),
-	goal: z.string().describe("Free-form description of what this session optimizes.").optional(),
-	primary_metric: z
-		.string()
-		.describe(
-			"Primary metric name shown in the dashboard. Match the `METRIC <name>=<value>` lines printed by the benchmark.",
-		),
-	metric_unit: z.string().describe("Unit for the primary metric (e.g. ms, µs, mb). Empty when unitless.").optional(),
+	name: z.string().describe("experiment name"),
+	goal: z.string().describe("session goal").optional(),
+	primary_metric: z.string().describe("primary metric name"),
+	metric_unit: z.string().describe("metric unit (e.g. ms, µs, mb)").optional(),
 	direction: z
 		.enum(["lower", "higher"] as const)
-		.describe("Whether lower or higher values are better. Defaults to lower.")
-		.optional(),
-	secondary_metrics: z
-		.array(z.string())
-		.describe("Names of secondary metrics tracked alongside the primary metric.")
-		.optional(),
-	scope_paths: z
-		.array(z.string())
-		.describe(
-			"Files or directories the agent expects to modify. Used post-hoc to flag scope deviations on log_experiment; never used to block edits.",
-		)
-		.optional(),
-	off_limits: z
-		.array(z.string())
-		.describe(
-			"Paths the agent SHOULD NOT modify. Used post-hoc to flag scope deviations on log_experiment; never used to block edits.",
-		)
-		.optional(),
-	constraints: z.array(z.string()).describe("Free-form constraints (e.g. 'no api break').").optional(),
-	max_iterations: z.number().describe("Soft cap on iterations per segment. Optional.").optional(),
-	new_segment: z
-		.boolean()
-		.describe(
-			"When true, bump to a new segment even when an active session exists. New baselines and best-metric reset.",
-		)
+		.describe("better direction (default lower)")
 		.optional(),
+	secondary_metrics: z.array(z.string()).describe("secondary metric names").optional(),
+	scope_paths: z.array(z.string()).describe("expected-to-modify paths").optional(),
+	off_limits: z.array(z.string()).describe("off-limits paths").optional(),
+	constraints: z.array(z.string()).describe("free-form constraints").optional(),
+	max_iterations: z.number().describe("soft iteration cap per segment").optional(),
+	new_segment: z.boolean().describe("bump to a new segment in existing session").optional(),
 });
 
 interface InitExperimentDetails {

package/src/autoresearch/tools/log-experiment.ts

@@ -37,35 +37,21 @@ import type {
 const EXPERIMENT_TOOL_NAMES = ["init_experiment", "run_experiment", "log_experiment", "update_notes"];
 
 const logExperimentSchema = z.object({
-	metric: z
-		.number()
-		.describe("Primary metric value for this run. May differ from the parsed value; deviation is recorded."),
-	status: z.enum(["keep", "discard", "crash", "checks_failed"] as const).describe("Outcome for this run."),
-	description: z.string().describe("Short description of the experiment."),
-	metrics: z.record(z.string(), z.number()).describe("Secondary metrics for this run.").optional(),
-	asi: z
-		.object({})
-		.passthrough()
-		.describe("Free-form structured metadata captured for this run (hypothesis, learnings, etc.).")
-		.optional(),
-	commit: z
-		.string()
-		.describe("Override the commit hash recorded for this run. Defaults to the current HEAD.")
-		.optional(),
-	justification: z
-		.string()
-		.describe(
-			"Required when the run modifies paths outside scope or inside off-limits and you still want it kept. Free-form explanation.",
-		)
-		.optional(),
+	metric: z.number().describe("primary metric value"),
+	status: z.enum(["keep", "discard", "crash", "checks_failed"] as const).describe("run outcome"),
+	description: z.string().describe("short run description"),
+	metrics: z.record(z.string(), z.number()).describe("secondary metrics").optional(),
+	asi: z.object({}).passthrough().describe("free-form structured metadata").optional(),
+	commit: z.string().describe("override recorded commit hash").optional(),
+	justification: z.string().describe("required when keeping a scope-deviating run").optional(),
 	flag_runs: z
 		.array(
 			z.object({
-				run_id: z.number().describe("Run id (#) of a previously logged run to flag as suspect."),
-				reason: z.string().describe("Why this earlier run is suspect (e.g. reward-hacked, broken metric)."),
+				run_id: z.number().describe("run id to flag"),
+				reason: z.string().describe("why this run is suspect"),
 			}),
 		)
-		.describe("Mark earlier runs as flagged. Flagged runs are excluded from baseline and best-metric math.")
+		.describe("flag earlier runs as suspect")
 		.optional(),
 });
 

package/src/autoresearch/tools/run-experiment.ts

@@ -27,7 +27,7 @@ import type { AutoresearchToolFactoryOptions, RunDetails, RunExperimentProgressD
 import { DEFAULT_HARNESS_COMMAND } from "./init-experiment";
 
 const runExperimentSchema = z.object({
-	timeout_seconds: z.number().describe("Timeout in seconds. Defaults to 600.").optional(),
+	timeout_seconds: z.number().describe("timeout in seconds (default 600)").optional(),
 });
 
 interface ProcessExecutionResult {

package/src/autoresearch/tools/update-notes.ts

@@ -9,15 +9,8 @@ import { openAutoresearchStorageIfExists } from "../storage";
 import type { AutoresearchToolFactoryOptions } from "../types";
 
 const updateNotesSchema = z.object({
-	body: z
-		.string()
-		.describe("Replacement markdown body for the active autoresearch session's notes (your durable playbook)."),
-	append_idea: z
-		.string()
-		.describe(
-			"When set, append this string as a new bullet under an Ideas section instead of replacing the body. `body` is ignored.",
-		)
-		.optional(),
+	body: z.string().describe("replacement notes body"),
+	append_idea: z.string().describe("append as bullet under Ideas instead of replacing body").optional(),
 });
 
 interface UpdateNotesDetails {