@sayknow-cli/coding-agent 0.5.1 → 0.5.6

package/src/config/settings.ts

@@ -39,6 +39,7 @@ import { AgentStorage } from "../session/agent-storage";
 import { type EditMode, normalizeEditMode } from "../utils/edit-mode";
 import {
 	type AtomicYamlPatch,
+	AtomicYamlRetargetError,
 	applyAtomicYamlPatches,
 	applyAtomicYamlPatchesWithCurrent,
 	atomicYamlPathHash,
@@ -830,22 +831,28 @@ export class Settings implements NotificationSettingsReader {
 		if (this.#modified.size > 0 && !this.#pendingSaveSlot) this.#queueSave();
 		this.#releasePendingSaveSlot();
 		const observedSave = this.#savePromise;
+		let saveError: unknown;
 		try {
 			await observedSave;
-		} catch {
+		} catch (error) {
 			// Historical flush() behavior logs background failures but does not reject.
+			saveError = error;
 		}
+		if (saveError instanceof AtomicYamlRetargetError) return;
 		// A failed predecessor may settle just before a new mutation observes its
 		// still-reserved slot. Explicit flush owns one fresh attempt for remaining
 		// dirty patches instead of leaving them stranded or retrying forever.
 		if (this.#modified.size > 0 && this.#savePromise === observedSave) {
 			if (!this.#pendingSaveSlot) this.#queueSave();
 			this.#releasePendingSaveSlot();
+			let retryError: unknown;
 			try {
 				await this.#savePromise;
-			} catch {
+			} catch (error) {
 				// Keep dirty state for a later explicit flush or mutation.
+				retryError = error;
 			}
+			if (retryError instanceof AtomicYamlRetargetError) return;
 		}
 		await this.#refreshDurableSettings();
 		if (this.#modified.size > 0 && !this.#pendingSaveSlot) {
@@ -871,6 +878,7 @@ export class Settings implements NotificationSettingsReader {
 			saveError = error;
 		}
 		await this.#refreshDurableSettings();
+		if (saveError instanceof AtomicYamlRetargetError) throw saveError;
 		if (this.#modified.size > 0 && !this.#pendingSaveSlot) {
 			this.#queueSave();
 			this.#releasePendingSaveSlot();
@@ -1721,6 +1729,9 @@ export class Settings implements NotificationSettingsReader {
 					logger.warn("Settings: refresh after background save failure failed", { error: String(refreshError) });
 				}
 				throw error;
+			})
+			.finally(() => {
+				if (this.#pendingSaveSlot === slot) this.#pendingSaveSlot = undefined;
 			});
 		this.#savePromise = save;
 		void save.catch(() => {});

package/src/config/telegram-autostart.ts

@@ -10,11 +10,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getConfigRootDir, isCompiledBinary, logger } from "@sayknow-cli/utils";
-import { settings } from "./settings";
+import { settings as globalSettings, type Settings } from "./settings";
 import type { TelegramSettings } from "./settings-schema";
 import { telegramSettingsToEnv, validateTelegramSettings } from "./telegram-env-bridge";
 
-function readTelegramSettings(): TelegramSettings {
+/**
+ * The startup command runs against an explicit Settings instance (tests and
+ * embedders inject one), so read through it instead of the global proxy —
+ * which may not be initialized at all on those paths.
+ */
+type TelegramSettingsSource = Pick<Settings, "get">;
+
+function readTelegramSettings(settings: TelegramSettingsSource): TelegramSettings {
 	return {
 		enabled: settings.get("telegram.enabled"),
 		botToken: settings.get("telegram.botToken"),
@@ -69,10 +76,10 @@ function isAlreadyRunning(pidFile: string): boolean {
  * it in the background. Never throws — failures are logged as warnings so the
  * main skc session is unaffected.
  */
-export async function maybeAutostartTelegramRemote(): Promise<void> {
+export async function maybeAutostartTelegramRemote(settings: TelegramSettingsSource = globalSettings): Promise<void> {
 	if (!settings.get("telegram.enabled")) return;
 
-	const config = readTelegramSettings();
+	const config = readTelegramSettings(settings);
 	const errors = validateTelegramSettings(config);
 	if (errors.length > 0) {
 		logger.warn("Telegram Remote enabled but misconfigured, skipping autostart", { errors });

package/src/dap/client.ts

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import * as fs from "node:fs/promises";
-import { logger } from "@sayknow-cli/utils";
+import { isKnownSinkPeerClosedError, logger } from "@sayknow-cli/utils";
 import { formatCrashDiagnosticNotice, writeCrashReport } from "../debug/crash-diagnostics";
 import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
 import { type OwnedProcess, spawnOwnedProcess } from "../runtime/process-lifecycle";
@@ -62,9 +62,9 @@ function parseMessage(
 
 async function writeMessage(sink: DapWriteSink, message: DapRequestMessage | DapResponseMessage): Promise<void> {
 	const content = JSON.stringify(message);
-	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n`);
-	sink.write(content);
-	await sink.flush();
+	const frame = `Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n${content}`;
+	await Promise.resolve(sink.write(frame));
+	await Promise.resolve(sink.flush());
 }
 
 function toErrorMessage(value: unknown): string {
@@ -98,6 +98,9 @@ export class DapClient {
 	#messageBuffer = Buffer.alloc(0);
 	#isReading = false;
 	#disposed = false;
+	#terminalError: Error | undefined;
+	#disposePromise: Promise<void> | undefined;
+	#writeQueue: Promise<void> = Promise.resolve();
 	#lastActivity = Date.now();
 	#capabilities?: DapCapabilities;
 	#eventHandlers = new Map<string, Set<DapEventHandler>>();
@@ -119,6 +122,18 @@ export class DapClient {
 		this.#socket = options?.socket;
 	}
 
+	#queueWriteMessage(message: DapRequestMessage | DapResponseMessage): Promise<void> {
+		const write = this.#writeQueue
+			.catch(() => {})
+			.then(() => {
+				if (this.#terminalError) throw this.#terminalError;
+				if (this.#disposed) throw new Error(`DAP adapter ${this.adapter.name} is not running`);
+				return writeMessage(this.#writeSink, message);
+			});
+		this.#writeQueue = write.catch(() => {});
+		return write;
+	}
+
 	static async spawn({ adapter, cwd }: DapSpawnOptions): Promise<DapClient> {
 		if (adapter.connectMode === "socket") {
 			return DapClient.#spawnSocket({ adapter, cwd });
@@ -142,7 +157,7 @@ export class DapClient {
 		proc.exited.then(() => {
 			client.#handleProcessExit();
 		});
-		void client.#startMessageReader();
+		void client.startMessageReader();
 		return client;
 	}
 
@@ -199,7 +214,7 @@ export class DapClient {
 			transport = await connectSocket({ unix: socketPath }, 10_000);
 			const client = new DapClient(adapter, cwd, owner, transport);
 			proc.exited.then(() => client.#handleProcessExit());
-			void client.#startMessageReader();
+			void client.startMessageReader();
 			return client;
 		} catch (err) {
 			transport?.socket.end();
@@ -268,7 +283,7 @@ export class DapClient {
 		const { readable, writeSink, socket } = wrapBunSocket(rawSocket);
 		const client = new DapClient(adapter, cwd, owner, { readable, writeSink, socket });
 		proc.exited.then(() => client.#handleProcessExit());
-		void client.#startMessageReader();
+		void client.startMessageReader();
 		return client;
 	}
 
@@ -364,6 +379,7 @@ export class DapClient {
 		signal?: AbortSignal,
 		timeoutMs: number = DEFAULT_REQUEST_TIMEOUT_MS,
 	): Promise<TBody> {
+		if (this.#terminalError) throw this.#terminalError;
 		if (signal?.aborted) {
 			throw signal.reason instanceof Error ? signal.reason : new ToolAbortError();
 		}
@@ -412,10 +428,11 @@ export class DapClient {
 		});
 		this.#lastActivity = Date.now();
 		try {
-			await writeMessage(this.#writeSink, request);
+			await this.#queueWriteMessage(request);
 		} catch (error) {
 			this.#pendingRequests.delete(requestSeq);
 			cleanup();
+			if (isKnownSinkPeerClosedError(error)) throw this.#terminalizeTransport(error);
 			throw error;
 		}
 		return promise;
@@ -431,37 +448,30 @@ export class DapClient {
 			...(message ? { message } : {}),
 			...(body !== undefined ? { body } : {}),
 		};
-		await writeMessage(this.#writeSink, response);
+		await this.#queueWriteMessage(response);
 	}
 
 	async dispose(): Promise<void> {
-		if (this.#disposed) return;
-		this.#disposed = true;
-		this.#rejectPendingRequests(new Error(`DAP adapter ${this.adapter.name} disposed`));
-		try {
-			this.#socket?.end();
-		} catch {
-			/* socket may already be closed */
-		}
-		try {
-			await this.#owner.dispose();
-			await this.#owner.awaitExit({ timeoutMs: 1_000 });
-		} catch (error) {
-			logger.debug("Failed to dispose DAP adapter", {
-				adapter: this.adapter.name,
-				error: toErrorMessage(error),
-			});
+		if (!this.#disposed) {
+			const error = new Error(`DAP adapter ${this.adapter.name} disposed`);
+			this.#disposed = true;
+			this.#terminalError = error;
+			this.#rejectPendingRequests(error);
 		}
+		await this.#beginOwnerDisposal();
 	}
 
-	async #startMessageReader(): Promise<void> {
+	async startMessageReader(): Promise<void> {
 		if (this.#isReading) return;
 		this.#isReading = true;
 		const reader = this.#readable.getReader();
 		try {
 			while (true) {
 				const { done, value } = await reader.read();
-				if (done) break;
+				if (done) {
+					this.#terminalizeTransport(new Error("DAP readable closed"));
+					break;
+				}
 				const currentBuffer = Buffer.concat([this.#messageBuffer, value]);
 				this.#messageBuffer = currentBuffer;
 				let workingBuffer = currentBuffer;
@@ -482,7 +492,7 @@ export class DapClient {
 				this.#messageBuffer = workingBuffer;
 			}
 		} catch (error) {
-			this.#rejectPendingRequests(new Error(`DAP connection closed: ${toErrorMessage(error)}`));
+			this.#terminalizeTransport(error);
 		} finally {
 			reader.releaseLock();
 			this.#isReading = false;
@@ -523,9 +533,9 @@ export class DapClient {
 		try {
 			const handler = this.#reverseRequestHandlers.get(message.command);
 			if (handler) {
+				let body: unknown;
 				try {
-					const body = await handler(message.arguments);
-					await this.sendResponse(message, true, body);
+					body = await handler(message.arguments);
 				} catch (error) {
 					const errorMessage = toErrorMessage(error);
 					await this.sendResponse(
@@ -539,7 +549,9 @@ export class DapClient {
 						},
 						errorMessage,
 					);
+					return;
 				}
+				await this.sendResponse(message, true, body);
 				return;
 			}
 			const errorMessage = `Unsupported DAP request: ${message.command}`;
@@ -555,6 +567,10 @@ export class DapClient {
 				errorMessage,
 			);
 		} catch (error) {
+			if (isKnownSinkPeerClosedError(error)) {
+				this.#terminalizeTransport(error);
+				return;
+			}
 			logger.warn("Failed to answer DAP adapter request", {
 				adapter: this.adapter.name,
 				command: message.command,
@@ -586,9 +602,41 @@ export class DapClient {
 				? `DAP adapter exited (code ${exitCode}): ${stderr}${diagnosticSuffix}`
 				: `DAP adapter exited unexpectedly (code ${exitCode})${diagnosticSuffix}`,
 		);
+		this.#terminalError = error;
 		this.#rejectPendingRequests(error);
 	}
 
+	#terminalizeTransport(cause: unknown): Error {
+		if (this.#terminalError) return this.#terminalError;
+		const error = new Error(`DAP adapter ${this.adapter.name} transport closed`, { cause });
+		this.#terminalError = error;
+		this.#disposed = true;
+		this.#rejectPendingRequests(error);
+		void this.#beginOwnerDisposal();
+		return error;
+	}
+
+	#beginOwnerDisposal(): Promise<void> {
+		if (this.#disposePromise) return this.#disposePromise;
+		this.#disposePromise = (async () => {
+			try {
+				this.#socket?.end();
+			} catch {
+				/* socket may already be closed */
+			}
+			try {
+				await this.#owner.dispose();
+				await this.#owner.awaitExit({ timeoutMs: 1_000 });
+			} catch (disposeError) {
+				logger.debug("Failed to dispose DAP adapter", {
+					adapter: this.adapter.name,
+					error: toErrorMessage(disposeError),
+				});
+			}
+		})();
+		return this.#disposePromise;
+	}
+
 	#rejectPendingRequests(error: Error): void {
 		for (const pending of this.#pendingRequests.values()) {
 			pending.reject(error);

package/src/defaults/skc/skills/deep-interview/SKILL.md

@@ -26,7 +26,7 @@ Deep Interview implements Ouroboros-inspired Socratic questioning with mathemati
 <Do_Not_Use_When>
 - User has a detailed, specific request with file paths, function names, or acceptance criteria -- execute directly
 - User wants to explore options or brainstorm -- use `ralplan` skill instead
-- User wants a quick fix or single change -- delegate to executor or execution
+- User wants a quick fix or single change -- delegate to executor or direct execution
 - User says "just do it" or "skip the questions" without an explicit execution path -- respect their intent by ending interview and writing a `pending approval` spec, not by mutating files or delegating execution
 - User already has a PRD or plan file and explicitly asks to execute it -- use the requested execution skill with that plan
 </Do_Not_Use_When>
@@ -128,6 +128,12 @@ If the user request appended after this skill as the final `User:` line is alrea
 
 This gate exists to prevent deep-interview from making easy problems harder. A small verification need does not make a request interview-worthy.
 
+**Implementation wording is not execution approval.** When the user says `implementation`, "implementation plan", Korean `구현`, or "구현 계획", they are describing the eventual target, not permission to implement now. Interpreting that wording as approval is the single most likely way this skill breaks its own boundary.
+
+On that wording: do not implement, edit/write code, launch implementation workers, or start task/skill/ultragoal implementation. Say plainly — "I can interview for an implementation plan, but I won't implement during deep-interview." — and continue clarifying scope, risks, acceptance criteria, and unknowns.
+
+Implementation requires an explicit phase transition/approval after the interview: the workflow phase must explicitly transition out of deep-interview, and execution approval must be captured by a downstream execution path (Phase 5's bridge into `/skill:ralplan`, `/skill:ultragoal`, or `/skill:team`). Wanting an implementation plan and approving implementation are two different consents.
+
 ## Phase 0.75: Optional Trace Pre-Step
 
 Run this phase only when the active deep-interview state or invocation indicates `--trace` / `state.trace.enabled === true`. It is a pre-interview research step, not an implementation phase.
@@ -326,6 +332,20 @@ If any prompt input is too large, summarize it first and then continue from the
 | Context Clarity (brownfield) | "How does this fit?" | "I found JWT auth middleware in `src/auth/` (pattern: passport + JWT). Should this feature extend that path or intentionally diverge from it?" |
 | Scope-fuzzy / ontology stress | "What IS the core thing here?" | "You have named Tasks, Projects, and Workspaces across the last rounds. Which one is the core entity, and which are supporting views or containers?" |
 
+**Attach your own guess to every question.** The question exposes the *user's* assumptions; the guess exposes *yours*. Without it the interview only ever audits one side, and the agent's unexamined read of the ask silently steers the next round's targeting.
+
+Every generated question MUST carry a one-line `GUESS:` — your hypothesis for the answer, the reason you hold it, and what changes if it is wrong:
+
+```
+{question}
+GUESS: {your hypothesis} — {why you hold it}. If it is {the other reading} instead, {what changes}.
+```
+
+- Reacting is cheaper than generating: a terse "no, the second one" still carries a full correction, so low-effort answers stop being low-information rounds.
+- A visible guess is falsifiable. Being wrong out loud is the point; guess in the direction you expect pushback when the reading is genuinely contested.
+- A guess is NOT an auto-answer. It never resolves the round, never feeds scoring, and never increments `auto_answer_streak` — only the user's answer does.
+- Skip only when a guess would be pure noise: Round 0 topology confirmation, the Phase 4b restate gate, and clarification re-asks.
+
 ### Step 2a′: Auto-Research Greenfield Questions
 
 When the next question is for a greenfield interview and is tagged `research: true`, load `auto-research-greenfield.md` as an internal `kind: "skill-fragment"` prompt for a fork-context architect before Step 2b. Pass only the tagged question, locked topology summary, prompt-safe initial idea, trimmed prior decisions/gaps, and relevant constraints. The architect must return 2-3 ranked candidates with rationale, confidence, and fallback notes. Validate the shape before use; if valid, incorporate the candidates as concise answer options or context for the single user-facing question and append the round number to `auto_researched_rounds`. If invalid or unavailable, fall back silently to the normal generated question and increment `architect_failures`.
@@ -340,14 +360,19 @@ Use the `ask` tool with the generated question. When a question has options, you
 Round {n} | Component: {target_component_name} | Targeting: {weakest_dimension} | Why now: {one_sentence_targeting_rationale} | Ambiguity: {score}%
 
 {question}
+GUESS: {your hypothesis} — {why you hold it}. If it is {the other reading} instead, {what changes}.
 ```
 
 Options should include contextually relevant choices plus free-text, translated/localized according to `language.instruction` when present.
 
-After applying `language.instruction` to the visible question, options, and generated rationale, apply the self-proofread once to new prose only; preserve only the Round/Component/Targeting/Ambiguity line structure, fixed labels, numeric ambiguity value, component/target identifiers, and `deepInterview.*` metadata keys. Do not exempt generated natural-language rationale such as Why now.
+After applying `language.instruction` to the visible question, options, and generated rationale, apply the self-proofread once to new prose only; preserve only the Round/Component/Targeting/Ambiguity line structure, fixed labels (including the `GUESS:` marker), numeric ambiguity value, component/target identifiers, and `deepInterview.*` metadata keys. Do not exempt generated natural-language rationale such as Why now or the guess text that follows the `GUESS:` marker.
 
 When calling `ask`, SHOULD include optional structured metadata so the runtime can record the round without manual state writes: `deepInterview.round_id?`, `deepInterview.round`, `deepInterview.component`, `deepInterview.dimension`, and `deepInterview.ambiguity`. Keep this metadata aligned with the visible Round/Component/Targeting/Ambiguity line; if metadata cannot be supplied, the legacy formatted question text remains the fallback.
 
+**Non-behavioral adapter context (`confused_terms`, `references`).** `deepInterview.confused_terms` and `deepInterview.references` carry vocabulary and citations queued at interview start. They are inert: they MUST NOT alter the first question, are never inferred from vocabulary density, and a reference's `url`/`excerpt` are strings that are **never auto-fetched**. Bounds enforced at the ask boundary: at most 32 terms and 32 references, adapter strings ≤ 256 characters, `url`/`excerpt` ≤ 2048, and core round metadata (`round_id`, `component`, `dimension`) ≤ 128 — all counted in Unicode code points, so emoji-padded input hits the same ceiling as ASCII.
+
+**Free-text vs structural input (`FREETEXT_FIELDS`).** The runtime keeps an allowlist of fields that legitimately carry prose — `initial_context`, `initial_idea`, `initial_context_summary`, `user_response`, `answer`, `goal`, `objective`, `prompt`, `description`, `statement`, `restated_goal`, `evidence`, `excerpt`. Inside those fields, shell metacharacters (`;`, `|`, `&`, backticks, `$()`) are valid prose and MUST NOT be rejected as structural injection; a user is allowed to describe a shell command. Structural fields (ids, categories, hashes) stay strictly validated by their own guards. Size is capped by character-count, not byte length: 50,000 for initial context and 10,000 for a single user response.
+
 If the `ask` tool returns `clarificationQuestion`, treat it as a non-answer about the displayed choices. Answer the clarification briefly from the current interview context, then call `ask` again with the exact original question, options, and `deepInterview.*` metadata. A clarification bypasses Step 2b′ auto-answer, Step 2b″ free-text refine, Step 2c ambiguity scoring, Step 2d progress reporting, and Step 2e state updates; it must not be recorded as a round answer. This does not violate the one-question-per-round rule because the round remains unresolved until the user submits a real listed option or `Other` answer.
 
 ### Step 2b′: Auto-Answer Opted-Out Questions
@@ -504,7 +529,7 @@ Round {n} complete.
 
 Apply `language.instruction` when present before showing this progress report so status text, gaps, and next-target phrasing stay in the preserved session language.
 
-Then apply the self-proofread once (DIPP-5) to narrative status text, generated prose cells, gaps, and next-target phrasing; preserve only table structure, fixed status labels, scores, weights, component ids, and trigger tokens.
+Then apply the self-proofread once to narrative status text, generated prose cells, gaps, and next-target phrasing; preserve only table structure, fixed status labels, scores, weights, component ids, and trigger tokens.
 
 ### Step 2e: Update State
 
@@ -927,6 +952,7 @@ Why bad: 45% ambiguity means nearly half the requirements are unclear. The mathe
 - [ ] Oversized initial context/history summarized before scoring, question generation, spec generation, or handoff
 - [ ] Round 0 topology gate completed before scoring; `topology.confirmed_at` persisted
 - [ ] Ambiguity scored and displayed every round, naming the weakest component/dimension target (rotating across active components when N > 1)
+- [ ] Every asked question carried a `GUESS:` line (except Round 0 topology, the Restate gate, and clarification re-asks), and no guess was recorded as an answer or counted toward `auto_answer_streak`
 - [ ] Lateral panel convened at milestone transitions (and before synthesizing agent-supplied answers) with parallel read-only personas
 - [ ] Free-text answers passed the Refine gate; dialectic rhythm guard forced a user question after 3 agent-resolved answers; any auto-answer threshold crossing explicitly confirmed
 - [ ] Closure / Acceptance Guard and the one-sentence Restate gate both passed before crystallization