@sayknow-cli/coding-agent 0.2.3 → 0.2.5

package/src/session/agent-session.ts

@@ -44,7 +44,6 @@ import {
 	type EmergencyCompactionSample,
 	emergencyCompactionReason,
 	estimateMessageTokensHeuristic,
-	estimateTokens,
 	generateBranchSummary,
 	generateHandoff,
 	prepareCompaction,
@@ -217,6 +216,11 @@ import { MCPManager } from "../runtime-mcp/manager";
 import { deobfuscateSessionContext, type SecretObfuscator } from "../secrets/obfuscator";
 import { formatNoCredentialOnboardingError, formatNoModelOnboardingError } from "../setup/model-onboarding-guidance";
 import { buildSkcRuntimeSessionEnv, consumePendingGoalModeRequest } from "../skc-runtime/goal-mode-request";
+import {
+	assertNonEmptySkcSessionId,
+	modeStatePath as sessionModeStatePath,
+	sessionStateDir,
+} from "../skc-runtime/session-layout";
 import { persistCoordinatorRuntimeStateFromEvent } from "../skc-runtime/session-state-sidecar";
 import { writeArtifact } from "../skc-runtime/state-writer";
 import { requestSkcWorkerIntegrationAttempt } from "../skc-runtime/team-runtime";
@@ -225,7 +229,7 @@ import {
 	readVisibleSkillActiveState,
 	syncSkillActiveState,
 } from "../skill-state/active-state";
-import { assertDeepInterviewMutationAllowed } from "../skill-state/deep-interview-mutation-guard";
+import { assertWorkflowMutationAllowed } from "../skill-state/deep-interview-mutation-guard";
 import { invalidateHostMetadata } from "../ssh/connection-manager";
 import { resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
 import {
@@ -313,13 +317,6 @@ export type AgentSessionEvent =
 	| { type: "thinking_level_changed"; thinkingLevel: ThinkingLevel | undefined }
 	| { type: "goal_updated"; goal: Goal | null; state?: GoalModeState };
 
-/**
- * Safe path component pattern used to validate session-id segments before
- * joining them into `.skc/state` paths. Mirrors the regex used by the
- * `skc state` runtime selector resolver.
- */
-const SAFE_PATH_COMPONENT = /^[A-Za-z0-9_-][A-Za-z0-9._-]{0,63}$/;
-
 function isUnderProjectSkc(cwd: string, targetPath: string): boolean {
 	const relative = path.relative(path.join(path.resolve(cwd), ".skc"), path.resolve(targetPath));
 	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
@@ -1371,21 +1368,17 @@ export class AgentSession {
 	getActiveSkillPhase(): string | undefined {
 		const active = this.#activeSkillState;
 		if (!active) return undefined;
-		// Path safety: refuse to read mode-state files when the skill or
-		// session-id are not safe path components. The `skill` tool
-		// interprets undefined as a non-terminal phase, so chaining is
-		// refused — there is no risk of bypassing the guard via a custom
-		// skill name with `..` or a session-id with separators.
 		if (!isCanonicalSkcWorkflowSkill(active.skill)) return undefined;
-		if (active.sessionId !== undefined && !SAFE_PATH_COMPONENT.test(active.sessionId)) {
-			return undefined;
-		}
+		const sessionId = active.sessionId ?? this.sessionManager.getSessionId();
 		try {
-			const stateDir = path.join(this.sessionManager.getCwd(), ".skc", "state");
-			const segments = active.sessionId
-				? [stateDir, "sessions", encodeURIComponent(active.sessionId).replaceAll(".", "%2E")]
-				: [stateDir];
-			const filePath = path.join(...segments, `${active.skill}-state.json`);
+			assertNonEmptySkcSessionId(sessionId, "AgentSession.getActiveSkillPhase");
+			// Keep the session-state-dir construction explicit here so the chain guard
+			// refuses to fall back to a legacy root `.skc/state` read.
+			const stateDir = sessionStateDir(this.sessionManager.getCwd(), sessionId);
+			const filePath = path.join(
+				stateDir,
+				path.basename(sessionModeStatePath(this.sessionManager.getCwd(), sessionId, active.skill)),
+			);
 			const raw = fs.readFileSync(filePath, "utf-8");
 			const parsed = JSON.parse(raw) as { current_phase?: unknown };
 			return typeof parsed.current_phase === "string" ? parsed.current_phase : undefined;
@@ -1475,7 +1468,7 @@ export class AgentSession {
 			}
 			const sanitized = sanitizeMessage(providerMessages[i]!);
 			if (!sanitized) continue;
-			const messageTokens = estimateTokens(sanitized);
+			const messageTokens = estimateMessageTokensHeuristic(sanitized);
 			if (maxTokens > 0 && approximateTokens + messageTokens > maxTokens) {
 				recordSkip("token-limit");
 				continue;
@@ -3764,7 +3757,7 @@ export class AgentSession {
 	 * prompts or tool execution can run.
 	 */
 	#wrapToolForDeepInterviewMutationGuard<T extends AgentTool>(tool: T): T {
-		if (!["edit", "write", "ast_edit", "bash"].includes(tool.name)) return tool;
+		if (!["edit", "write", "ast_edit"].includes(tool.name)) return tool;
 		return new Proxy(tool, {
 			get: (target, prop) => {
 				if (prop !== "execute") return Reflect.get(target, prop, target);
@@ -3775,7 +3768,7 @@ export class AgentSession {
 					onUpdate: never,
 					ctx: never,
 				) => {
-					await assertDeepInterviewMutationAllowed({
+					await assertWorkflowMutationAllowed({
 						cwd: this.sessionManager.getCwd(),
 						sessionId: this.sessionManager.getSessionId(),
 						tool: target,
@@ -9901,9 +9894,9 @@ export class AgentSession {
 	#estimateContextTokensForCompaction(pendingMessages: readonly AgentMessage[]): {
 		tokens: number;
 	} {
-		const estimate = this.#estimateContextTokensWith(message => this.#estimateMessageNativeContextTokens(message));
+		const estimate = this.#estimateContextTokensWith(message => this.#estimateMessageCompactionDeltaTokens(message));
 		return {
-			tokens: estimate.tokens + this.#estimateMessagesNativeContextTokens(pendingMessages),
+			tokens: estimate.tokens + this.#estimateMessagesCompactionDeltaTokens(pendingMessages),
 		};
 	}
 
@@ -9949,10 +9942,10 @@ export class AgentSession {
 		};
 	}
 
-	#estimateMessagesNativeContextTokens(messages: readonly AgentMessage[]): number {
+	#estimateMessagesCompactionDeltaTokens(messages: readonly AgentMessage[]): number {
 		let tokens = 0;
 		for (const message of messages) {
-			tokens += this.#estimateMessageNativeContextTokens(message);
+			tokens += this.#estimateMessageCompactionDeltaTokens(message);
 		}
 		return tokens;
 	}
@@ -9965,11 +9958,17 @@ export class AgentSession {
 		return tokens;
 	}
 
-	#nativeTokenCache = new WeakMap<AgentMessage, { len: number; tokens: number }>();
+	/**
+	 * Conservative inflation applied to the native-free chars/4 estimate of the
+	 * UNSENT context delta. chars/4 undercounts dense code/CJK, so we bias high
+	 * to compact slightly early rather than overflow the model window before the
+	 * next provider response re-anchors the exact count.
+	 */
+	#compactionDeltaInflation = 1.2;
+	#compactionDeltaTokenCache = new WeakMap<AgentMessage, { len: number; tokens: number }>();
 
-	/** Cheap content-size signal to invalidate the native token cache on mutation (growth). */
 	/**
-	 * Cheap content-size signal to invalidate the native token cache on mutation. Recursively
+	 * Cheap content-size signal to invalidate the compaction-delta token cache on mutation. Recursively
 	 * sums string lengths across the whole message (depth-bounded), so it covers every
 	 * provider-visible shape (text/thinking/tool args, toolResult output, tool names, etc.)
 	 * without allocating a serialized copy. A size-preserving in-place edit yields only a
@@ -9992,19 +9991,22 @@ export class AgentSession {
 		return 0;
 	}
 
-	#estimateMessageNativeContextTokens(message: AgentMessage): number {
-		// F10/F22: cache the expensive native token count per message object, invalidated by a
-		// cheap content-size signal, so unchanged (stable-size) messages are not re-tokenized on
-		// every pre-prompt estimate. A rare size-preserving in-place edit yields only a benign
-		// token-estimate drift, never wrong output.
+	#estimateMessageCompactionDeltaTokens(message: AgentMessage): number {
+		// Provider usage anchors the already-sent context (see calculatePromptTokens); this
+		// estimates only the UNSENT delta with the native-free chars/4 heuristic, inflated by
+		// #compactionDeltaInflation so dense input cannot undercount us past the compaction
+		// threshold before the next provider response re-anchors the exact count. Cached per
+		// message object, invalidated by a cheap content-size signal; a rare size-preserving
+		// in-place edit yields only a benign estimate drift, never wrong output.
 		const len = this.#messageTokenSize(message);
-		const cached = this.#nativeTokenCache.get(message);
+		const cached = this.#compactionDeltaTokenCache.get(message);
 		if (cached && cached.len === len) return cached.tokens;
-		let tokens = 0;
+		let heuristic = 0;
 		for (const llmMessage of convertToLlm([message])) {
-			tokens += estimateTokens(llmMessage);
+			heuristic += estimateMessageTokensHeuristic(llmMessage);
 		}
-		this.#nativeTokenCache.set(message, { len, tokens });
+		const tokens = Math.ceil(heuristic * this.#compactionDeltaInflation);
+		this.#compactionDeltaTokenCache.set(message, { len, tokens });
 		return tokens;
 	}
 

package/src/session/session-manager.ts

@@ -1129,6 +1129,23 @@ function formatTimeAgo(date: Date): string {
 	return date.toLocaleDateString();
 }
 
+async function movePathAcrossDevicesSafe(source: string, destination: string): Promise<void> {
+	try {
+		await fs.promises.rename(source, destination);
+		return;
+	} catch (error) {
+		if (!hasFsCode(error, "EXDEV")) throw error;
+	}
+	const stat = await fs.promises.stat(source);
+	if (stat.isDirectory()) {
+		await fs.promises.cp(source, destination, { recursive: true, force: false, errorOnExist: true });
+		await fs.promises.rm(source, { recursive: true, force: false });
+		return;
+	}
+	await fs.promises.copyFile(source, destination, fs.constants.COPYFILE_EXCL);
+	await fs.promises.unlink(source);
+}
+
 const MAX_PERSIST_CHARS = 500_000;
 const TRUNCATION_NOTICE = "\n\n[Session persistence truncated large content]";
 /** Minimum base64 length to externalize to blob store (skip tiny inline images) */
@@ -2498,14 +2515,14 @@ export class SessionManager {
 			try {
 				// Guard: session file may not exist yet (no assistant messages persisted)
 				if (hadSessionFile) {
-					await fs.promises.rename(oldSessionFile, newSessionFile);
+					await movePathAcrossDevicesSafe(oldSessionFile, newSessionFile);
 					movedSessionFile = true;
 				}
 
 				try {
 					const stat = await fs.promises.stat(oldArtifactDir);
 					if (stat.isDirectory()) {
-						await fs.promises.rename(oldArtifactDir, newArtifactDir);
+						await movePathAcrossDevicesSafe(oldArtifactDir, newArtifactDir);
 						movedArtifactDir = true;
 					}
 				} catch (err) {

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

@@ -29,6 +29,14 @@ The Hermes bridge does not choose a model/provider. Generated setup configures `
 
 Provider-specific commands are examples only, never product defaults.
 
+## Visible routed-session fallback
+
+If a Hermes/OpenClaw/Clawhip-style operator needs a human-visible, channel-routed SKC pane instead of a pure Coordinator MCP session, use the visible session pattern in [`docs/skc-session-clawhip-routing.md`](../../../../../../docs/skc-session-clawhip-routing.md).
+
+Use that pattern only when the router must watch tmux output, send stale-session alerts, or inject follow-up prompts into the same visible pane. The short version is: prepare a dedicated worktree, register a stable tmux session through the host router, start interactive `skc`, wait for TUI readiness, inject the task prompt separately, and verify actual tool/work activity before reporting acceptance.
+
+Do not put private channel ids, mention targets, socket names, tokens, or local routing policy into portable setup output. Keep those in the host/operator deployment.
+
 ## Safety
 
 - Mutating tools require bridge startup mutation classes and per-call consent.

package/src/setup/hermes-setup.ts

@@ -404,7 +404,7 @@ async function installConfig(spec: CoordinatorSetupSpec, force: boolean): Promis
 
 async function runSmoke(spec: CoordinatorSetupSpec): Promise<HermesSetupResult["smoke"]> {
 	const requiredTools = [...COORDINATOR_MCP_TOOL_NAMES];
-	const server = createCoordinatorMcpServer({ env: {} });
+	const server = createCoordinatorMcpServer({ env: renderHermesServerBlock(spec).env as NodeJS.ProcessEnv });
 	const listed = await server.handleJsonRpc({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} });
 	const listedResult = isRecord(listed.result) ? listed.result : {};
 	const tools = Array.isArray(listedResult.tools) ? listedResult.tools : [];

package/src/skc-runtime/deep-interview-recorder.ts

@@ -11,7 +11,8 @@ import {
 	normalizeDeepInterviewEnvelope,
 	questionHash,
 } from "./deep-interview-state";
-import { readExistingStateForMutation, writeWorkflowEnvelopeAtomic } from "./state-writer";
+import { writeSessionActivityMarker } from "./session-resolution";
+import { readExistingStateForMutation, writeGuardedWorkflowEnvelopeAtomic } from "./state-writer";
 
 export * from "./deep-interview-state";
 
@@ -298,6 +299,12 @@ async function readEnvelope(statePath: string): Promise<DeepInterviewStateEnvelo
 	return ensureDeepInterviewStateShape(undefined);
 }
 
+function existingStateRevision(value: unknown): number | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const revision = (value as Record<string, unknown>).state_revision;
+	return typeof revision === "number" && Number.isFinite(revision) ? revision : 0;
+}
+
 function interviewIdOf(envelope: DeepInterviewStateEnvelope): string | undefined {
 	const inner = (envelope.state ?? {}) as Record<string, unknown>;
 	return typeof inner.interview_id === "string" ? inner.interview_id : undefined;
@@ -310,6 +317,7 @@ async function persistEnvelope(
 	sessionId: string | undefined,
 	command: string,
 ): Promise<void> {
+	if (!sessionId) throw new Error("deep-interview recorder requires a session id");
 	const now = new Date().toISOString();
 	const payload: Record<string, unknown> = { ...normalizeDeepInterviewEnvelope(envelope), updated_at: now };
 	// Guarantee RequiredOnWriteEnvelopeSchema fields for the fresh/absent fallback;
@@ -318,11 +326,22 @@ async function persistEnvelope(
 	payload.version ??= WORKFLOW_STATE_VERSION;
 	payload.active ??= true;
 	payload.current_phase ??= "interviewing";
-	await writeWorkflowEnvelopeAtomic(statePath, payload, {
+	const expectedRevision = existingStateRevision(envelope);
+	const writeResult = await writeGuardedWorkflowEnvelopeAtomic(statePath, payload, {
 		cwd,
+		policy: "source",
+		expectedRevision,
 		receipt: { cwd, skill: "deep-interview", owner: "skc-runtime", command, sessionId, nowIso: now },
-		audit: { category: "state", verb: "write", owner: "skc-runtime", skill: "deep-interview" },
+		audit: { category: "state", verb: "write", owner: "skc-runtime", skill: "deep-interview", sessionId },
 	});
+	// Reflect the freshly written revision back onto the in-memory envelope so a
+	// follow-up HUD sync derives its `sourceRevision` from the persisted revision
+	// (not the stale pre-write value), otherwise the active-state writer treats the
+	// newer HUD as stale and skips it (e.g. dropping the ambiguity chip after scoring).
+	if (writeResult.written && typeof expectedRevision === "number") {
+		(envelope as Record<string, unknown>).state_revision = expectedRevision + 1;
+	}
+	await writeSessionActivityMarker(cwd, sessionId, { writer: "deep-interview-recorder", path: statePath });
 }
 
 /**
@@ -335,20 +354,17 @@ async function syncRecorderHud(
 	envelope: DeepInterviewStateEnvelope,
 	sessionId: string | undefined,
 ): Promise<void> {
-	try {
-		const phase = typeof envelope.current_phase === "string" ? envelope.current_phase : "interviewing";
-		await syncSkillActiveState({
-			cwd,
-			skill: "deep-interview",
-			active: phase !== "complete",
-			phase,
-			sessionId,
-			source: "skc-runtime-deep-interview-recorder",
-			hud: deriveDeepInterviewHud(envelope as Record<string, unknown>, { phase }),
-		});
-	} catch {
-		// HUD sync is best-effort cache maintenance and must not change record semantics.
-	}
+	const phase = typeof envelope.current_phase === "string" ? envelope.current_phase : "interviewing";
+	await syncSkillActiveState({
+		cwd,
+		skill: "deep-interview",
+		active: phase !== "complete",
+		phase,
+		sessionId,
+		source: "skc-runtime-deep-interview-recorder",
+		hud: deriveDeepInterviewHud(envelope as Record<string, unknown>, { phase }),
+		sourceRevision: existingStateRevision(envelope),
+	});
 }
 
 /**
@@ -360,6 +376,19 @@ async function repairRecorderHudFromPersisted(
 	cwd: string,
 	statePath: string,
 	sessionId: string | undefined,
+): Promise<void> {
+	try {
+		await syncDeepInterviewRecorderHud(cwd, statePath, sessionId);
+	} catch {
+		// HUD sync is best-effort cache maintenance and must not change record semantics.
+	}
+}
+
+/** Refresh the best-effort HUD cache from persisted deep-interview state. */
+export async function syncDeepInterviewRecorderHud(
+	cwd: string,
+	statePath: string,
+	sessionId: string | undefined,
 ): Promise<void> {
 	const read = await readExistingStateForMutation(statePath);
 	if (read.kind !== "valid") return;
@@ -384,7 +413,11 @@ export async function appendOrMergeDeepInterviewRound(
 	}
 	(envelope.state as Record<string, unknown>).rounds = result.rounds;
 	await persistEnvelope(cwd, statePath, envelope, options.sessionId, "skc deep-interview record-answer");
-	await syncRecorderHud(cwd, envelope, options.sessionId);
+	try {
+		await syncRecorderHud(cwd, envelope, options.sessionId);
+	} catch {
+		// HUD sync is best-effort cache maintenance and must not change record semantics.
+	}
 	return { action: result.action, record: result.record };
 }
 

package/src/skc-runtime/deep-interview-runtime.ts

@@ -7,6 +7,8 @@ import { deriveDeepInterviewHud } from "../skill-state/workflow-hud";
 import { WORKFLOW_STATE_VERSION } from "../skill-state/workflow-state-contract";
 import { normalizeDeepInterviewEnvelope } from "./deep-interview-state";
 import { runNativeRalplanCommand } from "./ralplan-runtime";
+import { modeStatePath, sessionSpecsDir } from "./session-layout";
+import { resolveSkcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { runNativeStateCommand } from "./state-runtime";
 import { appendJsonl, readExistingStateForMutation, writeArtifact, writeWorkflowEnvelopeAtomic } from "./state-writer";
 
@@ -76,10 +78,6 @@ function assertSafePathComponent(value: string, label: string): void {
 	}
 }
 
-function encodeSessionSegment(value: string): string {
-	return encodeURIComponent(value).replaceAll(".", "%2E");
-}
-
 function defaultSpecSlug(now: Date = new Date()): string {
 	const yyyy = now.getUTCFullYear().toString().padStart(4, "0");
 	const mm = (now.getUTCMonth() + 1).toString().padStart(2, "0");
@@ -89,14 +87,10 @@ function defaultSpecSlug(now: Date = new Date()): string {
 	return `${yyyy}-${mm}-${dd}-${hh}${min}-${randomBytes(2).toString("hex")}`;
 }
 
-function stateDirFor(cwd: string, sessionId: string | undefined): string {
-	return sessionId
-		? path.join(cwd, ".skc", "state", "sessions", encodeSessionSegment(sessionId))
-		: path.join(cwd, ".skc", "state");
-}
-
-export function deepInterviewStatePath(cwd: string, sessionId: string | undefined): string {
-	return path.join(stateDirFor(cwd, sessionId), "deep-interview-state.json");
+export function deepInterviewStatePath(cwd: string, sessionId?: string): string {
+	const resolvedSessionId = sessionId?.trim() || process.env.SKC_SESSION_ID?.trim();
+	if (!resolvedSessionId) throw new Error("deep-interview state path requires a session id");
+	return modeStatePath(cwd, resolvedSessionId, "deep-interview");
 }
 
 async function resolveSpecContent(rawSpec: string, cwd: string): Promise<string> {
@@ -117,7 +111,7 @@ interface ResolvedDeepInterviewArgs {
 	resolution: DeepInterviewResolution;
 	threshold: number;
 	thresholdSource: string;
-	sessionId?: string;
+	sessionId: string;
 	idea: string;
 	language?: DeepInterviewLanguagePreference;
 	json: boolean;
@@ -134,7 +128,7 @@ export interface ResolvedDeepInterviewSpecWriteArgs {
 	stage: "final";
 	slug: string;
 	spec: string;
-	sessionId?: string;
+	sessionId: string;
 	json: boolean;
 	deliberate: boolean;
 	handoff?: "ralplan";
@@ -277,8 +271,12 @@ async function resolveSpecWriteArgs(args: readonly string[], cwd: string): Promi
 		throw new DeepInterviewCommandError(2, "--spec is required for deep-interview --write");
 	}
 
-	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
-	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+	const session = resolveSkcSessionForWrite(cwd, {
+		flagValue: flagValue(args, "--session-id"),
+		envSessionId: process.env.SKC_SESSION_ID,
+	});
+	const sessionId = session.skcSessionId;
+	assertSafePathComponent(sessionId, "session-id");
 
 	const rawHandoff = flagValue(args, "--handoff")?.trim() || undefined;
 	if (rawHandoff && rawHandoff !== "ralplan") {
@@ -324,8 +322,12 @@ async function resolveSpecWriteArgs(args: readonly string[], cwd: string): Promi
 }
 
 async function resolveDeepInterviewArgs(args: readonly string[], cwd: string): Promise<ResolvedDeepInterviewArgs> {
-	const sessionId = flagValue(args, "--session-id")?.trim() || undefined;
-	if (sessionId) assertSafePathComponent(sessionId, "session-id");
+	const session = resolveSkcSessionForWrite(cwd, {
+		flagValue: flagValue(args, "--session-id"),
+		envSessionId: process.env.SKC_SESSION_ID,
+	});
+	const sessionId = session.skcSessionId;
+	assertSafePathComponent(sessionId, "session-id");
 
 	const explicitResolutions = (["quick", "standard", "deep"] as const).filter(name => hasFlag(args, `--${name}`));
 	if (explicitResolutions.length > 1) {
@@ -402,19 +404,34 @@ export async function persistDeepInterviewSpec(
 	}
 	const existing = existingRead.kind === "valid" ? existingRead.value : {};
 
-	const specPath = path.join(cwd, ".skc", "specs", `deep-interview-${resolved.slug}.md`);
+	const specPath = path.join(sessionSpecsDir(cwd, resolved.sessionId), `deep-interview-${resolved.slug}.md`);
 	const content = resolved.spec.endsWith("\n") ? resolved.spec : `${resolved.spec}\n`;
 	await writeArtifact(specPath, content, {
 		cwd,
-		audit: { category: "artifact", verb: "write", owner: "skc-runtime", skill: "deep-interview" },
+		audit: {
+			category: "artifact",
+			verb: "write",
+			owner: "skc-runtime",
+			skill: "deep-interview",
+			sessionId: resolved.sessionId,
+		},
 	});
 
 	const sha256 = createHash("sha256").update(content).digest("hex");
 	const createdAt = new Date().toISOString();
 	await appendJsonl(
-		path.join(cwd, ".skc", "specs", "deep-interview-index.jsonl"),
+		path.join(sessionSpecsDir(cwd, resolved.sessionId), "deep-interview-index.jsonl"),
 		{ slug: resolved.slug, stage: resolved.stage, path: specPath, created_at: createdAt, sha256 },
-		{ cwd, audit: { category: "ledger", verb: "append", owner: "skc-runtime", skill: "deep-interview" } },
+		{
+			cwd,
+			audit: {
+				category: "ledger",
+				verb: "append",
+				owner: "skc-runtime",
+				skill: "deep-interview",
+				sessionId: resolved.sessionId,
+			},
+		},
 	);
 
 	const payload = normalizeDeepInterviewEnvelope({
@@ -446,9 +463,11 @@ export async function persistDeepInterviewSpec(
 			verb: "write",
 			owner: "skc-runtime",
 			skill: "deep-interview",
+			sessionId: resolved.sessionId,
 			forced: resolved.force,
 		},
 	});
+	await writeSessionActivityMarker(cwd, resolved.sessionId, { writer: "deep-interview-runtime", path: statePath });
 	await syncDeepInterviewHud({
 		cwd,
 		sessionId: resolved.sessionId,
@@ -503,8 +522,15 @@ async function seedDeepInterviewState(cwd: string, resolved: ResolvedDeepIntervi
 			sessionId: resolved.sessionId,
 			nowIso: now,
 		},
-		audit: { category: "state", verb: "write", owner: "skc-runtime", skill: "deep-interview" },
+		audit: {
+			category: "state",
+			verb: "write",
+			owner: "skc-runtime",
+			skill: "deep-interview",
+			sessionId: resolved.sessionId,
+		},
 	});
+	await writeSessionActivityMarker(cwd, resolved.sessionId, { writer: "deep-interview-runtime", path: statePath });
 	await syncDeepInterviewHud({ cwd, sessionId: resolved.sessionId, payload, phase: "interviewing" });
 	return statePath;
 }

package/src/skc-runtime/goal-mode-request.ts

@@ -8,6 +8,8 @@ import {
 	type ModeChangeEntry,
 	type SessionEntry,
 } from "../session/session-manager";
+import { sessionStateDir, sessionUltragoalDir } from "./session-layout";
+import { resolveSkcSessionForRead, resolveSkcSessionForWrite, writeSessionActivityMarker } from "./session-resolution";
 import { removeFileAudited, writeJsonAtomic } from "./state-writer";
 
 export const SKC_SESSION_FILE_ENV = "SKC_SESSION_FILE";
@@ -48,12 +50,12 @@ function isEnoent(error: unknown): boolean {
 	);
 }
 
-function requestPath(cwd: string): string {
-	return path.join(cwd, ".skc", "state", "goal-mode-request.json");
+function requestPath(cwd: string, sessionId: string): string {
+	return path.join(sessionStateDir(cwd, sessionId), "goal-mode-request.json");
 }
 
-function ultragoalGoalsPath(cwd: string): string {
-	return path.join(cwd, ".skc", "ultragoal", "goals.json");
+function ultragoalGoalsPath(cwd: string, sessionId: string): string {
+	return path.join(sessionUltragoalDir(cwd, sessionId), "goals.json");
 }
 
 function isCreateGoalsArg(value: string): boolean {
@@ -65,8 +67,14 @@ export function isUltragoalCreateGoalsInvocation(args: readonly string[]): boole
 	return command !== undefined && isCreateGoalsArg(command);
 }
 
-export async function readUltragoalSkcObjective(cwd: string): Promise<{ objective: string; goalsPath: string }> {
-	const goalsPath = ultragoalGoalsPath(cwd);
+export async function readUltragoalSkcObjective(
+	cwd: string,
+	sessionId?: string | null,
+): Promise<{ objective: string; goalsPath: string }> {
+	const session = sessionId?.trim()
+		? { skcSessionId: sessionId.trim() }
+		: await resolveSkcSessionForRead(cwd, { envSessionId: process.env.SKC_SESSION_ID });
+	const goalsPath = ultragoalGoalsPath(cwd, session.skcSessionId);
 	try {
 		const plan = (await Bun.file(goalsPath).json()) as UltragoalPlanShape;
 		const objective = typeof plan.skcObjective === "string" ? plan.skcObjective.trim() : "";
@@ -87,7 +95,10 @@ export async function writePendingGoalModeRequest(input: {
 }): Promise<PendingGoalModeRequest> {
 	const objective = input.objective.trim();
 	if (!objective) throw new Error("goal objective is required");
-	const sessionId = input.sessionId?.trim();
+	const resolvedSessionId =
+		input.sessionId?.trim() ||
+		resolveSkcSessionForWrite(input.cwd, { envSessionId: process.env.SKC_SESSION_ID }).skcSessionId;
+	const sessionId = resolvedSessionId;
 	const request: PendingGoalModeRequest = {
 		version: REQUEST_VERSION,
 		kind: "goal_mode_request",
@@ -97,11 +108,12 @@ export async function writePendingGoalModeRequest(input: {
 		goalsPath: input.goalsPath,
 		...(sessionId ? { sessionId } : {}),
 	};
-	const filePath = requestPath(input.cwd);
+	const filePath = requestPath(input.cwd, sessionId);
 	await writeJsonAtomic(filePath, request, {
 		cwd: input.cwd,
-		audit: { category: "state", verb: "write", owner: "skc-runtime" },
+		audit: { category: "state", verb: "write", owner: "skc-runtime", sessionId },
 	});
+	await writeSessionActivityMarker(input.cwd, sessionId, { writer: "goal-mode-request", path: filePath });
 	return request;
 }
 
@@ -175,7 +187,10 @@ export async function consumePendingGoalModeRequest(
 	cwd: string,
 	currentSessionId?: string | null,
 ): Promise<PendingGoalModeRequest | null> {
-	const filePath = requestPath(cwd);
+	const session = currentSessionId?.trim()
+		? { skcSessionId: currentSessionId.trim() }
+		: await resolveSkcSessionForRead(cwd, { envSessionId: process.env.SKC_SESSION_ID });
+	const filePath = requestPath(cwd, session.skcSessionId);
 	let raw: unknown;
 	try {
 		raw = await Bun.file(filePath).json();
@@ -203,7 +218,7 @@ export async function consumePendingGoalModeRequest(
 	}
 	await removeFileAudited(filePath, {
 		cwd,
-		audit: { category: "prune", verb: "remove", owner: "skc-runtime" },
+		audit: { category: "prune", verb: "remove", owner: "skc-runtime", sessionId: session.skcSessionId },
 	}).catch(error => {
 		if (!isEnoent(error)) throw error;
 	});