@sayknow-cli/coding-agent 0.2.4 → 0.2.5

package/src/skill-state/deep-interview-mutation-guard.ts

@@ -1,8 +1,12 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentTool } from "@sayknow-cli/agent-core";
 import { logger } from "@sayknow-cli/utils";
 import { expandApplyPatchToEntries } from "../edit/modes/apply-patch";
 import { LocalProtocolHandler, resolveLocalUrlToPath } from "../internal-urls/local-protocol";
+import { SKC_SESSION_PREFIX, modeStatePath as sessionModeStatePath } from "../skc-runtime/session-layout";
+import { resolveSkcSessionForRead } from "../skc-runtime/session-resolution";
 import { ModeStateSchema } from "../skc-runtime/state-schema";
 import { resolveToCwd } from "../tools/path-utils";
 import { ToolError } from "../tools/tool-errors";
@@ -17,15 +21,22 @@ export const DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE =
 	"Deep-interview phase boundary: continue gathering context/questions/risks and emit a handoff/spec before code edits. Mutation tools and patch execution are blocked while deep-interview is active; finalize specs through `skc deep-interview --write --stage final` or hand off to an execution phase.";
 export const WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE =
 	".skc workflow state and artifacts are runtime-owned. Agent mutation tools cannot edit `.skc/**`; use the sanctioned `skc` CLI instead.";
+export const RALPLAN_MUTATION_BLOCK_MESSAGE =
+	"Ralplan planning phase boundary: keep refining the consensus plan and persist plan artifacts through `skc 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 `skc ultragoal` before editing code. Product-code mutation tools and patch execution are blocked until goal planning completes and execution begins.";
 
-const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit", "bash"]);
+/** Resolve the phase-boundary block message for the active planning skill. */
+function planningPhaseBlockMessage(skill: CanonicalSkcWorkflowSkill): string {
+	if (skill === "ralplan") return RALPLAN_MUTATION_BLOCK_MESSAGE;
+	if (skill === "ultragoal") return ULTRAGOAL_GOAL_PLANNING_MUTATION_BLOCK_MESSAGE;
+	return DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE;
+}
+
+const BLOCKED_TOOL_NAMES = new Set(["edit", "write", "ast_edit"]);
 const ARCHIVE_OR_SQLITE_BASE_RE = /^(.+?\.(?:tar\.gz|sqlite3|sqlite|db3|zip|tgz|tar|db))(?:$|:)/i;
 const INTERNAL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 const VIM_FILE_SWITCH_RE = /^\s*:(?:e|e!|edit|edit!)(?:\s+([^<\r\n]+))?(?:<CR>|\r|\n|$)/i;
-const BASH_TOKEN_RE = /'[^']*'|"(?:\\.|[^"\\])*"|\S+/g;
-const BASH_REDIRECT_RE = /^(?:\d*)>>?$/;
-const BASH_HEREDOC_RE = /^(?:\d*)<<-?$/;
-const BASH_MUTATION_COMMANDS = new Set(["rm", "mv", "cp", "touch", "mkdir", "ln", "tee"]);
 
 type ToolWithEditMode = AgentTool & {
 	mode?: unknown;
@@ -67,15 +78,18 @@ function safeString(value: unknown): string {
 	return typeof value === "string" ? value : "";
 }
 
-function encodePathSegment(value: string): string {
-	return encodeURIComponent(value).replaceAll(".", "%2E");
+async function resolveBoundarySessionId(cwd: string, sessionId?: string): Promise<string | null> {
+	const normalizedSessionId = sessionId?.trim();
+	if (normalizedSessionId) return normalizedSessionId;
+	try {
+		return (await resolveSkcSessionForRead(cwd, { envSessionId: process.env.SKC_SESSION_ID })).skcSessionId;
+	} catch {
+		return null;
+	}
 }
 
-function modeStatePath(cwd: string, skill: string, sessionId?: string): string {
-	const stateDir = path.join(cwd, ".skc", "state");
-	const fileName = `${skill}-state.json`;
-	if (sessionId) return path.join(stateDir, "sessions", encodePathSegment(sessionId), fileName);
-	return path.join(stateDir, fileName);
+function modeStatePath(cwd: string, skill: string, sessionId: string): string {
+	return sessionModeStatePath(cwd, sessionId, skill);
 }
 
 function warnInvalidModeState(filePath: string, error: string): void {
@@ -103,21 +117,17 @@ async function readValidatedModeState(filePath: string): Promise<ModeState | nul
 	}
 	return state;
 }
-async function readVisibleModeState(cwd: string, skill: string, sessionId?: string): Promise<ModeState | null> {
-	if (sessionId) {
-		const sessionState = await readValidatedModeState(modeStatePath(cwd, skill, sessionId));
-		if (sessionState) return sessionState;
-	}
-	return await readValidatedModeState(modeStatePath(cwd, skill));
+async function readVisibleModeState(cwd: string, skill: string, sessionId: string): Promise<ModeState | null> {
+	return await readValidatedModeState(modeStatePath(cwd, skill, sessionId));
 }
 
-function isTerminalModeState(state: ModeState | null): boolean {
-	if (state?.active !== true) return true;
-	const phase = String(state.current_phase ?? "")
-		.trim()
-		.toLowerCase();
-	return ["complete", "completed", "failed", "cancelled", "canceled", "inactive"].includes(phase);
-}
+/**
+ * Phases that genuinely finish a workflow skill. Mirrors the Stop hook's
+ * `STOP_RELEASING_PHASES` (`hooks/skill-state.ts`): `handoff` is intentionally
+ * absent so a handoff-required planning skill (deep-interview/ralplan) keeps
+ * blocking through its handoff/ask window until it is demoted or cleared.
+ */
+const WORKFLOW_FINISHED_PHASES = new Set(["complete", "completed", "failed", "cancelled", "canceled", "inactive"]);
 
 function entryMatchesContext(entry: SkillActiveEntry, sessionId?: string, threadId?: string): boolean {
 	if (sessionId && entry.session_id && entry.session_id !== sessionId) return false;
@@ -131,17 +141,94 @@ function modeStateMatchesContext(state: ModeState, sessionId?: string, threadId?
 	return true;
 }
 
-async function isActiveDeepInterview(cwd: string, sessionId?: string, threadId?: string): Promise<boolean> {
-	const skillState = await readVisibleSkillActiveState(cwd, sessionId);
-	const activeDeepInterview = listActiveSkills(skillState).find(
-		entry => entry.skill === "deep-interview" && entryMatchesContext(entry, sessionId, threadId),
+/** 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";
+}
+
+/**
+ * Whether `skill` in `phase` is a pre-approval planning posture that must block
+ * product-code mutation. `deep-interview` and `ralplan` are wholly pre-approval
+ * (every phase blocks except a genuinely-finished one — `handoff` and ralplan's
+ * `final` keep blocking until execution is approved and the skill is demoted).
+ * `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 {
+	const normalized = phase.trim().toLowerCase();
+	if (skill === "ultragoal") return normalized === "goal-planning";
+	return !WORKFLOW_FINISHED_PHASES.has(normalized);
+}
+
+interface ActivePlanningSkill {
+	skill: "deep-interview" | "ralplan" | "ultragoal";
+	phase: string;
+}
+
+/**
+ * Pick the single CURRENT workflow entry among active entries.
+ *
+ * Steady state has exactly one active workflow skill (handoff demotes the prior
+ * 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`)
+ * 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]`.
+ */
+function resolveCurrentWorkflowEntry(entries: SkillActiveEntry[], topLevelSkill: string): SkillActiveEntry {
+	const ts = (entry: SkillActiveEntry): number => {
+		const value = Date.parse(safeString(entry.updated_at) || safeString(entry.activated_at));
+		return Number.isNaN(value) ? -1 : value;
+	};
+	let best = entries[0];
+	for (const entry of entries) {
+		const delta = ts(entry) - ts(best);
+		if (delta > 0) best = entry;
+		else if (delta === 0 && topLevelSkill && entry.skill === topLevelSkill) best = entry;
+	}
+	return best;
+}
+
+/**
+ * Resolve the single active pre-approval planning skill for this context, or null.
+ *
+ * Transition/return safety: this keys off the ONE canonical current workflow
+ * skill (the resolved top-level `skill` that the HUD and the skill-tool chain
+ * guard treat as active), not an independent scan of every skill. A handoff
+ * atomically demotes the prior skill and promotes the callee, and a return
+ * (e.g. re-entering ralplan/deep-interview after an ultragoal goal completes)
+ * re-activates the planning skill — in every case "whatever skill is current"
+ * governs, so a stale planning entry can never block while an executor runs and
+ * a resumed planning phase reliably re-blocks.
+ *
+ * Fail-open contract: a missing or invalid durable mode-state releases the block
+ * (a corrupt state file must not lock all mutation), matching the guard's
+ * historical behavior — this is intentionally looser than the Stop hook, which
+ * fails closed for handoff-required skills.
+ */
+async function getActivePlanningSkill(
+	cwd: string,
+	sessionId?: string,
+	threadId?: string,
+): Promise<ActivePlanningSkill | null> {
+	const resolvedSessionId = await resolveBoundarySessionId(cwd, sessionId);
+	if (!resolvedSessionId) return null;
+	const skillState = await readVisibleSkillActiveState(cwd, resolvedSessionId);
+	if (!skillState) return null;
+	const activeEntries = listActiveSkills(skillState).filter(entry =>
+		entryMatchesContext(entry, resolvedSessionId, threadId),
 	);
-	if (!activeDeepInterview) return false;
-
-	const modeState = await readVisibleModeState(cwd, "deep-interview", sessionId);
-	if (isTerminalModeState(modeState)) return false;
-	if (modeState && !modeStateMatchesContext(modeState, sessionId, threadId)) return false;
-	return true;
+	if (activeEntries.length === 0) return null;
+	const current = resolveCurrentWorkflowEntry(activeEntries, safeString(skillState.skill).trim());
+	if (!isPlanningSkill(current.skill)) return null;
+	const modeState = await readVisibleModeState(cwd, current.skill, resolvedSessionId);
+	if (!modeState) return null;
+	if (modeState.active !== true) return null;
+	if (!modeStateMatchesContext(modeState, resolvedSessionId, threadId)) return null;
+	const phase = String(modeState.current_phase ?? current.phase ?? "").trim();
+	if (!isBlockingPlanningPhase(current.skill, phase)) return null;
+	return { skill: current.skill, phase };
 }
 
 function normalizePosix(value: string): string {
@@ -243,75 +330,10 @@ function extractEditTargets(args: unknown, tool: ToolWithEditMode): ExtractedTar
 	return targets;
 }
 
-function extractBashTargets(args: unknown): ExtractedTargets {
-	const record = getRecord(args);
-	const command = safeString(record?.command).trim();
-	const targets: ExtractedTargets = { paths: [], unknown: false };
-	if (!command) {
-		targets.unknown = true;
-		return targets;
-	}
-	if (/^skc(?:\s|$)/.test(command)) return targets;
-
-	const tokens = command.match(BASH_TOKEN_RE)?.map(unquoteBashToken) ?? [];
-	for (let index = 0; index < tokens.length; index++) {
-		const token = tokens[index] ?? "";
-		if (BASH_REDIRECT_RE.test(token)) {
-			addPath(targets, tokens[index + 1]);
-			index++;
-			continue;
-		}
-		const redirectMatch = token.match(/^(?:\d*)>>?(.+)$/);
-		if (redirectMatch?.[1]) {
-			addPath(targets, redirectMatch[1]);
-			continue;
-		}
-		if (BASH_HEREDOC_RE.test(token)) {
-			addPath(targets, tokens[index + 1]);
-			index++;
-			continue;
-		}
-		const heredocMatch = token.match(/^(?:\d*)<<-?(.+)$/);
-		if (heredocMatch?.[1]) {
-			addPath(targets, heredocMatch[1]);
-			continue;
-		}
-		if (isMutationBashCommand(tokens, index)) {
-			for (let targetIndex = index + 1; targetIndex < tokens.length; targetIndex++) {
-				const target = tokens[targetIndex] ?? "";
-				if (isBashCommandBoundary(target)) break;
-				if (target.startsWith("-")) continue;
-				addPath(targets, target);
-			}
-		}
-	}
-	return targets;
-}
-
-function unquoteBashToken(token: string): string {
-	if (token.length < 2) return token;
-	const quote = token[0];
-	if ((quote === "'" || quote === '"') && token.at(-1) === quote) return token.slice(1, -1);
-	return token;
-}
-
-function isBashCommandBoundary(token: string): boolean {
-	return [";", "&&", "||", "|"].includes(token);
-}
-
-function isMutationBashCommand(tokens: string[], index: number): boolean {
-	const token = path.basename(tokens[index] ?? "");
-	if (BASH_MUTATION_COMMANDS.has(token)) return true;
-	if (token !== "sed") return false;
-	const next = tokens[index + 1] ?? "";
-	return next === "-i" || next.startsWith("-i") || next.includes("i");
-}
-
 function extractTargets(tool: ToolWithEditMode, args: unknown): ExtractedTargets {
 	if (tool.name === "write") return extractWriteTargets(args);
 	if (tool.name === "ast_edit") return extractAstEditTargets(args);
 	if (tool.name === "edit") return extractEditTargets(args, tool);
-	if (tool.name === "bash") return extractBashTargets(args);
 	return { paths: [], unknown: true };
 }
 
@@ -355,8 +377,9 @@ function relativeSkcSegments(cwd: string, rawPath: string): string[] | null {
 function blockedWorkflowStateSkill(cwd: string, rawPath: string): CanonicalSkcWorkflowSkill | null {
 	const segments = relativeSkcSegments(cwd, rawPath);
 	if (segments?.[0] !== ".skc") return null;
-	if (segments[1] === "specs" || segments[1] === "plans") return null;
-	if (segments[1] !== "state") return null;
+	const generatedRoot = segments[1]?.startsWith(SKC_SESSION_PREFIX) ? segments[2] : segments[1];
+	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) {
 		if (fileName === workflowModeStateFileName(skillName)) return skillName;
@@ -376,7 +399,8 @@ function firstBlockedWorkflowStateSkill(cwd: string, targets: ExtractedTargets):
 function isAllowlistedPath(cwd: string, rawPath: string): boolean {
 	const segments = relativeSkcSegments(cwd, rawPath);
 	if (segments?.[0] !== ".skc") return false;
-	return segments[1] === "specs" || segments[1] === "plans";
+	const generatedRoot = segments[1]?.startsWith(SKC_SESSION_PREFIX) ? segments[2] : segments[1];
+	return generatedRoot === "specs" || generatedRoot === "plans";
 }
 function isBlockedSkcPath(cwd: string, rawPath: string): boolean {
 	const segments = relativeSkcSegments(cwd, rawPath);
@@ -392,6 +416,84 @@ function allTargetsAllowlisted(cwd: string, targets: ExtractedTargets): boolean
 		!targets.unknown && targets.paths.length > 0 && targets.paths.every(rawPath => isAllowlistedPath(cwd, rawPath))
 	);
 }
+
+function neutralTempRoots(): string[] {
+	const roots = new Set<string>();
+	const add = (value: string | undefined): void => {
+		const trimmed = value?.trim();
+		if (trimmed) roots.add(path.resolve(trimmed));
+	};
+	add(os.tmpdir());
+	add(process.env.TMPDIR);
+	for (const fixed of ["/tmp", "/var/tmp", "/private/tmp", "/private/var/tmp"]) add(fixed);
+	return [...roots];
+}
+
+function isPathWithin(root: string, target: string): boolean {
+	const rel = path.relative(root, target);
+	return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+async function realpathOrSelf(target: string): Promise<string> {
+	try {
+		return await fs.realpath(target);
+	} catch {
+		return target;
+	}
+}
+
+/**
+ * Canonicalize a target whose leaf may not exist yet (we are about to write it):
+ * realpath the nearest existing ancestor and re-append the not-yet-existing
+ * suffix, so a symlinked ancestor (or macOS `/tmp` → `/private/tmp` alias) is
+ * resolved to its real location.
+ */
+async function canonicalizeForContainment(absolutePath: string): Promise<string> {
+	const suffix: string[] = [];
+	let current = absolutePath;
+	for (let depth = 0; depth < 64; depth++) {
+		try {
+			const real = await fs.realpath(current);
+			return suffix.length > 0 ? path.join(real, ...suffix.reverse()) : real;
+		} catch {
+			const parent = path.dirname(current);
+			if (parent === current) break;
+			suffix.push(path.basename(current));
+			current = parent;
+		}
+	}
+	return absolutePath;
+}
+
+/**
+ * A neutral scratch path the planning-phase block tolerates: it resolves to a
+ * system temp directory and lives OUTSIDE the project cwd. Files inside the
+ * project tree (product code, `.skc/**`) are never neutral, even when the cwd
+ * itself is rooted under a temp dir. The lexical checks run first; a canonical
+ * (symlink/alias-resolved) re-check then ensures the REAL target is still outside
+ * the project and inside a real temp root, defeating a temp symlink that points
+ * back into the repo or `.skc/`.
+ */
+async function isNeutralTempPath(cwd: string, rawPath: string): Promise<boolean> {
+	const { absolutePath, unknown } = resolveRawPath(cwd, rawPath);
+	if (unknown || !absolutePath) return false;
+	const resolvedCwd = path.resolve(cwd);
+	if (isPathWithin(resolvedCwd, absolutePath)) return false;
+	if (!neutralTempRoots().some(root => isPathWithin(root, absolutePath))) return false;
+	const realTarget = await canonicalizeForContainment(absolutePath);
+	if (isPathWithin(await realpathOrSelf(resolvedCwd), realTarget)) return false;
+	const realRoots = await Promise.all(neutralTempRoots().map(realpathOrSelf));
+	return realRoots.some(root => isPathWithin(root, realTarget));
+}
+
+/** Targets that remain disallowed during a planning phase (excludes neutral temp scratch). */
+async function planningBlockedTargets(cwd: string, targets: ExtractedTargets): Promise<string[]> {
+	const blocked: string[] = [];
+	for (const rawPath of targets.paths) {
+		if (!(await isNeutralTempPath(cwd, rawPath))) blocked.push(rawPath);
+	}
+	return blocked;
+}
 export async function assertDeepInterviewMutationRawPathsAllowed(input: {
 	cwd: string;
 	sessionId?: string;
@@ -399,12 +501,21 @@ export async function assertDeepInterviewMutationRawPathsAllowed(input: {
 	rawPaths: string[];
 	forceOverride?: boolean;
 }): Promise<void> {
-	if (input.forceOverride) return;
-	if (!(await isActiveDeepInterview(input.cwd, input.sessionId, input.threadId))) return;
 	const targets: ExtractedTargets = { paths: input.rawPaths, unknown: input.rawPaths.length === 0 };
-	if (targets.unknown || targets.paths.length > 0) {
-		throw new ToolError(DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE);
+	// Always-on `.skc/**` runtime-owned block, in parity with getDeepInterviewMutationDecision
+	// and ahead of forceOverride: a deferred ast_edit apply must not reach `.skc/**` either.
+	if (hasBlockedSkcTarget(input.cwd, targets)) {
+		const stateSkill = firstBlockedWorkflowStateSkill(input.cwd, targets);
+		const command = stateSkill ? sanctionedWorkflowStateCommand(stateSkill) : "skc <workflow-command>";
+		throw new ToolError(`${WORKFLOW_STATE_MUTATION_BLOCK_MESSAGE}\nUse: ${command}`);
 	}
+	if (input.forceOverride) return;
+	const planning = await getActivePlanningSkill(input.cwd, input.sessionId, input.threadId);
+	if (!planning) return;
+	const message = planningPhaseBlockMessage(planning.skill);
+	if (input.rawPaths.length === 0) throw new ToolError(message);
+	const blocked = await planningBlockedTargets(input.cwd, targets);
+	if (blocked.length > 0) throw new ToolError(message);
 }
 
 export async function getDeepInterviewMutationDecision(
@@ -423,24 +534,30 @@ export async function getDeepInterviewMutationDecision(
 			command,
 		};
 	}
-	if (!(await isActiveDeepInterview(input.cwd, input.sessionId, input.threadId))) {
+	const planning = await getActivePlanningSkill(input.cwd, input.sessionId, input.threadId);
+	if (!planning) {
 		return { blocked: false, targets: [] };
 	}
 	if (input.forceOverride) return { blocked: false, targets: [] };
+	const message = planningPhaseBlockMessage(planning.skill);
 	if (targets.unknown) {
 		return {
 			blocked: true,
-			message: DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE,
+			message,
 			targets: targets.paths,
 			reason: "unknown-target",
 		};
 	}
-	if (input.tool.name === "bash") {
+	// Neutral temp scratch (outside the project tree) stays writable so agents can
+	// stage artifacts and feed their path to the sanctioned `skc ... --write` CLIs.
+	// Read-only / `skc` bash extract no targets and fall through to allowed here.
+	const blockedTargets = await planningBlockedTargets(input.cwd, targets);
+	if (blockedTargets.length === 0) {
 		return { blocked: false, targets: targets.paths };
 	}
 	return {
 		blocked: true,
-		message: DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE,
+		message,
 		targets: targets.paths,
 		reason: allTargetsAllowlisted(input.cwd, targets) ? "handoff-artifact-tool-target" : "phase-boundary",
 	};
@@ -450,3 +567,13 @@ export async function assertDeepInterviewMutationAllowed(input: DeepInterviewMut
 	const decision = await getDeepInterviewMutationDecision(input);
 	if (decision.blocked) throw new ToolError(decision.message ?? DEEP_INTERVIEW_MUTATION_BLOCK_MESSAGE);
 }
+
+/*
+ * Generic cross-workflow names for this planning-phase mutation guard. The guard
+ * now governs deep-interview, ralplan, and ultragoal goal-planning, so new
+ * callers SHOULD use these names; the `*DeepInterview*` exports above remain as
+ * compatibility aliases (and are still what the test-suite imports).
+ */
+export const getWorkflowMutationDecision = getDeepInterviewMutationDecision;
+export const assertWorkflowMutationAllowed = assertDeepInterviewMutationAllowed;
+export const assertWorkflowMutationRawPathsAllowed = assertDeepInterviewMutationRawPathsAllowed;

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

@@ -40,7 +40,7 @@ interface UltragoalHudState extends WorkflowGateHudState {
 	currentGoal?: UltragoalLikeGoal;
 	counts: Record<string, number>;
 	goals: UltragoalLikeGoal[];
-	latestLedgerEvent?: { event?: string; goalId?: string; timestamp?: string };
+	latestLedgerEvent?: { event?: string; goalId?: string; timestamp?: string; kind?: string; evidence?: string };
 	updatedAt?: string;
 }
 
@@ -237,7 +237,9 @@ export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudS
 			chip(
 				"ledger",
 				state.latestLedgerEvent?.event
-					? [state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":")
+					? [state.latestLedgerEvent.event, state.latestLedgerEvent.kind, state.latestLedgerEvent.goalId]
+							.filter(Boolean)
+							.join(":")
 					: undefined,
 				35,
 			),

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

@@ -141,10 +141,10 @@ export function sanctionedWorkflowStateCommand(skill: CanonicalSkcWorkflowSkill)
 export function describeWorkflowStateContract(skill: CanonicalSkcWorkflowSkill): string[] {
 	return [
 		`Sanctioned mutation path: skc state ${skill} read|write --input '<json>'`,
-		`Canonical active HUD state: .skc/state/${SKILL_ACTIVE_STATE_FILE} and .skc/state/sessions/<session>/${SKILL_ACTIVE_STATE_FILE}`,
-		`Skill mode state: .skc/state/${workflowModeStateFileName(skill)} or .skc/state/sessions/<session>/${workflowModeStateFileName(skill)}`,
+		`Canonical active HUD state: .skc/_session-{sessionid}/state/${SKILL_ACTIVE_STATE_FILE}`,
+		`Skill mode state: .skc/_session-{sessionid}/state/${workflowModeStateFileName(skill)}`,
 		"Receipts include version, skill, owner, command, state_path, storage_path, mutated_at, fresh_until, status, and mutation_id.",
 		"Receipts are fresh for 30 minutes; older receipts are stale and render as HUD warnings.",
-		"Planning artifacts under .skc/specs/** and .skc/plans/** remain writable outside the state command.",
+		"Planning artifacts under .skc/_session-{sessionid}/specs/** and .skc/_session-{sessionid}/plans/** remain writable outside the state command.",
 	];
 }

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

@@ -251,11 +251,15 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		inlineHint: "[objective]",
 		allowArgs: true,
 		handleTui: async (command, runtime) => {
-			const hadArgs = !!command.args;
-			// Capture state BEFORE the call (see /plan above for rationale).
-			const wasGoalModeEnabled = runtime.ctx.goalModeEnabled;
+			// The goal command always consumes the typed input: it either submits
+			// the bare objective (never the literal `/goal …` text the user typed)
+			// or shows a warning, so the normal submission path never records it in
+			// input history. Preserve the typed command whenever args were supplied
+			// — including the first-time `/goal set <objective>` case where goal
+			// mode was not yet active. A previous `wasGoalModeEnabled` guard dropped
+			// that first-time case from history (up/down-arrow recall).
 			await runtime.ctx.handleGoalModeCommand(command.args || undefined);
-			if (hadArgs && wasGoalModeEnabled) {
+			if (command.args) {
 				runtime.ctx.editor.addToHistory(command.text);
 			}
 			runtime.ctx.editor.setText("");

package/src/system-prompt.ts

@@ -253,15 +253,17 @@ export async function loadProjectContextFiles(
 
 	const result = await loadCapability(contextFileCapability.id, { cwd: resolvedCwd });
 
-	// Convert ContextFile items and preserve depth info
-	const files = result.items.map(item => {
-		const contextFile = item as ContextFile;
-		return {
-			path: contextFile.path,
-			content: contextFile.content,
-			depth: contextFile.depth,
-		};
-	});
+	// Convert project-level ContextFile items and preserve depth info
+	const files = result.items
+		.filter(item => (item as ContextFile).level === "project")
+		.map(item => {
+			const contextFile = item as ContextFile;
+			return {
+				path: contextFile.path,
+				content: contextFile.content,
+				depth: contextFile.depth,
+			};
+		});
 
 	// Sort by depth (descending): higher depth (farther from cwd) comes first,
 	// so files closer to cwd appear later and are more prominent

package/src/task/agents.ts

@@ -3,20 +3,14 @@
  *
  * Agents are embedded at build time via Bun's import with { type: "text" }.
  */
-import { Effort } from "@sayknow-cli/ai";
 import { parseFrontmatter, prompt } from "@sayknow-cli/utils";
 import { parseAgentFields } from "../discovery/helpers";
+// Embed agent markdown files at build time
 import architectMd from "../prompts/agents/architect.md" with { type: "text" };
 import criticMd from "../prompts/agents/critic.md" with { type: "text" };
 import executorMd from "../prompts/agents/executor.md" with { type: "text" };
-import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
-// Embed agent markdown files at build time
 import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
-
-import planMd from "../prompts/agents/plan.md" with { type: "text" };
 import plannerMd from "../prompts/agents/planner.md" with { type: "text" };
-import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
-import taskMd from "../prompts/agents/task.md" with { type: "text" };
 
 import type { AgentDefinition, AgentSource } from "./types";
 
@@ -50,21 +44,6 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "architect.md", template: architectMd },
 	{ fileName: "planner.md", template: plannerMd },
 	{ fileName: "critic.md", template: criticMd },
-	{ fileName: "explore.md", template: exploreMd },
-	{ fileName: "plan.md", template: planMd },
-	{ fileName: "reviewer.md", template: reviewerMd },
-	{
-		fileName: "task.md",
-		frontmatter: {
-			name: "task",
-			description: "General-purpose subagent with full capabilities for delegated multi-step tasks",
-			spawns: "*",
-			model: "pi/default",
-			thinkingLevel: Effort.Medium,
-			hide: true,
-		},
-		template: taskMd,
-	},
 ];
 
 // Computed lazily on first loadBundledAgents() call to avoid eager prompt.render at module load.

package/src/task/index.ts

@@ -55,7 +55,7 @@ import { assertNoRawTaskFields, buildTaskReceipt, buildTaskRoiSummary } from "./
 import { renderResult, renderCall as renderTaskCall } from "./render";
 import { reconcileSpawnRoi } from "./roi-reconciliation";
 import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
-import { DEFAULT_SPAWN_THRESHOLD, evaluateReviewerExploreGate, evaluateSpawnGate } from "./spawn-gate";
+import { DEFAULT_SPAWN_THRESHOLD, evaluateSpawnGate } from "./spawn-gate";
 import {
 	applyNestedPatches,
 	captureBaseline,
@@ -359,7 +359,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 	readonly renderResult = renderResult;
 	readonly #discoveredAgents: AgentDefinition[];
 	readonly #blockedAgent: string | undefined;
-	readonly #spawningAgentType: string | undefined;
 
 	get parameters(): TaskToolSchemaInstance {
 		const isolationEnabled = this.session.settings.get("task.isolation.mode") !== "none";
@@ -391,7 +390,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		discoveredAgents: AgentDefinition[],
 	) {
 		this.#blockedAgent = $env.PI_BLOCKED_AGENT;
-		this.#spawningAgentType = session.currentAgentType;
 		this.#discoveredAgents = discoveredAgents;
 	}
 
@@ -478,23 +476,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			};
 		}
 
-		const reviewerExploreDecision = evaluateReviewerExploreGate({
-			spawningAgentType: this.#spawningAgentType,
-			targetAgent: params.agent,
-			plan: params.spawnPlan,
-		});
-		if (reviewerExploreDecision.outcome === "rejected") {
-			return {
-				content: [
-					{
-						type: "text",
-						text: `Task spawn gate rejected reviewer->explore: ${reviewerExploreDecision.reason}. Provide spawnPlan fields: ${reviewerExploreDecision.missingFields.join(", ")}.`,
-					},
-				],
-				details: { projectAgentsDir: null, results: [], totalDurationMs: 0 },
-			};
-		}
-
 		const manager = AsyncJobManager.instance();
 		if (!manager) {
 			return {
@@ -1083,27 +1064,6 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			};
 		}
 
-		const reviewerExploreDecision = evaluateReviewerExploreGate({
-			spawningAgentType: this.#spawningAgentType,
-			targetAgent: agentName,
-			plan: params.spawnPlan,
-		});
-		if (reviewerExploreDecision.outcome === "rejected") {
-			return {
-				content: [
-					{
-						type: "text",
-						text: `Task spawn gate rejected reviewer->explore: ${reviewerExploreDecision.reason}. Provide spawnPlan fields: ${reviewerExploreDecision.missingFields.join(", ")}.`,
-					},
-				],
-				details: {
-					projectAgentsDir,
-					results: [],
-					totalDurationMs: Date.now() - startTime,
-				},
-			};
-		}
-
 		let repoRoot: string | null = null;
 		let baseline: WorktreeBaseline | null = null;
 		if (isIsolated) {