omegon 0.10.2 → 0.10.4

package/bin/omegon.mjs

@@ -135,20 +135,31 @@ function purgeSelfReferentialPackages() {
 }
 purgeSelfReferentialPackages();
 
-process.argv = injectBundledResourceArgs(process.argv);
-
 // ---------------------------------------------------------------------------
-// Pre-import splash — show a simple loading indicator while the module graph
-// resolves. The TUI takes over once interactive mode starts.
+// CLI launch — subprocess with restart-loop support.
+//
+// Instead of importing the CLI directly (which makes restart impossible since
+// Node can't replace its own process image), we spawn it as a child process.
+// If the child exits with code 75 (EX_TEMPFAIL), we re-spawn — this is the
+// restart signal from /update and /restart commands.
+//
+// This keeps the wrapper as the foreground process group leader throughout,
+// so the re-spawned CLI always owns the terminal and can receive input.
 // ---------------------------------------------------------------------------
+import { spawn as nodeSpawn } from "node:child_process";
+
+const RESTART_EXIT_CODE = 75;
+
+const cliArgs = injectBundledResourceArgs(process.argv).slice(2);
+
 const isInteractive = process.stdout.isTTY &&
   !process.argv.includes("-p") &&
   !process.argv.includes("--print") &&
   !process.argv.includes("--help") &&
   !process.argv.includes("-h");
 
-let preImportCleanup;
-if (isInteractive) {
+function showPreImportSpinner() {
+  if (!isInteractive) return undefined;
   const PRIMARY = "\x1b[38;2;42;180;200m";
   const DIM = "\x1b[38;2;64;88;112m";
   const RST = "\x1b[0m";
@@ -157,9 +168,8 @@ if (isInteractive) {
   const spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
   let frame = 0;
 
-  // Safety net: restore cursor on any exit path (crash, SIGTERM, etc.)
   const restoreCursor = () => { try { process.stdout.write(SHOW_CURSOR); } catch {} };
-  process.on('exit', restoreCursor);
+  process.on("exit", restoreCursor);
 
   process.stdout.write(HIDE_CURSOR);
   process.stdout.write(`\n  ${PRIMARY}omegon${RST} ${DIM}loading…${RST}`);
@@ -170,16 +180,52 @@ if (isInteractive) {
     frame++;
   }, 80);
 
-  preImportCleanup = () => {
+  return () => {
     clearInterval(spinTimer);
-    process.removeListener('exit', restoreCursor);
-    // Clear the loading line and restore cursor
+    process.removeListener("exit", restoreCursor);
     process.stdout.write(`\r\x1b[2K${SHOW_CURSOR}`);
   };
 }
 
-try {
-  await import(cli);
-} finally {
-  preImportCleanup?.();
+function launchCli() {
+  return new Promise((resolve) => {
+    const cleanup = showPreImportSpinner();
+
+    const child = nodeSpawn(process.execPath, [cli, ...cliArgs], {
+      stdio: "inherit",
+      env: process.env,
+    });
+
+    // Let the child handle SIGINT (Ctrl+C) — the wrapper ignores it.
+    const ignoreInt = () => {};
+    process.on("SIGINT", ignoreInt);
+    // Forward SIGTERM so graceful shutdown works.
+    const fwdTerm = () => child.kill("SIGTERM");
+    process.on("SIGTERM", fwdTerm);
+
+    // Clean up spinner once the child's TUI takes over. The child will
+    // clear the screen on startup anyway, but a brief delay ensures the
+    // spinner doesn't flicker.
+    if (cleanup) {
+      setTimeout(() => cleanup(), 200);
+    }
+
+    child.on("exit", (code, signal) => {
+      process.removeListener("SIGINT", ignoreInt);
+      process.removeListener("SIGTERM", fwdTerm);
+      if (signal) {
+        // Re-raise the signal so the wrapper exits with the right status
+        process.kill(process.pid, signal);
+      }
+      resolve(code ?? 1);
+    });
+  });
 }
+
+// Main loop — restart on exit code 75
+let exitCode;
+do {
+  exitCode = await launchCli();
+} while (exitCode === RESTART_EXIT_CODE);
+
+process.exit(exitCode);

package/extensions/bootstrap/index.ts

@@ -25,7 +25,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir, tmpdir } from "node:os";
 import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
-import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
+
 import { checkAllProviders, type AuthResult } from "../01-auth/auth.ts";
 import { loadPiConfig } from "../lib/model-preferences.ts";
 import {
@@ -436,101 +436,18 @@ export default function (pi: ExtensionAPI) {
  * exit and release the terminal), then exec's the new Omegon. This avoids
  * two TUI processes fighting over the same terminal simultaneously.
  */
+/**
+ * Restart Omegon by exiting with code 75.
+ *
+ * The bin/omegon.mjs wrapper runs the CLI in a subprocess loop. When it sees
+ * exit code 75 (EX_TEMPFAIL), it re-spawns a fresh CLI process. Because the
+ * wrapper stays as the foreground process group leader throughout, the new
+ * CLI always owns the terminal and can receive input — no detached spawn,
+ * no competing with the shell for stdin.
+ */
 function restartOmegon(): never {
-	const { command, argvPrefix } = resolveOmegonSubprocess();
-	const userArgs = process.argv.slice(2).filter(a =>
-		!a.startsWith("--extensions-dir=") &&
-		!a.startsWith("--themes-dir=") &&
-		!a.startsWith("--skills-dir=") &&
-		!a.startsWith("--prompts-dir=") &&
-		!a.startsWith("--extension=") && !a.startsWith("--extension ") &&
-		!a.startsWith("--skill=") && !a.startsWith("--skill ") &&
-		!a.startsWith("--prompt-template=") && !a.startsWith("--prompt-template ") &&
-		!a.startsWith("--theme=") && !a.startsWith("--theme ") &&
-		!a.startsWith("--no-skills") &&
-		!a.startsWith("--no-prompt-templates") &&
-		!a.startsWith("--no-themes") &&
-		!a.startsWith("--no-extensions")
-	);
-
-	const parts = [command, ...argvPrefix, ...userArgs].map(shellEscape);
-	const script = join(tmpdir(), `omegon-restart-${process.pid}.sh`);
-	const oldPid = process.pid;
-	writeFileSync(script, [
-		"#!/bin/sh",
-		// Trap signals so Ctrl+C works; ignore HUP so parent death doesn't kill us
-		"trap 'stty sane 2>/dev/null; exit 130' INT TERM",
-		"trap '' HUP",
-		// Wait for the old process to fully die (poll with timeout)
-		"_w=0",
-		`while kill -0 ${oldPid} 2>/dev/null; do`,
-		"  sleep 0.1",
-		"  _w=$((_w + 1))",
-		// Bail after ~5 seconds — proceed anyway
-		'  [ "$_w" -ge 50 ] && break',
-		"done",
-		// Extra grace period for fd/terminal release
-		"sleep 0.3",
-		// Hard terminal reset via /dev/tty — avoids stdout buffering that
-		// bleeds into the exec'd process. RIS clears all protocol state
-		// (kitty keyboard protocol, bracketed paste, mouse tracking, etc.).
-		// Do NOT use `reset` here — it outputs terminfo init strings to
-		// stdout which the new TUI interprets as input (causing stray
-		// characters and double renders).
-		"printf '\\033c' >/dev/tty 2>/dev/null",
-		"stty sane 2>/dev/null",
-		// Clean up this script
-		`rm -f "${script}"`,
-		// Replace this shell with new omegon
-		`exec ${parts.join(" ")}`,
-	].join("\n") + "\n", { mode: 0o755 });
-
-	// Reset terminal to cooked mode BEFORE exiting so the restart script
-	// (and the user) aren't stuck with raw-mode terminal if something goes wrong.
-	try {
-		// RIS (Reset to Initial State) — the only reliable way to ensure ALL
-		// terminal protocol state is cleared. Write directly to the TTY fd
-		// to bypass pi's TUI layer which intercepts process.stdout and would
-		// mangle the escape sequence into visible ANSI garbage.
-		const { openSync, writeSync, closeSync } = require("fs") as typeof import("fs");
-		let ttyFd = -1;
-		try {
-			ttyFd = openSync("/dev/tty", "w");
-			writeSync(ttyFd, "\x1bc");
-			closeSync(ttyFd);
-		} catch {
-			// Fallback if /dev/tty isn't available (shouldn't happen on macOS/Linux)
-			process.stdout.write("\x1bc");
-		}
-		// Pause stdin to prevent buffered input from being re-interpreted
-		// after raw mode is disabled (prevents Ctrl+D from closing parent shell).
-		process.stdin.pause();
-		if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
-			process.stdin.setRawMode(false);
-		}
-		// stty sane resets line discipline to known-good state.
-		spawnSync("stty", ["sane"], { stdio: ["inherit", "ignore", "ignore"], timeout: 2000 });
-	} catch { /* best-effort */ }
-
-	// Spawn restart script detached (survives parent exit) but with SIGHUP
-	// ignored in the script so process-group teardown doesn't kill it.
-	// detached: true puts it in its own process group; the script's signal
-	// traps ensure Ctrl+C still works once the new omegon exec's.
-	const child = spawn("sh", [script], {
-		stdio: "inherit",
-		detached: true,
-		env: process.env,
-	});
-	child.unref();
-
-	// Clean exit — the script waits for us to die before starting new omegon
-	process.exit(0);
-}
-
-/** Escape a string for POSIX shell */
-function shellEscape(s: string): string {
-	if (/^[a-zA-Z0-9_./:=-]+$/.test(s)) return s;
-	return `'${s.replace(/'/g, "'\\''")}'`;
+	const RESTART_EXIT_CODE = 75;
+	process.exit(RESTART_EXIT_CODE);
 }
 
 /** Run a command, collect stdout+stderr, resolve with exit code. */

package/extensions/chronos/chronos.ts

@@ -0,0 +1,324 @@
+/**
+ * chronos — Pure TypeScript date/time context functions
+ *
+ * Replaces chronos.sh. All functions accept an injectable `now` for deterministic testing.
+ * Output format matches the original shell script exactly for backward compatibility.
+ */
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"] as const;
+const MONTHS_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
+
+/** Format as YYYY-MM-DD */
+function ymd(d: Date): string {
+	const y = d.getFullYear();
+	const m = String(d.getMonth() + 1).padStart(2, "0");
+	const day = String(d.getDate()).padStart(2, "0");
+	return `${y}-${m}-${day}`;
+}
+
+/** Day of week name */
+function dowName(d: Date): string {
+	return DAYS[d.getDay()];
+}
+
+/** ISO day of week: 1=Monday … 7=Sunday */
+function isoDow(d: Date): number {
+	return d.getDay() === 0 ? 7 : d.getDay();
+}
+
+/** Format as "Mon D" (e.g. "Mar 18") */
+function formatShort(d: Date): string {
+	return `${MONTHS_SHORT[d.getMonth()]} ${d.getDate()}`;
+}
+
+/** Add N days to a date (returns new Date) */
+function addDays(d: Date, n: number): Date {
+	const r = new Date(d);
+	r.setDate(r.getDate() + n);
+	return r;
+}
+
+/** Add N months to a date */
+function addMonths(d: Date, n: number): Date {
+	const r = new Date(d);
+	r.setMonth(r.getMonth() + n);
+	return r;
+}
+
+/** First day of month */
+function monthStart(year: number, month: number): Date {
+	return new Date(year, month, 1);
+}
+
+/** Last day of month */
+function monthEnd(year: number, month: number): Date {
+	return new Date(year, month + 1, 0);
+}
+
+/** Build range string like "Mar 16 - Mar 20, 2026" handling year boundaries */
+function weekRange(mon: Date, fri: Date): string {
+	const monY = mon.getFullYear();
+	const friY = fri.getFullYear();
+	if (monY === friY) {
+		return `${formatShort(mon)} - ${formatShort(fri)}, ${friY}`;
+	}
+	return `${formatShort(mon)}, ${monY} - ${formatShort(fri)}, ${friY}`;
+}
+
+// ── Subcommands ──────────────────────────────────────────────────────────────
+
+export function computeWeek(now: Date = new Date()): string {
+	const dow = isoDow(now);
+	const daysSinceMon = dow - 1;
+	const currMon = addDays(now, -daysSinceMon);
+	const currFri = addDays(currMon, 4);
+	const prevMon = addDays(currMon, -7);
+	const prevFri = addDays(prevMon, 4);
+
+	return [
+		"DATE_CONTEXT:",
+		`  TODAY: ${ymd(now)} (${dowName(now)})`,
+		`  CURR_WEEK_START: ${ymd(currMon)} (Monday)`,
+		`  CURR_WEEK_END: ${ymd(currFri)} (Friday)`,
+		`  CURR_WEEK_RANGE: ${weekRange(currMon, currFri)}`,
+		`  PREV_WEEK_START: ${ymd(prevMon)} (Monday)`,
+		`  PREV_WEEK_END: ${ymd(prevFri)} (Friday)`,
+		`  PREV_WEEK_RANGE: ${weekRange(prevMon, prevFri)}`,
+	].join("\n");
+}
+
+export function computeMonth(now: Date = new Date()): string {
+	const year = now.getFullYear();
+	const month = now.getMonth();
+
+	const currStart = monthStart(year, month);
+	const currEnd = monthEnd(year, month);
+
+	const prevMonth = month === 0 ? 11 : month - 1;
+	const prevYear = month === 0 ? year - 1 : year;
+	const prevStart = monthStart(prevYear, prevMonth);
+	const prevEnd = monthEnd(prevYear, prevMonth);
+
+	return [
+		"MONTH_CONTEXT:",
+		`  TODAY: ${ymd(now)} (${dowName(now)})`,
+		`  CURR_MONTH_START: ${ymd(currStart)}`,
+		`  CURR_MONTH_END: ${ymd(currEnd)}`,
+		`  CURR_MONTH_RANGE: ${formatShort(currStart)} - ${formatShort(currEnd)}, ${year}`,
+		`  PREV_MONTH_START: ${ymd(prevStart)}`,
+		`  PREV_MONTH_END: ${ymd(prevEnd)}`,
+		`  PREV_MONTH_RANGE: ${formatShort(prevStart)}, ${prevYear} - ${formatShort(prevEnd)}, ${prevEnd.getFullYear()}`,
+	].join("\n");
+}
+
+export function computeQuarter(now: Date = new Date()): string {
+	const year = now.getFullYear();
+	const month = now.getMonth() + 1; // 1-based
+
+	const quarter = Math.ceil(month / 3);
+	const qStartMonth = (quarter - 1) * 3; // 0-based
+	const qStart = monthStart(year, qStartMonth);
+	const qEnd = monthEnd(year, qStartMonth + 2);
+
+	let fyYear: number, fyStart: string, fyEnd: string;
+	if (month >= 10) {
+		fyYear = year + 1;
+		fyStart = `${year}-10-01`;
+		fyEnd = `${fyYear}-09-30`;
+	} else {
+		fyYear = year;
+		fyStart = `${year - 1}-10-01`;
+		fyEnd = `${year}-09-30`;
+	}
+
+	const fyMonthOffset = month >= 10 ? month - 10 + 1 : month + 3;
+	const fq = Math.ceil(fyMonthOffset / 3);
+
+	return [
+		"QUARTER_CONTEXT:",
+		`  TODAY: ${ymd(now)} (${dowName(now)})`,
+		`  CALENDAR_QUARTER: Q${quarter} ${year}`,
+		`  QUARTER_START: ${ymd(qStart)}`,
+		`  QUARTER_END: ${ymd(qEnd)}`,
+		`  FISCAL_YEAR: FY${fyYear} (Oct-Sep)`,
+		`  FISCAL_QUARTER: FQ${fq}`,
+		`  FY_START: ${fyStart}`,
+		`  FY_END: ${fyEnd}`,
+	].join("\n");
+}
+
+/** Resolve a relative date expression. Throws on unrecognized expressions. */
+export function resolveRelative(expression: string, now: Date = new Date()): Date {
+	const expr = expression.trim().toLowerCase();
+
+	if (expr === "yesterday") return addDays(now, -1);
+	if (expr === "tomorrow") return addDays(now, 1);
+	if (expr === "today") return now;
+
+	// N days/weeks/months ago
+	const agoMatch = expr.match(/^(\d+)\s+(day|days|week|weeks|month|months)\s+ago$/);
+	if (agoMatch) {
+		const n = parseInt(agoMatch[1], 10);
+		const unit = agoMatch[2];
+		if (unit.startsWith("day")) return addDays(now, -n);
+		if (unit.startsWith("week")) return addDays(now, -n * 7);
+		if (unit.startsWith("month")) return addMonths(now, -n);
+	}
+
+	// N days/weeks from now / ahead / from today
+	const aheadMatch = expr.match(/^(\d+)\s+(day|days|week|weeks)\s+(from now|ahead|from today)$/);
+	if (aheadMatch) {
+		const n = parseInt(aheadMatch[1], 10);
+		const unit = aheadMatch[2];
+		if (unit.startsWith("day")) return addDays(now, n);
+		if (unit.startsWith("week")) return addDays(now, n * 7);
+	}
+
+	// next/last {weekday}
+	const dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+	const dayMatch = expr.match(/^(next|last)\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)$/);
+	if (dayMatch) {
+		const direction = dayMatch[1];
+		const targetDow = dayNames.indexOf(dayMatch[2]);
+		const currentDow = now.getDay();
+
+		if (direction === "next") {
+			let diff = targetDow - currentDow;
+			if (diff <= 0) diff += 7;
+			return addDays(now, diff);
+		} else {
+			let diff = currentDow - targetDow;
+			if (diff <= 0) diff += 7;
+			return addDays(now, -diff);
+		}
+	}
+
+	throw new Error(`Cannot parse relative expression: '${expression}'. Supported: N days/weeks/months ago, N days/weeks from now, yesterday, tomorrow, next/last {weekday}.`);
+}
+
+export function computeRelative(expression: string, now: Date = new Date()): string {
+	const resolved = resolveRelative(expression, now);
+	return [
+		"RELATIVE_DATE:",
+		`  EXPRESSION: ${expression}`,
+		`  RESOLVED: ${ymd(resolved)} (${dowName(resolved)})`,
+		`  TODAY: ${ymd(now)} (${dowName(now)})`,
+	].join("\n");
+}
+
+/** ISO 8601 week number (Thursday-based) */
+function isoWeekNumber(d: Date): { week: number; year: number } {
+	const tmp = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+	const dayNum = tmp.getUTCDay() || 7;
+	tmp.setUTCDate(tmp.getUTCDate() + 4 - dayNum);
+	const yearStart = new Date(Date.UTC(tmp.getUTCFullYear(), 0, 1));
+	const week = Math.ceil(((tmp.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+	return { week, year: tmp.getUTCFullYear() };
+}
+
+/** Day of year (1-366) */
+function dayOfYear(d: Date): number {
+	const start = new Date(d.getFullYear(), 0, 0);
+	const diff = d.getTime() - start.getTime();
+	return Math.floor(diff / 86400000);
+}
+
+export function computeIso(now: Date = new Date()): string {
+	const { week, year } = isoWeekNumber(now);
+	const wStr = String(week).padStart(2, "0");
+	const doy = String(dayOfYear(now)).padStart(3, "0");
+	const dow = isoDow(now);
+
+	return [
+		"ISO_CONTEXT:",
+		`  TODAY: ${ymd(now)} (${dowName(now)})`,
+		`  ISO_WEEK: W${wStr}`,
+		`  ISO_YEAR: ${year}`,
+		`  ISO_WEEKDATE: ${year}-W${wStr}-${dow}`,
+		`  DAY_OF_YEAR: ${doy}`,
+	].join("\n");
+}
+
+export function computeEpoch(now: Date = new Date()): string {
+	const seconds = Math.floor(now.getTime() / 1000);
+	const millis = now.getTime();
+
+	return [
+		"EPOCH_CONTEXT:",
+		`  TODAY: ${ymd(now)} (${dowName(now)})`,
+		`  UNIX_SECONDS: ${seconds}`,
+		`  UNIX_MILLIS: ${millis}`,
+	].join("\n");
+}
+
+export function computeTz(now: Date = new Date()): string {
+	const tzParts = now.toTimeString().match(/\((.+)\)/);
+	const tzAbbrev = tzParts
+		? tzParts[1].replace(/[a-z ]/g, "") || tzParts[1]
+		: Intl.DateTimeFormat(undefined, { timeZoneName: "short" }).formatToParts(now).find(p => p.type === "timeZoneName")?.value || "Unknown";
+
+	const offsetMin = now.getTimezoneOffset();
+	const sign = offsetMin <= 0 ? "+" : "-";
+	const absMin = Math.abs(offsetMin);
+	const hh = String(Math.floor(absMin / 60)).padStart(2, "0");
+	const mm = String(absMin % 60).padStart(2, "0");
+	const utcOffset = `${sign}${hh}${mm}`;
+
+	return [
+		"TIMEZONE_CONTEXT:",
+		`  TODAY: ${ymd(now)} (${dowName(now)})`,
+		`  TIMEZONE: ${tzAbbrev}`,
+		`  UTC_OFFSET: ${utcOffset}`,
+	].join("\n");
+}
+
+export function computeRange(fromDate: string, toDate: string): string {
+	const dateRe = /^\d{4}-\d{2}-\d{2}$/;
+	if (!dateRe.test(fromDate)) throw new Error(`Invalid date format '${fromDate}'. Use YYYY-MM-DD.`);
+	if (!dateRe.test(toDate)) throw new Error(`Invalid date format '${toDate}'. Use YYYY-MM-DD.`);
+
+	const d1 = new Date(fromDate + "T00:00:00");
+	const d2 = new Date(toDate + "T00:00:00");
+
+	if (isNaN(d1.getTime())) throw new Error(`Could not parse date: ${fromDate}`);
+	if (isNaN(d2.getTime())) throw new Error(`Could not parse date: ${toDate}`);
+
+	const diffMs = d2.getTime() - d1.getTime();
+	const calendarDays = Math.round(diffMs / 86400000);
+	const absDays = Math.abs(calendarDays);
+
+	let businessDays = 0;
+	const step = calendarDays >= 0 ? 1 : -1;
+	let cursor = new Date(d1);
+	for (let i = 0; i < absDays; i++) {
+		const dow = cursor.getDay();
+		if (dow >= 1 && dow <= 5) businessDays++;
+		cursor = addDays(cursor, step);
+	}
+
+	return [
+		"RANGE_CONTEXT:",
+		`  FROM: ${fromDate}`,
+		`  TO: ${toDate}`,
+		`  CALENDAR_DAYS: ${absDays}`,
+		`  BUSINESS_DAYS: ${businessDays}`,
+	].join("\n");
+}
+
+export function computeAll(now: Date = new Date()): string {
+	return [
+		computeWeek(now),
+		"",
+		computeMonth(now),
+		"",
+		computeQuarter(now),
+		"",
+		computeIso(now),
+		"",
+		computeEpoch(now),
+		"",
+		computeTz(now),
+	].join("\n");
+}

package/extensions/chronos/index.ts

@@ -1,35 +1,56 @@
 /**
  * chronos — Authoritative date and time context from system clock
  *
- * Registers a `chronos` tool that executes the chronos.sh script and returns
- * structured date context. Eliminates AI date calculation errors by providing
- * an authoritative source of truth from the system clock.
- *
- * Also registers a `/chronos` command for interactive use.
+ * Pure TypeScript implementation — no shell dependencies.
+ * Registers a `chronos` tool and `/chronos` command.
  *
  * Subcommands: week (default), month, quarter, relative, iso, epoch, tz, range, all
  */
 
-import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { StringEnum } from "../lib/typebox-helpers";
 import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-
-const CHRONOS_SH = join(import.meta.dirname ?? __dirname, "chronos.sh");
+import {
+	computeWeek,
+	computeMonth,
+	computeQuarter,
+	computeRelative,
+	computeIso,
+	computeEpoch,
+	computeTz,
+	computeRange,
+	computeAll,
+} from "./chronos";
 
 const SUBCOMMANDS = ["week", "month", "quarter", "relative", "iso", "epoch", "tz", "range", "all"] as const;
 
-export default function chronosExtension(pi: ExtensionAPI) {
+function executeChronos(params: { subcommand?: string; expression?: string; from_date?: string; to_date?: string }): string {
+	const sub = params.subcommand || "week";
 
-	// Ensure the script exists and is executable
-	if (!existsSync(CHRONOS_SH)) {
-		// Fail silently at load — the tool will report the error at call time
+	switch (sub) {
+		case "week": return computeWeek();
+		case "month": return computeMonth();
+		case "quarter": return computeQuarter();
+		case "relative":
+			if (!params.expression) {
+				throw new Error("The 'relative' subcommand requires an 'expression' parameter (e.g. '3 days ago').");
+			}
+			return computeRelative(params.expression);
+		case "iso": return computeIso();
+		case "epoch": return computeEpoch();
+		case "tz": return computeTz();
+		case "range":
+			if (!params.from_date || !params.to_date) {
+				throw new Error("The 'range' subcommand requires both 'from_date' and 'to_date' (YYYY-MM-DD).");
+			}
+			return computeRange(params.from_date, params.to_date);
+		case "all": return computeAll();
+		default: throw new Error(`Unknown subcommand: ${sub}`);
 	}
+}
+
+export default function chronosExtension(pi: ExtensionAPI) {
 
-	// ------------------------------------------------------------------
-	// chronos tool — callable by the LLM
-	// ------------------------------------------------------------------
 	pi.registerTool({
 		name: "chronos",
 		label: "Chronos",
@@ -68,45 +89,15 @@ export default function chronosExtension(pi: ExtensionAPI) {
 			),
 		}),
 
-		async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
-			if (!existsSync(CHRONOS_SH)) {
-				throw new Error(
-					`chronos.sh not found at ${CHRONOS_SH}. ` +
-					`Expected alongside the chronos skill.`
-				);
-			}
-
-			const sub = params.subcommand || "week";
-			const args = [CHRONOS_SH, sub];
-
-			if (sub === "relative") {
-				if (!params.expression) {
-					throw new Error("The 'relative' subcommand requires an 'expression' parameter (e.g. '3 days ago').");
-				}
-				args.push(params.expression);
-			} else if (sub === "range") {
-				if (!params.from_date || !params.to_date) {
-					throw new Error("The 'range' subcommand requires both 'from_date' and 'to_date' (YYYY-MM-DD).");
-				}
-				args.push(params.from_date, params.to_date);
-			}
-
-			const result = await pi.exec("bash", args, { signal, timeout: 10_000 });
-
-			if (result.code !== 0) {
-				throw new Error(`chronos.sh failed (exit ${result.code}):\n${result.stderr || result.stdout}`);
-			}
-
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const result = executeChronos(params);
 			return {
-				content: [{ type: "text", text: result.stdout.trim() }],
-				details: { subcommand: sub },
+				content: [{ type: "text", text: result }],
+				details: { subcommand: params.subcommand || "week" },
 			};
 		},
 	});
 
-	// ------------------------------------------------------------------
-	// /chronos command — interactive shortcut
-	// ------------------------------------------------------------------
 	pi.registerCommand("chronos", {
 		description: "Show date/time context (usage: /chronos [week|month|quarter|iso|epoch|tz|all])",
 		getArgumentCompletions: (prefix: string) => {
@@ -116,33 +107,21 @@ export default function chronosExtension(pi: ExtensionAPI) {
 		},
 		handler: async (args, _ctx) => {
 			const sub = (args || "").trim() || "week";
-
-			if (!existsSync(CHRONOS_SH)) {
+			try {
+				const result = executeChronos({ subcommand: sub });
 				pi.sendMessage({
 					customType: "view",
-					content: `❌ chronos.sh not found at \`${CHRONOS_SH}\``,
+					content: `**Chronos**\n\n\`\`\`\n${result}\n\`\`\``,
 					display: true,
 				});
-				return;
-			}
-
-			const cliArgs = [CHRONOS_SH, sub];
-			const result = await pi.exec("bash", cliArgs, { timeout: 10_000 });
-
-			if (result.code !== 0) {
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
 				pi.sendMessage({
 					customType: "view",
-					content: `❌ chronos.sh failed:\n\`\`\`\n${result.stderr || result.stdout}\n\`\`\``,
+					content: `❌ ${msg}`,
 					display: true,
 				});
-				return;
 			}
-
-			pi.sendMessage({
-				customType: "view",
-				content: `**Chronos**\n\n\`\`\`\n${result.stdout.trim()}\n\`\`\``,
-				display: true,
-			});
 		},
 	});
 }

package/extensions/cleave/dispatcher.ts

@@ -41,6 +41,20 @@ import { registerCleaveProc, deregisterCleaveProc, killCleaveProc } from "./subp
  */
 export const LARGE_RUN_THRESHOLD = 4;
 
+/**
+ * Default per-child wall-clock timeout (15 minutes).
+ * Hard backstop — children that exceed this are killed regardless of activity.
+ */
+export const DEFAULT_CHILD_TIMEOUT_MS = 15 * 60 * 1000;
+
+/**
+ * Default RPC idle timeout (3 minutes).
+ * If no RPC event arrives within this window, the child is considered stalled
+ * and is killed. Resets on every event (tool_start, tool_end, assistant_message,
+ * etc.). Only applies to RPC mode — pipe mode children use wall-clock only.
+ */
+export const IDLE_TIMEOUT_MS = 3 * 60 * 1000;
+
 // ─── Explicit model resolution ──────────────────────────────────────────────
 
 /**
@@ -505,6 +519,7 @@ async function spawnChildRpc(
 	signal?: AbortSignal,
 	localModel?: string,
 	onEvent?: (event: RpcChildEvent) => void,
+	idleTimeoutMs: number = IDLE_TIMEOUT_MS,
 ): Promise<RpcChildResult> {
 	const omegon = resolveOmegonSubprocess();
 	const args = [...omegon.argvPrefix, "--mode", "rpc", "--no-session"];
@@ -540,6 +555,25 @@ async function spawnChildRpc(
 		// Collect stderr
 		proc.stderr?.on("data", (data) => { stderr += data.toString(); });
 
+		// ── Idle timeout ─────────────────────────────────────────────────
+		// Reset on every RPC event. If no event arrives within the idle
+		// window, the child is stalled — kill it.
+		let idleKilled = false;
+		let idleTimer: ReturnType<typeof setTimeout> | undefined;
+		const resetIdleTimer = () => {
+			if (idleTimer) clearTimeout(idleTimer);
+			if (idleTimeoutMs > 0) {
+				idleTimer = setTimeout(() => {
+					if (!killed && !proc.killed) {
+						idleKilled = true;
+						killed = true;
+						killCleaveProc(proc);
+						scheduleEscalation();
+					}
+				}, idleTimeoutMs);
+			}
+		};
+
 		// Parse stdout exclusively via RPC event stream (no competing data listener)
 		let eventsFinished: Promise<void> = Promise.resolve();
 		if (proc.stdout) {
@@ -547,6 +581,7 @@ async function spawnChildRpc(
 				try {
 					for await (const event of parseRpcEventStream(proc.stdout!)) {
 						events.push(event);
+						resetIdleTimer(); // activity — push back the idle deadline
 						if (event.type === "pipe_closed") {
 							pipeBroken = true;
 						}
@@ -572,6 +607,10 @@ async function spawnChildRpc(
 			}, 5_000);
 		};
 
+		// Start the idle timer now — if the child never emits an event, it's
+		// caught within the idle window rather than waiting for the full wall clock.
+		resetIdleTimer();
+
 		const timer = setTimeout(() => {
 			killed = true;
 			killCleaveProc(proc);
@@ -592,6 +631,7 @@ async function spawnChildRpc(
 			deregisterCleaveProc(proc);
 			clearTimeout(timer);
 			clearTimeout(escalationTimer);
+			clearTimeout(idleTimer);
 			signal?.removeEventListener("abort", onAbort);
 
 			// Close stdin if still open (child has exited)
@@ -600,10 +640,16 @@ async function spawnChildRpc(
 			// Wait for all RPC events to be consumed before resolving
 			await eventsFinished;
 
+			const killReason = idleKilled
+				? `Killed (idle — no RPC events for ${Math.round(idleTimeoutMs / 1000)}s)\n${stderr}`
+				: killed
+					? `Killed (timeout or abort)\n${stderr}`
+					: stderr;
+
 			resolve({
 				exitCode: killed ? -1 : (code ?? 1),
 				stdout: "",
-				stderr: killed ? `Killed (timeout or abort)\n${stderr}` : stderr,
+				stderr: killReason,
 				events,
 				pipeBroken,
 			});
@@ -615,6 +661,7 @@ async function spawnChildRpc(
 			deregisterCleaveProc(proc);
 			clearTimeout(timer);
 			clearTimeout(escalationTimer);
+			clearTimeout(idleTimer);
 			signal?.removeEventListener("abort", onAbort);
 			resolve({
 				exitCode: 1,

package/extensions/cleave/index.ts

@@ -51,7 +51,7 @@ import {
 } from "./assessment.ts";
 import { detectConflicts, parseTaskResult } from "./conflicts.ts";
 import { emitResolvedBugCandidate } from "./lifecycle-emitter.ts";
-import { dispatchChildren, resolveExecuteModel } from "./dispatcher.ts";
+import { DEFAULT_CHILD_TIMEOUT_MS, dispatchChildren, resolveExecuteModel } from "./dispatcher.ts";
 import { DEFAULT_REVIEW_CONFIG, type ReviewConfig } from "./review.ts";
 import {
 	detectOpenSpec,
@@ -2144,7 +2144,7 @@ export default function cleaveExtension(pi: ExtensionAPI) {
 					pi,
 					state,
 					4, // maxParallel
-					120 * 60 * 1000,
+					DEFAULT_CHILD_TIMEOUT_MS,
 					undefined,
 					signal,
 					(msg) => emit(msg),
@@ -2581,7 +2581,7 @@ export default function cleaveExtension(pi: ExtensionAPI) {
 				pi,
 				state,
 				maxParallel,
-				120 * 60 * 1000, // 2 hour timeout per child
+				DEFAULT_CHILD_TIMEOUT_MS,
 				localModel,
 				signal ?? undefined,
 				(msg) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.10.2",
+	"version": "0.10.4",
 	"description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
 	"bin": {
 		"omegon": "bin/omegon.mjs",

package/extensions/chronos/chronos.sh

@@ -1,487 +0,0 @@
-#!/bin/bash
-# chronos.sh - Comprehensive date and time context
-# Outputs structured date context to eliminate AI date calculation errors
-# Cross-platform: macOS (BSD date) and Linux (GNU date)
-
-set -uo pipefail
-
-# Detect date command flavor
-if date --version >/dev/null 2>&1; then
-  DATE_FLAVOR="gnu"
-else
-  DATE_FLAVOR="bsd"
-fi
-
-# Helper: add/subtract days from a date
-# Usage: date_add "2026-01-25" -3  -> outputs date 3 days earlier
-date_add() {
-  local base_date=$1
-  local days=$2
-  if [[ "$DATE_FLAVOR" == "gnu" ]]; then
-    date -d "$base_date $days days" "+%Y-%m-%d"
-  else
-    # BSD date: convert to epoch, add seconds, convert back
-    local epoch=$(date -j -f "%Y-%m-%d" "$base_date" "+%s" 2>/dev/null)
-    local new_epoch=$((epoch + days * 86400))
-    date -r "$new_epoch" "+%Y-%m-%d"
-  fi
-}
-
-# Helper: format date as "Mon D"
-format_short() {
-  local ymd=$1
-  local month=$(echo "$ymd" | cut -d'-' -f2)
-  local day=$(echo "$ymd" | cut -d'-' -f3 | sed 's/^0//')
-  case $month in
-    01) mon="Jan" ;; 02) mon="Feb" ;; 03) mon="Mar" ;;
-    04) mon="Apr" ;; 05) mon="May" ;; 06) mon="Jun" ;;
-    07) mon="Jul" ;; 08) mon="Aug" ;; 09) mon="Sep" ;;
-    10) mon="Oct" ;; 11) mon="Nov" ;; 12) mon="Dec" ;;
-  esac
-  echo "$mon $day"
-}
-
-# Helper: get epoch from date string
-date_to_epoch() {
-  local ymd=$1
-  if [[ "$DATE_FLAVOR" == "gnu" ]]; then
-    date -d "$ymd" "+%s"
-  else
-    date -j -f "%Y-%m-%d" "$ymd" "+%s" 2>/dev/null
-  fi
-}
-
-# Helper: resolve a relative date expression
-resolve_relative() {
-  local expr=$1
-  if [[ "$DATE_FLAVOR" == "gnu" ]]; then
-    date -d "$expr" "+%Y-%m-%d" 2>/dev/null
-  else
-    # BSD: handle common expressions manually
-    case "$expr" in
-      *"days ago")
-        local n=$(echo "$expr" | grep -oE '[0-9]+')
-        date_add "$TODAY" "-$n"
-        ;;
-      *"days from now"|*"days ahead")
-        local n=$(echo "$expr" | grep -oE '[0-9]+')
-        date_add "$TODAY" "$n"
-        ;;
-      "yesterday")
-        date_add "$TODAY" "-1"
-        ;;
-      "tomorrow")
-        date_add "$TODAY" "1"
-        ;;
-      "next Monday"|"next monday")
-        local days_ahead=$(( (8 - DOW_NUM) % 7 ))
-        [[ $days_ahead -eq 0 ]] && days_ahead=7
-        date_add "$TODAY" "$days_ahead"
-        ;;
-      "next Friday"|"next friday")
-        local target=5
-        local days_ahead=$(( (target - DOW_NUM + 7) % 7 ))
-        [[ $days_ahead -eq 0 ]] && days_ahead=7
-        date_add "$TODAY" "$days_ahead"
-        ;;
-      "last Monday"|"last monday")
-        local days_back=$(( (DOW_NUM - 1 + 7) % 7 ))
-        [[ $days_back -eq 0 ]] && days_back=7
-        date_add "$TODAY" "-$days_back"
-        ;;
-      "last Friday"|"last friday")
-        local target=5
-        local days_back=$(( (DOW_NUM - target + 7) % 7 ))
-        [[ $days_back -eq 0 ]] && days_back=7
-        date_add "$TODAY" "-$days_back"
-        ;;
-      *"weeks ago")
-        local n=$(echo "$expr" | grep -oE '[0-9]+')
-        date_add "$TODAY" "-$((n * 7))"
-        ;;
-      *"months ago")
-        local n=$(echo "$expr" | grep -oE '[0-9]+')
-        local y=$(echo "$TODAY" | cut -d'-' -f1)
-        local m=$(echo "$TODAY" | cut -d'-' -f2 | sed 's/^0//')
-        local d=$(echo "$TODAY" | cut -d'-' -f3)
-        m=$((m - n))
-        while [[ $m -le 0 ]]; do
-          m=$((m + 12))
-          y=$((y - 1))
-        done
-        printf "%04d-%02d-%s" "$y" "$m" "$d"
-        ;;
-      *)
-        echo "ERROR: Cannot parse '$expr' on BSD date. Use GNU date for complex expressions." >&2
-        return 1
-        ;;
-    esac
-  fi
-}
-
-# Get today's info
-TODAY=$(date "+%Y-%m-%d")
-TODAY_DOW=$(date "+%A")
-DOW_NUM=$(date "+%u")  # 1=Monday, 7=Sunday
-
-# ---- Subcommand functions ----
-
-compute_week() {
-  DAYS_SINCE_MON=$((DOW_NUM - 1))
-  CURR_MON=$(date_add "$TODAY" "-$DAYS_SINCE_MON")
-  CURR_FRI=$(date_add "$CURR_MON" "4")
-
-  PREV_MON=$(date_add "$CURR_MON" "-7")
-  PREV_FRI=$(date_add "$PREV_MON" "4")
-
-  # Extract years for range formatting
-  CURR_MON_YEAR=$(echo "$CURR_MON" | cut -d'-' -f1)
-  CURR_FRI_YEAR=$(echo "$CURR_FRI" | cut -d'-' -f1)
-  PREV_MON_YEAR=$(echo "$PREV_MON" | cut -d'-' -f1)
-  PREV_FRI_YEAR=$(echo "$PREV_FRI" | cut -d'-' -f1)
-
-  # Format short dates
-  CURR_MON_FMT=$(format_short "$CURR_MON")
-  CURR_FRI_FMT=$(format_short "$CURR_FRI")
-  PREV_MON_FMT=$(format_short "$PREV_MON")
-  PREV_FRI_FMT=$(format_short "$PREV_FRI")
-
-  # Build range strings (handle year boundaries)
-  if [ "$CURR_MON_YEAR" = "$CURR_FRI_YEAR" ]; then
-    CURR_WEEK_RANGE="$CURR_MON_FMT - $CURR_FRI_FMT, $CURR_FRI_YEAR"
-  else
-    CURR_WEEK_RANGE="$CURR_MON_FMT, $CURR_MON_YEAR - $CURR_FRI_FMT, $CURR_FRI_YEAR"
-  fi
-
-  if [ "$PREV_MON_YEAR" = "$PREV_FRI_YEAR" ]; then
-    PREV_WEEK_RANGE="$PREV_MON_FMT - $PREV_FRI_FMT, $PREV_FRI_YEAR"
-  else
-    PREV_WEEK_RANGE="$PREV_MON_FMT, $PREV_MON_YEAR - $PREV_FRI_FMT, $PREV_FRI_YEAR"
-  fi
-
-  echo "DATE_CONTEXT:"
-  echo "  TODAY: $TODAY ($TODAY_DOW)"
-  echo "  CURR_WEEK_START: $CURR_MON (Monday)"
-  echo "  CURR_WEEK_END: $CURR_FRI (Friday)"
-  echo "  CURR_WEEK_RANGE: $CURR_WEEK_RANGE"
-  echo "  PREV_WEEK_START: $PREV_MON (Monday)"
-  echo "  PREV_WEEK_END: $PREV_FRI (Friday)"
-  echo "  PREV_WEEK_RANGE: $PREV_WEEK_RANGE"
-}
-
-compute_month() {
-  local year=$(echo "$TODAY" | cut -d'-' -f1)
-  local month=$(echo "$TODAY" | cut -d'-' -f2 | sed 's/^0//')
-
-  # Current month boundaries
-  local curr_month_start
-  curr_month_start=$(printf "%04d-%02d-01" "$year" "$month")
-
-  # Next month first day, then subtract 1 day for end of current month
-  local next_month=$((month + 1))
-  local next_year=$year
-  if [[ $next_month -gt 12 ]]; then
-    next_month=1
-    next_year=$((year + 1))
-  fi
-  local next_month_start
-  next_month_start=$(printf "%04d-%02d-01" "$next_year" "$next_month")
-  local curr_month_end
-  curr_month_end=$(date_add "$next_month_start" "-1")
-
-  # Previous month boundaries
-  local prev_month=$((month - 1))
-  local prev_year=$year
-  if [[ $prev_month -lt 1 ]]; then
-    prev_month=12
-    prev_year=$((year - 1))
-  fi
-  local prev_month_start
-  prev_month_start=$(printf "%04d-%02d-01" "$prev_year" "$prev_month")
-  local prev_month_end
-  prev_month_end=$(date_add "$curr_month_start" "-1")
-
-  local curr_month_fmt
-  curr_month_fmt=$(format_short "$curr_month_start")
-  local curr_month_end_fmt
-  curr_month_end_fmt=$(format_short "$curr_month_end")
-  local prev_month_fmt
-  prev_month_fmt=$(format_short "$prev_month_start")
-  local prev_month_end_fmt
-  prev_month_end_fmt=$(format_short "$prev_month_end")
-
-  echo "MONTH_CONTEXT:"
-  echo "  TODAY: $TODAY ($TODAY_DOW)"
-  echo "  CURR_MONTH_START: $curr_month_start"
-  echo "  CURR_MONTH_END: $curr_month_end"
-  echo "  CURR_MONTH_RANGE: $curr_month_fmt - $curr_month_end_fmt, $year"
-  echo "  PREV_MONTH_START: $prev_month_start"
-  echo "  PREV_MONTH_END: $prev_month_end"
-  echo "  PREV_MONTH_RANGE: $prev_month_fmt, $prev_year - $prev_month_end_fmt, $year"
-}
-
-compute_quarter() {
-  local year=$(echo "$TODAY" | cut -d'-' -f1)
-  local month=$(echo "$TODAY" | cut -d'-' -f2 | sed 's/^0//')
-
-  # Calendar quarter (Q1=Jan-Mar, Q2=Apr-Jun, Q3=Jul-Sep, Q4=Oct-Dec)
-  local quarter=$(( (month - 1) / 3 + 1 ))
-  local q_start_month=$(( (quarter - 1) * 3 + 1 ))
-  local q_end_month=$(( quarter * 3 ))
-  local q_start
-  q_start=$(printf "%04d-%02d-01" "$year" "$q_start_month")
-
-  # Quarter end: first day of next quarter minus 1
-  local next_q_month=$(( q_end_month + 1 ))
-  local next_q_year=$year
-  if [[ $next_q_month -gt 12 ]]; then
-    next_q_month=1
-    next_q_year=$((year + 1))
-  fi
-  local next_q_start
-  next_q_start=$(printf "%04d-%02d-01" "$next_q_year" "$next_q_month")
-  local q_end
-  q_end=$(date_add "$next_q_start" "-1")
-
-  # Fiscal year (Oct-Sep): FY starts in October of previous calendar year
-  local fy_year
-  local fy_start fy_end
-  if [[ $month -ge 10 ]]; then
-    fy_year=$((year + 1))
-    fy_start="$year-10-01"
-    fy_end="$fy_year-09-30"
-  else
-    fy_year=$year
-    fy_start="$((year - 1))-10-01"
-    fy_end="$year-09-30"
-  fi
-
-  # Fiscal quarter
-  local fy_month_offset
-  if [[ $month -ge 10 ]]; then
-    fy_month_offset=$((month - 10 + 1))
-  else
-    fy_month_offset=$((month + 3))
-  fi
-  local fq=$(( (fy_month_offset - 1) / 3 + 1 ))
-
-  echo "QUARTER_CONTEXT:"
-  echo "  TODAY: $TODAY ($TODAY_DOW)"
-  echo "  CALENDAR_QUARTER: Q$quarter $year"
-  echo "  QUARTER_START: $q_start"
-  echo "  QUARTER_END: $q_end"
-  echo "  FISCAL_YEAR: FY$fy_year (Oct-Sep)"
-  echo "  FISCAL_QUARTER: FQ$fq"
-  echo "  FY_START: $fy_start"
-  echo "  FY_END: $fy_end"
-}
-
-compute_relative() {
-  local expr=$1
-  local resolved
-  resolved=$(resolve_relative "$expr")
-  if [[ $? -ne 0 || -z "$resolved" ]]; then
-    echo "RELATIVE_DATE:"
-    echo "  ERROR: Could not resolve '$expr'"
-    return 1
-  fi
-
-  local resolved_dow
-  if [[ "$DATE_FLAVOR" == "gnu" ]]; then
-    resolved_dow=$(date -d "$resolved" "+%A")
-  else
-    local epoch=$(date_to_epoch "$resolved")
-    resolved_dow=$(date -r "$epoch" "+%A")
-  fi
-
-  echo "RELATIVE_DATE:"
-  echo "  EXPRESSION: $expr"
-  echo "  RESOLVED: $resolved ($resolved_dow)"
-  echo "  TODAY: $TODAY ($TODAY_DOW)"
-}
-
-compute_iso() {
-  local iso_week iso_year day_of_year
-  if [[ "$DATE_FLAVOR" == "gnu" ]]; then
-    iso_week=$(date -d "$TODAY" "+%V")
-    iso_year=$(date -d "$TODAY" "+%G")
-    day_of_year=$(date -d "$TODAY" "+%j")
-  else
-    iso_week=$(date -j -f "%Y-%m-%d" "$TODAY" "+%V" 2>/dev/null)
-    iso_year=$(date -j -f "%Y-%m-%d" "$TODAY" "+%G" 2>/dev/null || echo "$TODAY" | cut -d'-' -f1)
-    day_of_year=$(date -j -f "%Y-%m-%d" "$TODAY" "+%j" 2>/dev/null)
-  fi
-
-  echo "ISO_CONTEXT:"
-  echo "  TODAY: $TODAY ($TODAY_DOW)"
-  echo "  ISO_WEEK: W$iso_week"
-  echo "  ISO_YEAR: $iso_year"
-  echo "  ISO_WEEKDATE: $iso_year-W$iso_week-$DOW_NUM"
-  echo "  DAY_OF_YEAR: $day_of_year"
-}
-
-compute_epoch() {
-  local epoch
-  if [[ "$DATE_FLAVOR" == "gnu" ]]; then
-    epoch=$(date "+%s")
-  else
-    epoch=$(date "+%s")
-  fi
-  local millis="${epoch}000"
-
-  echo "EPOCH_CONTEXT:"
-  echo "  TODAY: $TODAY ($TODAY_DOW)"
-  echo "  UNIX_SECONDS: $epoch"
-  echo "  UNIX_MILLIS: $millis"
-}
-
-compute_tz() {
-  local tz_abbrev tz_offset
-  tz_abbrev=$(date "+%Z")
-  tz_offset=$(date "+%z")
-
-  echo "TIMEZONE_CONTEXT:"
-  echo "  TODAY: $TODAY ($TODAY_DOW)"
-  echo "  TIMEZONE: $tz_abbrev"
-  echo "  UTC_OFFSET: $tz_offset"
-}
-
-compute_range() {
-  local date1=$1
-  local date2=$2
-
-  # Validate date formats
-  if ! echo "$date1" | grep -qE '^[0-9]{4}-[0-9]{2}-[0-9]{2}$'; then
-    echo "RANGE_ERROR: Invalid date format '$date1'. Use YYYY-MM-DD." >&2
-    return 1
-  fi
-  if ! echo "$date2" | grep -qE '^[0-9]{4}-[0-9]{2}-[0-9]{2}$'; then
-    echo "RANGE_ERROR: Invalid date format '$date2'. Use YYYY-MM-DD." >&2
-    return 1
-  fi
-
-  local epoch1 epoch2
-  epoch1=$(date_to_epoch "$date1")
-  epoch2=$(date_to_epoch "$date2")
-
-  if [[ -z "$epoch1" || -z "$epoch2" ]]; then
-    echo "RANGE_ERROR: Could not parse dates." >&2
-    return 1
-  fi
-
-  local diff_seconds=$((epoch2 - epoch1))
-  local calendar_days=$((diff_seconds / 86400))
-
-  # Count business days (Mon-Fri)
-  local business_days=0
-  local current="$date1"
-  local step=1
-  if [[ $calendar_days -lt 0 ]]; then
-    step=-1
-    calendar_days=$(( -calendar_days ))
-  fi
-
-  local i=0
-  while [[ $i -lt $calendar_days ]]; do
-    local dow
-    if [[ "$DATE_FLAVOR" == "gnu" ]]; then
-      dow=$(date -d "$current" "+%u")
-    else
-      local e=$(date_to_epoch "$current")
-      dow=$(date -r "$e" "+%u")
-    fi
-    # Count if weekday (Mon=1 through Fri=5)
-    if [[ $dow -ge 1 && $dow -le 5 ]]; then
-      business_days=$((business_days + 1))
-    fi
-    current=$(date_add "$current" "$step")
-    i=$((i + 1))
-  done
-
-  echo "RANGE_CONTEXT:"
-  echo "  FROM: $date1"
-  echo "  TO: $date2"
-  echo "  CALENDAR_DAYS: $calendar_days"
-  echo "  BUSINESS_DAYS: $business_days"
-}
-
-usage() {
-  echo "Usage: chronos.sh [SUBCOMMAND] [ARGS]"
-  echo ""
-  echo "Subcommands:"
-  echo "  (none), week     Week boundaries (DATE_CONTEXT block)"
-  echo "  month            Current/previous month boundaries"
-  echo "  quarter          Calendar quarter, fiscal year (Oct-Sep)"
-  echo "  relative \"expr\"  Resolve relative date expression"
-  echo "  iso              ISO week number, year, day-of-year"
-  echo "  epoch            Unix timestamp (seconds and milliseconds)"
-  echo "  tz               Timezone abbreviation and UTC offset"
-  echo "  range D1 D2      Calendar and business days between dates"
-  echo "  all              All of the above combined"
-  echo ""
-  echo "Examples:"
-  echo "  chronos.sh                        # Week context (default)"
-  echo "  chronos.sh month                  # Month boundaries"
-  echo "  chronos.sh quarter                # Quarter and fiscal year"
-  echo "  chronos.sh relative \"3 days ago\"  # Resolve expression"
-  echo "  chronos.sh range 2026-01-01 2026-02-01"
-  echo "  chronos.sh all                    # Everything"
-}
-
-# ---- Main dispatch ----
-
-case "${1:-week}" in
-  -h|--help)
-    usage
-    ;;
-  week|"")
-    compute_week
-    ;;
-  month)
-    compute_month
-    ;;
-  quarter)
-    compute_quarter
-    ;;
-  relative)
-    if [[ -z "${2:-}" ]]; then
-      echo "Usage: chronos.sh relative \"expression\"" >&2
-      exit 1
-    fi
-    compute_relative "$2"
-    ;;
-  iso)
-    compute_iso
-    ;;
-  epoch)
-    compute_epoch
-    ;;
-  tz)
-    compute_tz
-    ;;
-  range)
-    if [[ -z "${2:-}" || -z "${3:-}" ]]; then
-      echo "Usage: chronos.sh range YYYY-MM-DD YYYY-MM-DD" >&2
-      exit 1
-    fi
-    compute_range "$2" "$3"
-    ;;
-  all)
-    compute_week
-    echo ""
-    compute_month
-    echo ""
-    compute_quarter
-    echo ""
-    compute_iso
-    echo ""
-    compute_epoch
-    echo ""
-    compute_tz
-    ;;
-  *)
-    echo "Unknown subcommand: $1" >&2
-    usage >&2
-    exit 1
-    ;;
-esac