pi-crew 0.11.1 → 0.11.4

package/src/runtime/output/output-validator.ts

@@ -123,10 +123,15 @@ export function validateWorkerOutput(role: string, output: string): OutputValida
  *
  * A trimmed non-empty line counts as log noise ONLY if it matches one of:
  *  1. a bracket-tag extension log line: `[oc-go] ...`, `[pi-qwen-mm] ...`,
- *     `[pi-qwen-mm] [core] [stderr] ...` — the leading tag is a lowercase
- *     identifier (deliberately excludes capitalized bracketed prose like
- *     `[Note] ...`), optionally followed by known sub-tags
- *     (core/mcp/stderr/stdout/warn/info/error/debug);
+ *     `[pi-qwen-mm] [core] [stderr] ...`, and — Finding #2 (2026-09-29
+ *     battery) — colon-bearing extension tags like
+ *     `[pi-crew:crash-recovery.reconcileStaleRuns] ...` or
+ *     `[pi-crew:crew-vibes.publish-quota-status] ...`. The leading tag
+ *     starts with a lowercase char (deliberately excludes capitalized
+ *     bracketed prose like `[Note] ...` / `[Note: ...]`); the rest of the tag
+ *     may carry `:`, `-`, `_`, `.`, digits, and inner capitals (extension
+ *     subsystem names are camelCase, e.g. `reconcileStaleRuns`), optionally
+ *     followed by known sub-tags (core/mcp/stderr/stdout/warn/info/error/debug);
  *  2. a Python `warnings.warn(` line (deprecation-warning continuation);
  *  3. a timestamped logging line: `2026-08-15 21:49:02,986 WARNING ...`.
  *
@@ -137,7 +142,7 @@ export function validateWorkerOutput(role: string, output: string): OutputValida
  * (post-execution.ts) applies the two-gate rule (authoritative output
  * sources empty AND artifact log-noise-only) before failing a task.
  */
-const BRACKET_TAG_LOG_LINE = /^\[[a-z0-9][a-z0-9_.-]*\](?:\s*\[(?:core|mcp|stderr|stdout|warn|info|error|debug)\])*(?:\s.*)?$/;
+const BRACKET_TAG_LOG_LINE = /^\[[a-z0-9][a-zA-Z0-9_.:\-]*\](?:\s*\[(?:core|mcp|stderr|stdout|warn|info|error|debug)\])*(?:\s.*)?$/;
 const PYTHON_WARNING_LINE = /(?:^|\s)warnings\.warn\(/;
 const TIMESTAMPED_LOG_LINE = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:[.,]\d{1,6})?(?:Z|[+-]\d{2}:?\d{2})?\s+[A-Za-z]+\b/;
 

package/src/runtime/plan-approval.ts

@@ -70,7 +70,20 @@ export async function ensurePlanApprovalRequested(manifest: TeamRunManifest, tas
 	const assessTask = tasks.find((task) => task.stepId === "assess" && task.status === "completed");
 	// ROADMAP T1.2: for non-adaptive workflows, fall back to the most recent
 	// completed read-only (planning) task as the plan reference.
-	const planTask = assessTask ?? [...tasks].reverse().find((t) => t.status === "completed" && !isMutatingTask(t));
+	// RR-021 WI-4.3e: allocation-free reverse scan — the old
+	// [...tasks].reverse().find() copied the whole array per call.
+	// (findLast needs an ES2023 lib bump, which breaks tsgo's RequestInfo
+	// ambient resolution — see WI-4.3 evidence note.)
+	let planTask = assessTask;
+	if (!planTask) {
+		for (let i = tasks.length - 1; i >= 0; i--) {
+			const t = tasks[i];
+			if (t?.status === "completed" && !isMutatingTask(t)) {
+				planTask = t;
+				break;
+			}
+		}
+	}
 	const now = new Date().toISOString();
 
 	// T2/R4 (ADR-4 §6 producer 3 + §8 dual-write): make sure a PlanRecord

package/src/runtime/recovery/crash-recovery.ts

@@ -1,12 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_PATHS } from "../../config/defaults.ts";
 import { appendHookEvent, executeHook } from "../../hooks/registry.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
-import { withRunLockSync } from "../../state/coordination/locks.ts";
+import { discoverRunLockFiles, sweepStaleLocks, withRunLock, withRunLockSync } from "../../state/coordination/locks.ts";
 import { appendEvent, scanSequence } from "../../state/event-log/event-log.ts";
 import { readActiveRunRegistry, unregisterActiveRun } from "../../state/stores/active-run-registry.ts";
-import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } from "../../state/stores/state-store.ts";
+import {
+	loadRunManifestById,
+	loadRunManifestByIdAsync,
+	saveRunManifest,
+	saveRunTasks,
+	updateRunStatus,
+} from "../../state/stores/state-store.ts";
 import type { TeamTaskState } from "../../state/types.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { projectCrewRoot, userCrewRoot } from "../../utils/paths.ts";
@@ -17,6 +24,7 @@ import { isWorkerHeartbeatStale } from "../heartbeat/worker-heartbeat.ts";
 import { terminateLiveAgentsForRun } from "../live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../manifest-cache.ts";
 import { checkProcessLiveness } from "../process-status.ts";
+import { mapConcurrent } from "../scheduling/parallel-utils.ts";
 import { isIntentionalWait, isPlanApprovalPendingEffective, type ReconcileResult, reconcileStaleRun } from "../stale-reconciler.ts";
 
 export interface RecoveryPlan {
@@ -689,13 +697,12 @@ export function purgeStaleActiveRunIndex(
 	return { purged, kept };
 }
 
-export function reconcileAllStaleRuns(
+export async function reconcileAllStaleRuns(
 	cwd: string,
 	manifestCache: ManifestCache,
 	now = Date.now(),
 	currentSessionId?: string,
-): ReconcileResult[] {
-	const results: ReconcileResult[] = [];
+): Promise<ReconcileResult[]> {
 	// Capture runIds to reconcile BEFORE acquiring locks — avoids TOCTOU between cache iteration and lock acquisition.
 	const runIds = manifestCache
 		.list(50)
@@ -707,55 +714,95 @@ export function reconcileAllStaleRuns(
 			return true;
 		})
 		.map((m) => m.runId);
-	for (const runId of runIds) {
-		const cached = manifestCache.get(runId);
-		if (!cached) continue;
-		const loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
-		if (!loaded) continue;
-		// Use lock to prevent race with cancel/status handlers modifying the same run
-		withRunLockSync(loaded.manifest, () => {
-			// Re-read inside lock to get freshest data
-			const fresh = loadRunManifestById(cwd, runId); // NOTE: inside withRunLockSync - consistent read
-			if (!fresh || (fresh.manifest.status !== "running" && fresh.manifest.status !== "blocked")) return;
-			// Belt-and-suspenders: reconcileStaleRun itself guards this, but the run
-			// may have flipped to blocked+plan-approval between cache-list and lock
-			// acquisition — re-check the freshest manifest under the lock.
-			if (isPlanApprovalPendingEffective(fresh.manifest)) {
-				results.push({
-					runId,
-					verdict: "blocked_awaiting_approval",
-					repaired: false,
-					detail: "Plan approval is pending; stale reconciliation skipped",
-				});
-				return;
-			}
-			const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
-			if (result.repaired || result.verdict === "result_exists") {
-				if (result.repairedTasks) {
-					saveRunTasks(fresh.manifest, result.repairedTasks);
-					for (const task of result.repairedTasks) {
-						try {
-							upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
-						} catch {
-							/* non-critical */
+	// RR-021 WI-1.5 (audit C3): serial reconcile → mapConcurrent bound 4.
+	// Each runId acquires its OWN run lock file (lockPath() is per-run), so the
+	// acquisitions are independent; bound 4 caps fs/CPU contention. Results keep
+	// input (snapshot) order — mapConcurrent indexes by item — and per-run
+	// semantics (re-read inside lock, plan-approval re-check) are unchanged.
+	const perRun = await mapConcurrent(runIds, 4, async (runId): Promise<ReconcileResult[]> => {
+		// RR-021 review remediation: per-run error isolation — one corrupt run
+		// must not reject the whole sweep (serial baseline threw too, but the
+		// SPEC's "independent per-run" intent requires continue-on-error).
+		try {
+			const cached = manifestCache.get(runId);
+			if (!cached) return [];
+			const loaded = await loadRunManifestByIdAsync(cwd, runId); // NOTE: best-effort only; concurrent writes may cause inconsistency
+			if (!loaded) return [];
+			const out: ReconcileResult[] = [];
+			// Use lock to prevent race with cancel/status handlers modifying the same run.
+			// Same v0.9.26 lock family as the old sync acquisition — interop-safe.
+			await withRunLock(loaded.manifest, async () => {
+				// Re-read inside lock to get freshest data
+				const fresh = await loadRunManifestByIdAsync(cwd, runId); // NOTE: inside withRunLock - consistent read
+				if (!fresh || (fresh.manifest.status !== "running" && fresh.manifest.status !== "blocked")) return;
+				// Belt-and-suspenders: reconcileStaleRun itself guards this, but the run
+				// may have flipped to blocked+plan-approval between cache-list and lock
+				// acquisition — re-check the freshest manifest under the lock.
+				if (isPlanApprovalPendingEffective(fresh.manifest)) {
+					out.push({
+						runId,
+						verdict: "blocked_awaiting_approval",
+						repaired: false,
+						detail: "Plan approval is pending; stale reconciliation skipped",
+					});
+					return;
+				}
+				const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
+				if (result.repaired || result.verdict === "result_exists") {
+					if (result.repairedTasks) {
+						saveRunTasks(fresh.manifest, result.repairedTasks);
+						for (const task of result.repairedTasks) {
+							try {
+								upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
+							} catch {
+								/* non-critical */
+							}
 						}
 					}
+					updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
+					void terminateLiveAgentsForRun(fresh.manifest.runId, "failed", appendEvent, fresh.manifest.eventsPath).catch((error) =>
+						logInternalError("crash-recovery.reconcile.terminate", error, `runId=${fresh.manifest.runId}`, "warn"),
+					);
+					appendEvent(fresh.manifest.eventsPath, {
+						type: "crew.run.reconciled_stale",
+						runId,
+						message: result.detail,
+						data: { verdict: result.verdict },
+					});
+				}
+				if (result.verdict !== "healthy") {
+					out.push(result);
 				}
-				updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
-				void terminateLiveAgentsForRun(fresh.manifest.runId, "failed", appendEvent, fresh.manifest.eventsPath).catch((error) =>
-					logInternalError("crash-recovery.reconcile.terminate", error, `runId=${fresh.manifest.runId}`, "warn"),
+			});
+			return out;
+		} catch (error) {
+			logInternalError("crash-recovery.reconcileStaleRuns", error, `runId=${runId}`, "warn");
+			return [];
+		}
+	});
+	const results = perRun.flat();
+	// US-002 (2026-09-22): structured stale-lock sweep. Runs after reconciliation
+	// so locks whose holder died (kill -9 / crash) do not linger. The sweep is
+	// strictly safer than acquire-time steal (stale AND holder-dead only), so a
+	// live holder is never disturbed. Best-effort.
+	try {
+		const runsRoots = [
+			path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.runsSubdir),
+			path.join(userCrewRoot(), DEFAULT_PATHS.state.runsSubdir),
+		];
+		for (const runsRoot of runsRoots) {
+			const { removed } = sweepStaleLocks(discoverRunLockFiles(runsRoot));
+			if (removed.length > 0) {
+				logInternalError(
+					"crash-recovery.sweep-stale-locks",
+					new Error(`swept ${removed.length} stale run lock(s)`),
+					removed.join(", "),
+					"warn",
 				);
-				appendEvent(fresh.manifest.eventsPath, {
-					type: "crew.run.reconciled_stale",
-					runId,
-					message: result.detail,
-					data: { verdict: result.verdict },
-				});
-			}
-			if (result.verdict !== "healthy") {
-				results.push(result);
 			}
-		});
+		}
+	} catch (error) {
+		logInternalError("crash-recovery.sweep-stale-locks", error);
 	}
 	return results;
 }

package/src/runtime/run-worker.ts

@@ -72,7 +72,18 @@ export interface WorkerSpawnInput extends ChildPiRunInput {
 export async function runWorker(input: WorkerSpawnInput): Promise<ChildPiRunResult> {
 	const { cap = true, ...childPiInput } = input;
 	if (cap) {
-		return withWorkerSlot(() => runChildPi(childPiInput));
+		// RR-014 / F15: thread the caller's signal into the slot WAIT itself.
+		// Previously the signal lived only inside childPiInput and was read by
+		// runChildPi AFTER the acquire resolved — a cancelled task queued on a
+		// full pool stayed pending until the slot holder finished (and delayed
+		// every drainPendingUnits awaiting it). Two consistent outcomes:
+		// - abort wins the race → acquire rejects (SemaphoreAbortedError), no
+		//   slot taken, fn never runs;
+		// - grant wins the race → acquire resolves, runChildPi's pre-spawn
+		//   guard (child-pi-spawn.ts B5) sees signal.aborted and returns
+		//   kind "aborted" WITHOUT spawning, and withWorkerSlot's finally
+		//   releases the slot within a microtask.
+		return withWorkerSlot(() => runChildPi(childPiInput), childPiInput.signal);
 	}
 	return runChildPi(childPiInput);
 }

package/src/runtime/scheduling/global-worker-cap.ts

@@ -64,11 +64,16 @@ export function __test_resetCap(testCapacity: number): void {
  * Acquire a global worker slot. Resolves immediately if under cap, else queues
  * (FIFO) until a slot frees. MUST be paired with releaseWorkerSlot().
  *
+ * RR-014 / F15: an optional AbortSignal makes the WAIT itself cancellable — a
+ * waiter whose signal fires is removed from the queue eagerly and the acquire
+ * REJECTS (SemaphoreAbortedError) without consuming a slot. Without a signal
+ * the semantics are unchanged.
+ *
  * Used to bound WORKER spawns only. Do NOT route the goal-judge through this
  * (see the RFC MAJ#3 rationale in the module header).
  */
-export async function acquireWorkerSlot(): Promise<void> {
-	await semaphore.acquire();
+export async function acquireWorkerSlot(signal?: AbortSignal): Promise<void> {
+	await semaphore.acquire(signal);
 }
 
 /**
@@ -82,13 +87,15 @@ export function releaseWorkerSlot(): void {
 /**
  * Convenience: acquire a worker slot, run `fn`, and release on completion OR
  * throw. The slot is ALWAYS released — including when `fn` rejects — so a
- * throwing worker never leaks a slot (deadlock prevention).
+ * throwing worker never leaks a slot (deadlock prevention). If `signal` is
+ * provided and fires while WAITING for a slot, the acquire rejects and `fn`
+ * never runs (no slot was taken, so there is nothing to release).
  *
  * Example:
- *   const result = await withWorkerSlot(() => runChildPi(...));
+ *   const result = await withWorkerSlot(() => runChildPi(...), input.signal);
  */
-export async function withWorkerSlot<T>(fn: () => Promise<T>): Promise<T> {
-	await acquireWorkerSlot();
+export async function withWorkerSlot<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+	await acquireWorkerSlot(signal);
 	try {
 		return await fn();
 	} finally {

package/src/runtime/scheduling/run-coalesced-task-group.ts

@@ -5,6 +5,7 @@ import { writeArtifact } from "../../state/stores/artifact-store.ts";
 import { loadRunManifestById, saveRunTasksAsync, updateRunStatus } from "../../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import type { WorkflowStep } from "../../workflows/workflow-config.ts";
+import { appendDeadletter } from "../deadletter.ts";
 import { createWorkerHeartbeat, touchWorkerHeartbeat } from "../heartbeat/worker-heartbeat.ts";
 import type { CrewRuntimeMode } from "../model/runtime-resolver.ts";
 import type { RetryPolicy } from "../recovery/retry-executor.ts";
@@ -196,7 +197,32 @@ export async function runCoalescedTaskGroup(input: CoalescedTaskGroupInput): Pro
 			}
 		};
 		try {
-			const result = useRetry ? await executeWithRetry(runOnce, policy, { signal }) : await runOnce();
+			const result = useRetry
+				? await executeWithRetry(runOnce, policy, {
+						signal,
+						// US-003 (2026-09-22): exhausted retries on the COALESCED path were never
+						// deadlettered — only the singleton path (dispatch-batch) wired
+						// onRetryGivenUp, so an M6 group that burned its whole retry budget left
+						// no post-mortem record once the run dir was pruned. The group shares ONE
+						// worker: the entry is recorded against the group's first task and names
+						// the whole group in the message. Aborts are NOT exhaustion — skip them
+						// (executeWithRetry also fires this hook on the cancelled exit).
+						onRetryGivenUp: (attempts, error) => {
+							if (signal?.aborted) return;
+							appendDeadletter(manifest, {
+								runId: manifest.runId,
+								taskId: firstTask.id,
+								reason: "max-retries",
+								attempts,
+								lastError: `coalesced group (${taskIds.length} task(s): ${taskIds.join(", ")}) — ${error.message}`,
+								timestamp: new Date().toISOString(),
+								agent: agent.name,
+								role: firstTask.role,
+								runStatus: manifest.status,
+							});
+						},
+					})
+				: await runOnce();
 			rawOutput = result.rawFinalText ?? result.stdout ?? "";
 			// RT-5 #1/#2: distinguish cancel from failure. Cancel = run-level
 			// signal aborted OR the child reports cooperative cancellation.

package/src/runtime/scheduling/scheduler.ts

@@ -24,6 +24,7 @@ export type ScheduleChangeEvent =
 	| { type: "removed"; jobId: string; spawnedRunIds?: string[] }
 	| { type: "updated"; job: ScheduledJob }
 	| { type: "fired"; jobId: string; agentId: string; name: string }
+	| { type: "skipped"; jobId: string; reason: string }
 	| { type: "error"; jobId: string; error: string };
 
 export interface CrewSchedulerOptions {
@@ -152,19 +153,29 @@ export class CrewScheduler {
 	private arm(job: ScheduledJob): void {
 		if (this.timers.has(job.id)) return;
 		if (job.scheduleType === "interval" && job.intervalMs) {
-			const t = setInterval(() => this.fire(job.id), job.intervalMs);
-			t.unref();
-			this.timers.set(job.id, t);
+			// 2026-09-22 spawn-storm root cause: this branch used
+			// setInterval(fire, intervalMs). Node timers are 32-bit — a LEGAL long
+			// interval (e.g. 90d = 7,776,000,000ms > 2^31-1) overflows and Node
+			// silently sets the delay to 1ms (TimeoutOverflowWarning): the job then
+			// fired every millisecond, and each
+			// tick dispatched another run (measured live: ~104 garbage runs + 50+
+			// node processes from ONE registered 90-day interval job). armCron()
+			// already clamps its hops below the same ceiling — the interval branch
+			// was missed. Reuse the identical chained-hop treatment: schedule toward
+			// now+intervalMs, clamped; cronTick fires on arrival (its
+			// advanceCronNextRun is a cron-only no-op here), and fire()'s internal
+			// update() → disarm→arm lifecycle re-arms the next interval.
+			const targetMs = this.now().getTime() + job.intervalMs;
+			this.setCronTimeout(job.id, targetMs);
 		} else if (job.scheduleType === "once") {
 			const target = new Date(job.schedule).getTime();
 			const delay = target - this.now().getTime();
 			if (delay > 0) {
-				const t = setTimeout(() => {
-					this.fire(job.id);
-					this.update(job.id, { enabled: false });
-				}, delay);
-				t.unref();
-				this.timers.set(job.id, t);
+				// Same 32-bit ceiling as the interval branch above: a once job armed
+				// > 2^31-1 ms out (e.g. "+30d" — a LEGAL relative spec — or a far ISO
+				// timestamp) overflowed setTimeout to a 1ms PREMATURE fire. Chained hops
+				// instead; cronTick self-disables once-jobs on arrival (below).
+				this.setCronTimeout(job.id, target);
 			} else {
 				this.update(job.id, { enabled: false, lastStatus: "error" });
 				this.emit?.({
@@ -219,6 +230,9 @@ export class CrewScheduler {
 		// hop that just fired is dead, so no timer doubles up.
 		this.fire(jobId);
 		this.advanceCronNextRun(jobId);
+		// once-semantics (was inline in arm()'s removed setTimeout): consume the
+		// job after its single arrival fire so a re-arm cannot fire it again.
+		if (job.scheduleType === "once") this.update(jobId, { enabled: false });
 	}
 
 	/** After a cron fire, advance the persisted nextRun to the next occurrence
@@ -265,6 +279,18 @@ export class CrewScheduler {
 		const job = this.jobs.get(id);
 		if (!job || !this.executor) return;
 		if (!job.enabled && !force) return;
+		// In-flight guard (2026-09-22, storm follow-up): the executor dispatches
+		// asynchronously and resets lastStatus (success/error) only on completion,
+		// so `running` marks the in-flight window. Without backpressure here, any
+		// interval shorter than the run duration stacks one overlapping run per
+		// tick (the 1ms overflow loop was the extreme case; fixed below/above).
+		// Skips emit a "skipped" event (visible to pi.events consumers; the toast
+		// bridge stays silent — a slow executor + short interval would spam).
+		// `force` (run-now) is the explicit escape hatch.
+		if (job.lastStatus === "running" && !force) {
+			this.emit?.({ type: "skipped", jobId: id, reason: "previous dispatch still in flight" });
+			return;
+		}
 		this.update(id, { lastStatus: "running" });
 		let agentId: string;
 		try {
@@ -297,10 +323,15 @@ export class CrewScheduler {
 				normalized: new Date(Date.now() + ms).toISOString(),
 			};
 		}
-		// Interval: 5m
-		const ivl = trimmed.match(/^(\d+)(s|m|h|d)$/);
+		// Interval: 5m — "ms" MUST be accepted: handle-schedule builds
+		// `${params.interval}ms` from the schema-level numeric `interval` param
+		// (ms number), so without an ms unit here every interval schedule died in
+		// the parser ("Invalid schedule …") — found live 2026-09-21 when
+		// `team action='schedule' interval=3600000` was impossible to satisfy.
+		const ivl = trimmed.match(/^(\d+)(ms|s|m|h|d)$/);
 		if (ivl) {
-			const ms = parseInt(ivl[1], 10) * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[ivl[2] as "s" | "m" | "h" | "d"];
+			const ms =
+				parseInt(ivl[1], 10) * { ms: 1, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[ivl[2] as "ms" | "s" | "m" | "h" | "d"];
 			return { type: "interval", intervalMs: ms, normalized: trimmed };
 		}
 		// ISO timestamp
@@ -329,13 +360,18 @@ function parseIntervalMs(s: string): number | undefined {
 	let ms = 0;
 	let remaining = s;
 	const unitMs: Record<string, number> = {
+		// "ms" MUST be first in the regex alternation below and present here:
+		// handle-schedule builds `${params.interval}ms` from the numeric interval
+		// param, so without an ms unit every interval schedule failed to parse
+		// (found live 2026-09-21 — `interval=3600000` was unsatisfiable).
+		ms: 1,
 		s: 1000,
 		m: 60_000,
 		h: 3_600_000,
 		d: 86_400_000,
 	};
 	while (remaining.length > 0) {
-		const m = remaining.match(/^(\d+)(s|m|h|d)/);
+		const m = remaining.match(/^(\d+)(ms|s|m|h|d)/);
 		if (!m) return undefined;
 		ms += parseInt(m[1], 10) * unitMs[m[2]];
 		remaining = remaining.slice(m[0].length);