@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/session/session-staging-paths.ts

@@ -0,0 +1,8 @@
+import * as path from "node:path";
+
+export const SESSION_STAGING_DIRNAME = ".staging" as const;
+
+/** True when a path is an immediate child of the reserved session staging directory. */
+export function isStagedSessionPath(filePath: string): boolean {
+	return path.basename(path.dirname(path.resolve(filePath))) === SESSION_STAGING_DIRNAME;
+}

package/src/setup/hermes/templates/operator-instructions.v1.md

@@ -21,7 +21,6 @@ When the goal is to hand GJC a whole workflow rather than micro-manage one promp
 
 - `gjc_delegate_plan` — run consensus planning (`/skill:ralplan`) to a pending-approval plan.
 - `gjc_delegate_execute` — run execution (`/skill:ultragoal`) to completion with verification.
-- `gjc_delegate_team` — run parallel team execution (`/skill:team`) with internal tmux workers.
 
 Each delegate starts (or reuses) a session, sends one workflow-tagged turn, and returns a durable `turn_id`. Pass `cwd` and `task`; set `allow_mutation: true` only when the bridge startup mutation class is enabled and the user has approved changes. Poll the returned `turn_id` with `{{TOOL_PREFIX}}_await_turn` or watch for the `delegation.started` event, exactly as with `send_prompt`. Drop to the manual start/send tools only for fine-grained control the delegate tools do not cover.
 

package/src/setup/host-plugin-setup.ts

@@ -78,7 +78,7 @@ export function buildHostPluginSetup(host: HostPluginKind, flags: HostPluginSetu
 			installGuidance: [
 				`Add the local marketplace: /plugin marketplace add ${marketplaceRoot}`,
 				"Install the plugin: /plugin install gajae-code",
-				"Then call gjc_delegate_plan / gjc_delegate_execute / gjc_delegate_team from Claude Code.",
+				"Then call gjc_delegate_plan / gjc_delegate_execute from Claude Code.",
 			],
 			coordinatorConfigPreview: { command: "gjc", args: ["mcp-serve", "coordinator"], env },
 			mutationPolicy:
@@ -104,7 +104,7 @@ export function buildHostPluginSetup(host: HostPluginKind, flags: HostPluginSetu
 		installGuidance: [
 			`Add the local marketplace: codex plugin marketplace add ${marketplaceRoot}`,
 			"Install the plugin: codex plugin add gajae-code@gajae-code-local",
-			"Then call gjc_delegate_plan / gjc_delegate_execute / gjc_delegate_team from Codex.",
+			"Then call gjc_delegate_plan / gjc_delegate_execute from Codex.",
 		],
 		coordinatorConfigPreview: { command: "gjc", args: ["mcp-serve", "coordinator"], env },
 		mutationPolicy:

package/src/skill-state/active-state.ts

@@ -351,7 +351,7 @@ export function isCanonicalGjcWorkflowSkill(skill: string): skill is CanonicalGj
  * rather than a generic synthetic compaction continuation.
  */
 const CONTINUATION_INERT_WORKFLOW_PHASES: Readonly<Partial<Record<CanonicalGjcWorkflowSkill, ReadonlySet<string>>>> = {
-	team: new Set(["awaiting_integration"]),
+	autoresearch: new Set(["verdict"]),
 };
 
 /**
@@ -624,7 +624,7 @@ function dedupeVisibleBySkill(entries: SkillActiveEntry[], sessionId?: string):
  * The planning pipeline advances one stage at a time: `deep-interview →
  * ralplan → ultragoal`. Activating a downstream stage supersedes upstream
  * stages so stale rows cannot keep owning the HUD, gate, or primary active
- * snapshot. `team` is intentionally excluded — it runs alongside ultragoal —
+ * snapshot. `autoresearch` is intentionally excluded — it runs alongside ultragoal —
  * and every non-pipeline skill is left untouched.
  */
 const PLANNING_PIPELINE_SKILLS = new Set<string>(["deep-interview", "ralplan", "ultragoal"]);

package/src/skill-state/canonical-skills.ts

@@ -1,4 +1,4 @@
 /** Native-free canonical GJC workflow skill identifiers. */
-export const CANONICAL_GJC_WORKFLOW_SKILLS = ["deep-interview", "ralplan", "ultragoal", "team"] as const;
+export const CANONICAL_GJC_WORKFLOW_SKILLS = ["deep-interview", "ralplan", "ultragoal", "autoresearch"] as const;
 
 export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];

package/src/skill-state/initial-phase.ts

@@ -14,6 +14,6 @@ export function initialPhaseForSkill(skill: CanonicalGjcWorkflowSkill | string):
 	if (skill === "deep-interview") return "interviewing";
 	if (skill === "ultragoal") return "goal-planning";
 	if (skill === "ralplan") return "planner";
-	if (skill === "team") return "starting";
+	if (skill === "autoresearch") return "intake";
 	return "planning";
 }

package/src/skill-state/workflow-hud.ts

@@ -53,21 +53,6 @@ interface UltragoalHudState extends WorkflowGateHudState {
 	updatedAt?: string;
 }
 
-interface TeamHudWorker {
-	id: string;
-	status?: string;
-}
-
-interface TeamHudState extends WorkflowGateHudState {
-	phase: string;
-	task_total: number;
-	task_counts: Record<string, number>;
-	workers: TeamHudWorker[];
-	updated_at?: string;
-	latestEvent?: { type?: string; worker?: string; message?: string };
-	latestMessage?: { from_worker?: string; body?: string };
-}
-
 function percent(value: number | undefined): string | undefined {
 	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
 	return `${Math.round(value * 100)}%`;
@@ -263,6 +248,47 @@ export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSumma
 	};
 }
 
+export interface AutoresearchHudState extends WorkflowGateHudState {
+	phase: string;
+	mode?: string;
+	intake?: string;
+	slug?: string;
+	specPath?: string;
+	verdict?: string;
+	experimentCount?: number;
+	experimentStatuses?: string[];
+	updatedAt?: string;
+}
+
+export function buildAutoresearchHudSummary(state: AutoresearchHudState): WorkflowHudSummary {
+	const statuses = state.experimentStatuses ?? [];
+	const total = Math.max(state.experimentCount ?? statuses.length, statuses.length);
+	const kept = statuses.filter(status => status === "keep").length;
+	const crash = statuses.filter(status => status === "crash").length;
+	const checksFailed = statuses.filter(status => status === "checks_failed").length;
+	const chips: Array<WorkflowHudChip | null> = [
+		...(state.phase === "verdict" ? [chip("verdict", state.verdict ?? "issued", 5)] : []),
+		chip("phase", state.phase, 10),
+		...(total > 0 ? [chip("exp", `${kept}/${total}`, 20)] : []),
+		crash > 0 ? { label: "crash", value: String(crash), priority: 4, severity: "warning" } : null,
+		checksFailed > 0
+			? { label: "checks_failed", value: String(checksFailed), priority: 5, severity: "warning" }
+			: null,
+		chip("mode", state.mode, 30),
+		chip("intake", state.intake, 40),
+		chip("spec", state.specPath, 45),
+		...gateChips(state, 50),
+	];
+	const visibleChips =
+		total === 0 && state.phase !== "verdict" ? compactChips([chip("phase", state.phase, 10)]) : compactChips(chips);
+	return {
+		version: 1,
+		...(state.slug ? { summary: `autoresearch mission ${state.slug}` } : {}),
+		chips: visibleChips,
+		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
+	};
+}
+
 export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudSummary {
 	const total = state.goals.length;
 	const complete = state.counts.complete ?? 0;
@@ -288,29 +314,3 @@ export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudS
 		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
 	};
 }
-
-export function buildTeamHudSummary(state: TeamHudState): WorkflowHudSummary {
-	const failedWorkers = state.workers.filter(
-		worker => worker.status === "failed" || worker.status === "blocked",
-	).length;
-	const stoppedWorkers = state.workers.filter(worker => worker.status === "stopped").length;
-	const completed = state.task_counts.completed ?? 0;
-	const failedTasks = (state.task_counts.failed ?? 0) + (state.task_counts.blocked ?? 0);
-	const latest = state.latestEvent?.message ?? state.latestEvent?.type ?? state.latestMessage?.body;
-	return {
-		version: 1,
-		chips: compactChips([
-			failedWorkers > 0 || failedTasks > 0
-				? { label: "blocked", value: String(failedWorkers + failedTasks), priority: 5, severity: "blocked" }
-				: stoppedWorkers > 0
-					? { label: "stopped", value: String(stoppedWorkers), priority: 5, severity: "warning" }
-					: null,
-			chip("phase", state.phase, 10),
-			chip("workers", `${state.workers.length - failedWorkers}/${state.workers.length}`, 20),
-			chip("tasks", `${completed}/${state.task_total}`, 30),
-			...gateChips(state, 40),
-			chip("latest", latest, 70),
-		]),
-		...(state.updated_at ? { updated_at: state.updated_at } : {}),
-	};
-}

package/src/skill-state/workflow-mutation-guard.ts

@@ -3,6 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentTool } from "@gajae-code/agent-core";
 import { logger } from "@gajae-code/utils";
+import { isAutoresearchAuthorizedResearchPath } from "../autoresearch/git";
 import { expandApplyPatchToEntries } from "../edit/modes/apply-patch";
 import { GJC_SESSION_PREFIX, modeStatePath as sessionModeStatePath } from "../gjc-runtime/session-layout";
 import { resolveGjcSessionForRead } from "../gjc-runtime/session-resolution";
@@ -26,10 +27,13 @@ export const RALPLAN_MUTATION_BLOCK_MESSAGE =
 	"Ralplan planning phase boundary: keep refining the consensus plan and persist plan artifacts through `gjc ralplan --write` (stage scratch files under a temp dir if needed). Product-code mutation tools and patch execution are blocked while ralplan is active; mutate only after the plan is approved and execution begins.";
 export const ULTRAGOAL_GOAL_PLANNING_MUTATION_BLOCK_MESSAGE =
 	"Ultragoal goal-planning phase boundary: finish goal planning and record goals through `gjc ultragoal` before editing code. Product-code mutation tools and patch execution are blocked until goal planning completes and execution begins.";
+export const AUTORESEARCH_MUTATION_BLOCK_MESSAGE =
+	"Autoresearch research-only boundary: this workflow produces findings, evidence, and a verdict — never product code. Product-code mutation tools and patch execution are blocked everywhere, on every branch. Mission research artifacts (`autoresearch.sh` at the workdir root and mission state through the sanctioned `gjc autoresearch` CLI) stay writable; run experiments through the `python` tool, or finish the mission and hand off to an approved implementation workflow.";
 
 /** Resolve the phase-boundary block message for the active planning skill. */
 function planningPhaseBlockMessage(skill: CanonicalGjcWorkflowSkill): string {
 	if (skill === "ralplan") return RALPLAN_MUTATION_BLOCK_MESSAGE;
+	if (skill === "autoresearch") return AUTORESEARCH_MUTATION_BLOCK_MESSAGE;
 	if (skill === "ultragoal") return ULTRAGOAL_GOAL_PLANNING_MUTATION_BLOCK_MESSAGE;
 	return DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE;
 }
@@ -220,9 +224,12 @@ function modeStateMatchesContext(state: ModeState, sessionId?: string, threadId?
 	return true;
 }
 
-/** Workflow skills that have a pre-approval planning posture this guard enforces. `team` never does. */
-function isPlanningSkill(skill: string): skill is "deep-interview" | "ralplan" | "ultragoal" {
-	return skill === "deep-interview" || skill === "ralplan" || skill === "ultragoal";
+/** Canonical workflow skills whose active posture gates product-code mutation. */
+type MutationGatedSkill = "deep-interview" | "ralplan" | "ultragoal" | "autoresearch";
+
+/** Workflow skills whose active posture this guard enforces against product-code mutation. */
+function isPlanningSkill(skill: string): skill is MutationGatedSkill {
+	return skill === "deep-interview" || skill === "ralplan" || skill === "ultragoal" || skill === "autoresearch";
 }
 
 /**
@@ -233,14 +240,14 @@ function isPlanningSkill(skill: string): skill is "deep-interview" | "ralplan" |
  * `ultragoal` only blocks during `goal-planning`; once goals are created it is an
  * executor and mutates freely.
  */
-function isBlockingPlanningPhase(skill: "deep-interview" | "ralplan" | "ultragoal", phase: string): boolean {
+function isBlockingPlanningPhase(skill: MutationGatedSkill, phase: string): boolean {
 	const normalized = phase.trim().toLowerCase();
 	if (skill === "ultragoal") return normalized === "goal-planning";
 	return !getSkillManifest(skill).stopReleasingPhases.includes(normalized);
 }
 
 interface ActivePlanningSkill {
-	skill: "deep-interview" | "ralplan" | "ultragoal";
+	skill: MutationGatedSkill;
 	phase: string;
 }
 
@@ -251,7 +258,7 @@ interface ActivePlanningSkill {
  * to `active:false`, which `listActiveSkills` already filters out). If several
  * are momentarily active, prefer the most-recently-updated entry so a stale
  * planning row (e.g. a still-active ralplan `final`) can never be selected over a
- * newer executor (ultragoal/team), and a planning *return* (newer `updated_at`)
+ * newer executor (ultragoal/autoresearch), and a planning *return* (newer `updated_at`)
  * reliably wins. Ties fall back to the resolved top-level `skill`, then to the
  * first entry, matching how the HUD/chain guard pick `activeSkills[0]`.
  */
@@ -1053,7 +1060,7 @@ function blockedWorkflowStateSkill(cwd: string, rawPath: string): CanonicalGjcWo
 	if (generatedRoot === "specs" || generatedRoot === "plans") return null;
 	if (generatedRoot !== "state") return null;
 	const fileName = segments.at(-1) ?? "";
-	for (const skillName of ["deep-interview", "ralplan", "ultragoal", "team"] as const) {
+	for (const skillName of ["deep-interview", "ralplan", "ultragoal"] as const) {
 		if (fileName === workflowModeStateFileName(skillName)) return skillName;
 	}
 	if (fileName === "skill-active-state.json") return "deep-interview";
@@ -1214,6 +1221,18 @@ export async function getWorkflowMutationDecision(
 		return { blocked: false, targets: [] };
 	}
 	if (input.forceOverride) return { blocked: false, targets: [] };
+	// Autoresearch is research-only: it never edits product code, on any branch.
+	// The only agent-writable surface is the mission's own research artifact —
+	// the `autoresearch.sh` harness at the workdir root (mission state under
+	// `.gjc/**` is runtime-owned and only the sanctioned CLI writes it). A branch
+	// name is not authorization: an `autoresearch/*` branch isolates keep/discard
+	// bookkeeping, it does not turn product edits into research.
+	if (
+		planning.skill === "autoresearch" &&
+		targets.paths.every(p => isAutoresearchAuthorizedResearchPath(input.cwd, p))
+	) {
+		return { blocked: false, targets: targets.paths };
+	}
 	const message = planningPhaseBlockMessage(planning.skill);
 	// Bash during a planning phase blocks only when a filesystem mutation was
 	// actually recognized. Inspection, reads, and CLI invocations the scanner does

package/src/slash-commands/builtin-registry.ts

@@ -44,6 +44,7 @@ import {
 } from "../setup/provider-onboarding";
 import { parseThinkingLevel } from "../thinking";
 import { getDisplayChangelogEntries } from "../utils/changelog";
+import { buildAutoroutingStatusReport } from "./helpers/autorouting-status";
 import { buildContextReportText } from "./helpers/context-report";
 import { switchSessionCredentialCommand } from "./helpers/credential-switch";
 import { buildFastStatusReport } from "./helpers/fast-status-report";
@@ -1117,6 +1118,82 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "routing",
+		description: "Show or set up sub-agent model autorouting",
+		acpDescription: "Show or set up sub-agent model autorouting",
+		inlineHint: "[on|off|status]",
+		acpInputHint: "[on|off|status]",
+		subcommands: [
+			{ name: "on", description: "Enable autorouting" },
+			{ name: "off", description: "Disable autorouting" },
+			{ name: "status", description: "Show effective autorouting tiers" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const arg = command.args.trim().toLowerCase();
+			if (arg === "on" || arg === "off") {
+				try {
+					// Mirror SelectorController#assertSmartRoutingWritable: the non-TUI (ACP/SDK)
+					// dispatch path must honor the same scoped-session guard as the TUI controller,
+					// otherwise a --models-scoped session can toggle routing through /routing on|off.
+					if ((runtime.session.scopedModels?.length ?? 0) > 0) {
+						throw new Error("Smart-routing settings are read-only in a --models-scoped session.");
+					}
+					runtime.settings.set("task.autorouting.enabled", arg === "on");
+				} catch (err) {
+					return usage(`Failed to change autorouting: ${errorMessage(err)}`, runtime);
+				}
+				await runtime.output(
+					buildAutoroutingStatusReport({
+						effective: runtime.settings.getEffectiveAutorouting(),
+						tiers: runtime.settings.get("task.autorouting.tiers"),
+						provenance: runtime.settings.get("task.autorouting.provenance"),
+					}),
+				);
+
+				return commandConsumed();
+			}
+			if (arg === "" || arg === "status") {
+				await runtime.output(
+					buildAutoroutingStatusReport({
+						effective: runtime.settings.getEffectiveAutorouting(),
+						tiers: runtime.settings.get("task.autorouting.tiers"),
+						provenance: runtime.settings.get("task.autorouting.provenance"),
+					}),
+				);
+
+				return commandConsumed();
+			}
+			return usage("Usage: /routing [on|off|status]", runtime);
+		},
+		handleTui: async (command, runtime) => {
+			const arg = command.args.trim().toLowerCase();
+			runtime.ctx.editor.setText("");
+			if (arg === "") {
+				runtime.ctx.showModelSelector({ smartRoutingOnly: true });
+				return;
+			}
+			if (arg === "on" || arg === "off") {
+				// Route through the controller so the toggle honors the same
+				// scoped-session and durable-config guards as the panel.
+				await runtime.ctx.setAutoroutingEnabled(arg === "on");
+			} else if (arg !== "status") {
+				runtime.ctx.showStatus("Usage: /routing [on|off|status]");
+				return;
+			}
+			const report = buildAutoroutingStatusReport({
+				effective: runtime.ctx.settings.getEffectiveAutorouting(),
+				tiers: runtime.ctx.settings.get("task.autorouting.tiers"),
+				provenance: runtime.ctx.settings.get("task.autorouting.provenance"),
+			});
+			runtime.ctx.chatContainer.addChild(new Spacer(1));
+			runtime.ctx.chatContainer.addChild(new DynamicBorder());
+			runtime.ctx.chatContainer.addChild(new Text(report, 1, 0));
+			runtime.ctx.chatContainer.addChild(new DynamicBorder());
+			runtime.ctx.ui.requestRender();
+		},
+	},
 	{
 		name: "export",
 		priority: 50,

package/src/slash-commands/helpers/autorouting-status.ts

@@ -0,0 +1,55 @@
+import { replaceTabs, truncateToWidth } from "@gajae-code/tui";
+import {
+	AUTOROUTING_TIERS,
+	type AutoroutingEffective,
+	type AutoroutingProvenance,
+	matchesRecordedTiersFingerprint,
+	validateAutoroutingProvenance,
+} from "../../config/autorouting-contract";
+import { validateDisplayLine } from "../../modes/components/ansi-display-validator";
+
+/** Longest rendered chain/diagnostic before truncation. */
+const MAX_STATUS_LINE_WIDTH = 200;
+
+/**
+ * Selectors and diagnostics originate in user-editable config, so a hand-edited
+ * value can carry tabs or terminal control sequences. Strip them before the
+ * string reaches a renderer.
+ */
+function displaySafe(text: string): string {
+	return truncateToWidth(validateDisplayLine(replaceTabs(text)), MAX_STATUS_LINE_WIDTH);
+}
+
+export type AutoroutingStatusSnapshot = {
+	effective: AutoroutingEffective;
+	tiers: unknown;
+	provenance: AutoroutingProvenance | undefined;
+};
+
+/** Render settings-derived autorouting state without consulting registry/auth. */
+export function buildAutoroutingStatusReport(snapshot: AutoroutingStatusSnapshot): string {
+	const { effective, tiers, provenance } = snapshot;
+	if (!effective.active) {
+		const detail =
+			effective.issue?.detail ?? "Autorouting is disabled; every Task item uses manual model resolution.";
+		return `Autorouting: off\n${displaySafe(detail)}`;
+	}
+	const provenanceIssues = provenance === undefined ? [] : validateAutoroutingProvenance(provenance);
+	const malformed = provenanceIssues.length > 0;
+	const generated = !malformed && provenance !== undefined && matchesRecordedTiersFingerprint(provenance, tiers);
+	const label = malformed
+		? "hand-authored tiers"
+		: generated
+			? "generated"
+			: provenance === undefined
+				? "hand-authored tiers"
+				: "generated, hand-edited";
+	const lines = [`Autorouting: on (${label})`];
+	if (malformed) lines.push("Recorded generation provenance is invalid; treating tiers as hand-authored.");
+	for (const tier of AUTOROUTING_TIERS) {
+		const chain = effective.map[tier];
+		const rendered = chain && chain.length > 0 ? displaySafe(chain.join(" -> ")) : "(unmapped, falls back to manual)";
+		lines.push(`  ${tier}: ${rendered}`);
+	}
+	return lines.join("\n");
+}

package/src/system-prompt.ts

@@ -405,18 +405,116 @@ export interface BuildSystemPromptResult {
 	/** Context-file discovery warnings visible to SDK and session callers. */
 	warnings: string[];
 }
+/** Host wall-clock facts injected with every turn. */
+export interface LocalTimeContext {
+	/** Local calendar date with weekday, e.g. `2026-08-19 (Wed)`. */
+	date: string;
+	/** Local clock time with UTC offset and IANA zone, e.g. `21:04 UTC+09:00 (Asia/Seoul)`. */
+	time: string;
+}
+
+/**
+ * Render the host's local date and clock time for the volatile turn context.
+ *
+ * Every field is derived from a single `Intl.DateTimeFormat` pass over one
+ * resolved zone, so the date, clock, offset, and zone name can never disagree
+ * with each other the way `Date`'s local getters can. Falls back to UTC only
+ * when the runtime has no usable ICU zone.
+ *
+ * @param timeZone IANA zone override. Default: the host zone.
+ */
+export function getLocalTimeContext(now: Date = new Date(), timeZone?: string): LocalTimeContext {
+	try {
+		const zone = timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+		const parts = new Intl.DateTimeFormat("en-US", {
+			timeZone: zone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			weekday: "short",
+			hour: "2-digit",
+			minute: "2-digit",
+			hourCycle: "h23",
+			timeZoneName: "longOffset",
+		}).formatToParts(now);
+		const part = (type: Intl.DateTimeFormatPartTypes): string =>
+			parts.find(candidate => candidate.type === type)?.value ?? "";
+		const year = part("year");
+		const month = part("month");
+		const day = part("day");
+		const hour = part("hour");
+		const minute = part("minute");
+		if (!year || !month || !day || !hour || !minute) throw new Error("incomplete date parts");
+		// `longOffset` renders "GMT+09:00", or a bare "GMT" at zero offset.
+		const offset = part("timeZoneName").replace(/^GMT$/, "UTC+00:00").replace(/^GMT/, "UTC");
+		const weekday = part("weekday");
+		return {
+			date: weekday ? `${year}-${month}-${day} (${weekday})` : `${year}-${month}-${day}`,
+			time: `${hour}:${minute} ${offset}${zone ? ` (${zone})` : ""}`.trim(),
+		};
+	} catch (error) {
+		logger.warn("Could not resolve host timezone for volatile project context; falling back to UTC", {
+			error: String(error),
+		});
+		const fallbackNow = Number.isFinite(now.getTime()) ? now : new Date(0);
+		const iso = fallbackNow.toISOString();
+		return { date: iso.slice(0, 10), time: `${iso.slice(11, 16)} UTC+00:00 (UTC)` };
+	}
+}
+
 export interface BuildVolatileProjectContextOptions {
 	cwd?: string;
+	/** Clock source for the rendered local date/time. Default: `new Date()`. */
+	now?: Date;
+	/** Trusted/test-only override in the derived `YYYY-MM-DD (Www)` or `YYYY-MM-DD` format. */
 	date?: string;
+	/** Trusted/test-only override in the derived `HH:MM UTC±HH:MM (IANA/Zone)` format. */
+	localTime?: string;
 	workspaceTree?: WorkspaceTree;
 }
 
+const LOCAL_DATE_OVERRIDE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})(?: \(([A-Z][a-z]{2})\))?$/u;
+const LOCAL_TIME_OVERRIDE_PATTERN =
+	/^(\d{2}):(\d{2}) UTC([+-])(\d{2}):(\d{2}) \(([A-Za-z0-9_+-]+(?:\/[A-Za-z0-9_+-]+)*)\)$/u;
+
+function isValidLocalDateOverride(value: string): boolean {
+	const match = LOCAL_DATE_OVERRIDE_PATTERN.exec(value);
+	if (!match) return false;
+	const year = Number(match[1]);
+	const month = Number(match[2]);
+	const day = Number(match[3]);
+	const instant = new Date(Date.UTC(2000, month - 1, day));
+	instant.setUTCFullYear(year);
+	if (instant.getUTCFullYear() !== year || instant.getUTCMonth() !== month - 1 || instant.getUTCDate() !== day)
+		return false;
+	const weekday = match[4];
+	if (!weekday) return true;
+	return ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][instant.getUTCDay()] === weekday;
+}
+
+function isValidLocalTimeOverride(value: string): boolean {
+	const match = LOCAL_TIME_OVERRIDE_PATTERN.exec(value);
+	if (!match) return false;
+	const hour = Number(match[1]);
+	const minute = Number(match[2]);
+	const offsetHour = Number(match[4]);
+	const offsetMinute = Number(match[5]);
+	return hour < 24 && minute < 60 && offsetHour < 24 && offsetMinute < 60;
+}
+
 export function buildVolatileProjectContext(options: BuildVolatileProjectContextOptions = {}): string {
 	const resolvedCwd = options.cwd ?? getProjectDir();
-	const date = options.date ?? new Date().toISOString().slice(0, 10);
+	const local = getLocalTimeContext(options.now ?? new Date());
+	const date = escapePromptMetadata(
+		options.date && isValidLocalDateOverride(options.date) ? options.date : local.date,
+	);
+	const localTime = escapePromptMetadata(
+		options.localTime && isValidLocalTimeOverride(options.localTime) ? options.localTime : local.time,
+	);
 	return prompt
 		.render(volatileProjectContextTemplate, {
 			date,
+			localTime,
 			cwd: escapePromptMetadata(shortenPath(resolvedCwd.replace(/\\/g, "/"))),
 			workspaceTree: {
 				...(options.workspaceTree ?? {
@@ -556,8 +654,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		}
 	}
 
-	const date = new Date().toISOString().slice(0, 10);
-	const dateTime = date;
+	// Date/time deliberately absent: volatile clock facts live in the per-turn
+	// volatile project context (see buildVolatileProjectContext), never in this
+	// cached stable prefix.
 	const promptCwd = shortenPath(resolvedCwd.replace(/\\/g, "/"));
 
 	// Build tool metadata for system prompt rendering
@@ -618,8 +717,6 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		workspaceTree,
 		rules: rules ?? [],
 		alwaysApplyRules: sanitizedAlwaysApplyRules,
-		date,
-		dateTime,
 		cwd: promptCwd,
 		intentTracing: !!intentField,
 		intentField: intentField ?? "",

package/src/task/discovery.ts

@@ -9,9 +9,8 @@
  * Agent files use markdown with YAML frontmatter.
  */
 import * as fs from "node:fs/promises";
-import * as os from "node:os";
 import * as path from "node:path";
-import { logger } from "@gajae-code/utils";
+import { getTrustedHomeDir, logger } from "@gajae-code/utils";
 import { isProviderEnabled } from "../capability";
 import { findAllNearestProjectConfigDirs, getConfigDirs } from "../config";
 import type { Settings } from "../config/settings";
@@ -62,7 +61,7 @@ async function loadAgentsFromDir(dir: string, source: AgentSource): Promise<Agen
  */
 export async function discoverAgents(
 	cwd: string,
-	home: string = os.homedir(),
+	home: string = getTrustedHomeDir(),
 	activeSettings?: Settings,
 ): Promise<DiscoveryResult> {
 	const resolvedCwd = path.resolve(cwd);