@sayknow-cli/coding-agent 0.2.7 → 0.3.1

package/src/daemon/control-types.ts

@@ -0,0 +1,65 @@
+/**
+ * Public types for the `skc daemon` control plane.
+ *
+ * Deliberately compact: a small result/status surface plus a built-in
+ * controller contract. There is exactly one daemon kind today (`telegram`);
+ * a richer registry is intentionally deferred until a second kind exists.
+ */
+
+export type DaemonKind = "telegram";
+
+export type DaemonAction = "list" | "status" | "stop" | "reload";
+
+export type DaemonHealth = "not_configured" | "stopped" | "running" | "stale" | "stopping" | "error";
+
+export interface DaemonRuntimeInfo {
+	/** `source` when respawn goes through bun/node + the entry script; `compiled` for a single-file binary. */
+	mode: "source" | "compiled";
+	execPath: string;
+	/** True only in source/dev mode, where a respawn loads amended TypeScript directly. */
+	reloadPicksUpSourceEdits: boolean;
+	/** Present when the runtime mode constrains what reload can achieve (e.g. compiled binary). */
+	warning?: string;
+}
+
+export interface DaemonStatus {
+	kind: DaemonKind;
+	configured: boolean;
+	health: DaemonHealth;
+	pid?: number;
+	ownerId?: string;
+	startedAt?: number;
+	heartbeatAt?: number;
+	roots?: string[];
+	rootCount?: number;
+	runtime: DaemonRuntimeInfo;
+	detail?: string;
+}
+
+export interface DaemonOperationOptions {
+	/** How long to wait for cooperative release before escalating. */
+	gracefulTimeoutMs?: number;
+	/** How long to wait for the old pid to die after SIGKILL. */
+	killTimeoutMs?: number;
+	/** Allow hard-kill escalation / acting on a still-live owner. */
+	force?: boolean;
+	/** For reload: spawn a fresh owner even when none is currently running. */
+	spawnIfStopped?: boolean;
+}
+
+export interface DaemonOperationResult {
+	kind: DaemonKind;
+	action: Exclude<DaemonAction, "list">;
+	ok: boolean;
+	before?: DaemonStatus;
+	after?: DaemonStatus;
+	warnings: string[];
+	message: string;
+}
+
+export interface BuiltInDaemonController {
+	readonly kind: DaemonKind;
+	status(): Promise<DaemonStatus>;
+	stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+	reload(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
+}

package/src/daemon/runtime.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared source-vs-compiled runtime detection for daemon spawning.
+ *
+ * Centralizes the logic previously embedded in `ensureTelegramDaemonRunning`
+ * so session autostart, reload, and status reporting agree on how a daemon
+ * process is launched and whether a reload can pick up amended source.
+ */
+
+import * as path from "node:path";
+
+export interface SkcRuntimeSpawnInfo {
+	execPath: string;
+	mode: "source" | "compiled";
+	/** Prefix prepended before the skc subcommand args; `[Bun.main]` in source mode, otherwise `[]`. */
+	argsPrefix: string[];
+	/** True only when respawn loads edited TypeScript directly (source/dev mode). */
+	reloadPicksUpSourceEdits: boolean;
+	/** Set in compiled mode to explain that a rebuild is required before reload picks up source edits. */
+	warning?: string;
+}
+
+const COMPILED_RELOAD_WARNING =
+	"Compiled binary: reload respawns the same binary. Rebuild the binary first for amended source to take effect.";
+
+/**
+ * Resolve how to spawn a detached skc subcommand for the current runtime.
+ *
+ * Source/dev mode (bun/node) prepends the entry script (`Bun.main`) so the
+ * respawn loads edited source. A compiled single-file binary self-spawns its
+ * own subcommand directly and cannot pick up workspace source edits.
+ */
+export function resolveSkcRuntimeSpawnInfo(execPath: string = process.execPath): SkcRuntimeSpawnInfo {
+	const base = path.basename(execPath).toLowerCase();
+	const fromSource = base === "bun" || base === "node" || base.startsWith("bun") || base.startsWith("node");
+	const mainScript = fromSource && typeof Bun !== "undefined" ? (Bun as unknown as { main?: string }).main : undefined;
+	if (fromSource) {
+		return {
+			execPath,
+			mode: "source",
+			argsPrefix: mainScript ? [mainScript] : [],
+			reloadPicksUpSourceEdits: true,
+		};
+	}
+	return {
+		execPath,
+		mode: "compiled",
+		argsPrefix: [],
+		reloadPicksUpSourceEdits: false,
+		warning: COMPILED_RELOAD_WARNING,
+	};
+}

package/src/defaults/skc/rules/ponytail.md

@@ -0,0 +1,68 @@
+---
+name: ponytail
+description: "Lazy senior dev mode — always pick the simplest, shortest solution that works (YAGNI, reuse, stdlib/native first), never cutting validation, error handling, security, or accessibility."
+alwaysApply: true
+license: MIT
+source: https://github.com/DietrichGebert/ponytail
+---
+
+# Ponytail — lazy senior dev mode
+
+You write code like the laziest senior dev in the room. Lazy means efficient,
+not careless. The best code is the code you never wrote. This rule governs
+*what* you build, not how you talk.
+
+## The ladder
+
+After you understand the problem, stop at the first rung that holds:
+
+1. **Does this need to exist at all?** Speculative need → skip it, say so in one line (YAGNI).
+2. **Already in this codebase?** A helper, util, type, or pattern that lives here → reuse it. Look before you write; re-implementing what's a few files over is the most common slop.
+3. **Stdlib does it?** Use it.
+4. **Native platform feature covers it?** `<input type="date">` over a picker lib, CSS over JS, DB constraint over app code.
+5. **Already-installed dependency solves it?** Use it. Never add a new dependency for what a few lines can do.
+6. **Can it be one line?** One line.
+7. **Only then:** the minimum code that works.
+
+The ladder runs *after* comprehension, not instead of it. Read the task and the
+code it touches, trace the real flow end to end, then climb. Two rungs work →
+take the higher one and move on.
+
+**Bug fix = root cause, not symptom.** Grep every caller of the function you are
+about to touch. One guard in the shared function is a smaller diff than a guard
+in every caller — and patching only the path the ticket names leaves every
+sibling caller broken.
+
+## Rules
+
+- No unrequested abstractions: no interface with one implementation, no factory for one product, no config for a value that never changes.
+- No boilerplate or scaffolding "for later" — later can scaffold for itself.
+- Deletion over addition. Boring over clever; clever is what someone decodes at 3am.
+- Fewest files possible. Shortest working diff wins — but only once you understand the problem. The smallest change in the wrong place is a second bug, not laziness.
+- Two stdlib options the same size? Take the one that is correct on edge cases.
+- Mark deliberate simplifications with a `ponytail:` comment that names the ceiling and the upgrade path (e.g. `// ponytail: global lock, per-account locks if throughput matters`).
+
+## Output
+
+Code first. Then at most three short lines: what was skipped, when to add it.
+No essays defending a simplification — every paragraph of defense is complexity
+smuggled back in as prose. Explanation the user explicitly asked for (a report,
+a walkthrough) is not debt; give it in full.
+
+Pattern: `[code] → skipped: [X], add when [Y].`
+
+## When NOT to be lazy
+
+Never simplify away: input validation at trust boundaries, error handling that
+prevents data loss, security measures, accessibility basics, or anything
+explicitly requested. Never be lazy about *understanding* the problem — the
+ladder shortens the solution, never the reading. A confident small diff in the
+wrong place is the dangerous kind of lazy.
+
+Non-trivial logic (a branch, loop, parser, money/security path) leaves ONE
+runnable check behind — the smallest thing that fails if the logic breaks. No
+frameworks or fixtures unless asked. Trivial one-liners need no test.
+
+---
+
+Adapted from [ponytail](https://github.com/DietrichGebert/ponytail) (MIT) by DietrichGebert.

package/src/defaults/skc/skills/ralplan/SKILL.md

@@ -47,7 +47,7 @@ Planning artifacts and stage handoffs MUST be persisted through the ralplan CLI
 skc ralplan --write --stage <type> --stage_n <N> --artifact "markdown file path or markdown string"
 ```
 
-Use stage values that match the producer or artifact kind, such as `planner`, `architect`, `critic`, `revision`, `adr`, or `final`. Increment `--stage_n` for each consensus-loop pass. The `--artifact` value may be either a markdown file path prepared outside `.skc/` for ingestion or the markdown content string itself. The native `--write` handler persists markdown under `.skc/_session-{sessionid}/plans/ralplan/<run-id>/stage-<NN>-<stage>.md`, maintains an `index.jsonl` audit log, and for `final` stages additionally writes a `pending-approval.md` copy. Direct `write`, `edit`, or `ast_edit` calls against `.skc/_session-{sessionid}/specs`, `.skc/_session-{sessionid}/plans`, `.skc/_session-{sessionid}/state`, or any other `.skc/` path are forbidden unless an explicit force override is active.
+Use stage values that match the producer or artifact kind, such as `planner`, `architect`, `critic`, `revision`, `post-interview`, `adr`, or `final`. Increment `--stage_n` for each consensus-loop pass. The `--artifact` value may be either a markdown file path prepared outside `.skc/` for ingestion or the markdown content string itself. The native `--write` handler persists markdown under `.skc/_session-{sessionid}/plans/ralplan/<run-id>/stage-<NN>-<stage>.md`, maintains an `index.jsonl` audit log, and for `final` stages additionally writes a `pending-approval.md` copy. Direct `write`, `edit`, or `ast_edit` calls against `.skc/_session-{sessionid}/specs`, `.skc/_session-{sessionid}/plans`, `.skc/_session-{sessionid}/state`, or any other `.skc/` path are forbidden unless an explicit force override is active.
 
 While ralplan is active it is a pre-approval planning phase: product-code mutation tools (`write`/`edit`/`ast_edit`) and product-mutating `bash` (e.g. `tee src/...`, redirects into the project tree) are blocked, exactly like deep-interview. Prefer passing the `--artifact` markdown **inline** (the content string) so no scratch file is needed; this is mandatory for restricted role agents (see below). Only the leader, and only when an artifact is too large to pass inline, may stage it as a file in a system temp directory (`os.tmpdir()`/`$TMPDIR`, `/tmp`, `/var/tmp`) outside the project tree and pass that path — never write scratch files into the repo or `.skc/`. Product code is mutated only after the plan is approved and execution begins.
 
@@ -80,9 +80,16 @@ The consensus workflow:
    d. Return to Critic evaluation
    e. Repeat this loop until Critic returns `APPROVE` or 5 iterations are reached
    f. If 5 iterations are reached without `APPROVE`, present the best version to the user
-6. On Critic approval, mark the plan `pending approval` unless explicit execution approval has already been captured, persist the ADR/final plan via `skc ralplan --write --stage final --stage_n <N> --artifact "..."`, and do not directly edit `.skc/_session-{sessionid}/plans`. *(--interactive only)* If `--interactive` is set, use the `ask` tool to present the plan with approval options (Approve execution via ultragoal (Recommended) / Approve execution via team (only when tmux-based interactive worker parallelization is required) / Compact then return for execution approval / Request changes / Reject). Final plan must include ADR (Decision, Drivers, Alternatives considered, Why chosen, Consequences, Follow-ups). Otherwise, output the final plan and stop before any mutation or delegation.
-7. *(--interactive only)* User chooses: Approve ultragoal execution (recommended), Approve team execution (tmux parallelization only), Request changes, or Reject
-8. *(--interactive only)* On approval: invoke `/skill:ultragoal` for execution by default; invoke `/skill:team` only when the user explicitly needs tmux-based interactive worker parallelization -- never implement directly
+6. **Post-ralplan interview** (intent reconciliation gate): After Critic returns `APPROVE` and before the plan is finalized, reconcile the consensus plan against the user's actual intent. The goal is to make sure ralplan did not silently bake in assumptions that conflict with what the user wants.
+   a. **Collect open items** from the run: every assumption the Planner/Architect/Critic resolved by assumption rather than by stated fact, every ambiguity flagged during review, and every decision the loop made without explicit user input. Source these from the persisted `planner`/`architect`/`critic`/`revision` stage artifacts, not from memory.
+   b. **Cross-check prior context for conflicts**: glob `.skc/_session-{sessionid}/specs/deep-interview-*.md` and other prior specs/plans/context relevant by topic. For each, list points where the consensus plan contradicts, weakens, or expands beyond a previously crystallized decision, constraint, or non-goal. Cite the conflicting artifact and line/section.
+   c. **Reconcile with the user**:
+      - *(--interactive only)* Use the `ask` tool to confirm the open assumptions and conflicts **one at a time**, weakest/highest-impact first, polishing intent. If any confirmation reveals that the plan diverges from user intent, route the consolidated correction back into the re-review loop (step 5b Planner revision) and re-run Architect + Critic before returning here. Cap at the same 5-iteration ceiling.
+      - *(automated mode)* Do not ask. Embed every unconfirmed assumption and every detected prior-context conflict into the final plan under an **## Intent Reconciliation** section as explicit open confirmations the user must review at the `pending approval` gate, so nothing is silently assumed.
+   d. Persist the reconciliation with `skc ralplan --write --stage post-interview --stage_n <N> --artifact "..." --json`, then return the receipt/path plus a compact status (reconciled-clean / reconciled-with-revision / open-confirmations-pending) instead of pasting the full body.
+7. On reconciliation completion, mark the plan `pending approval` unless explicit execution approval has already been captured, persist the ADR/final plan via `skc ralplan --write --stage final --stage_n <N> --artifact "..."`, and do not directly edit `.skc/_session-{sessionid}/plans`. *(--interactive only)* If `--interactive` is set, use the `ask` tool to present the plan with approval options (Approve execution via ultragoal (Recommended) / Approve execution via team (only when tmux-based interactive worker parallelization is required) / Compact then return for execution approval / Request changes / Reject). Final plan must include ADR (Decision, Drivers, Alternatives considered, Why chosen, Consequences, Follow-ups) and, when present, the **## Intent Reconciliation** section. Otherwise, output the final plan and stop before any mutation or delegation.
+8. *(--interactive only)* User chooses: Approve ultragoal execution (recommended), Approve team execution (tmux parallelization only), Request changes, or Reject
+9. *(--interactive only)* On approval: invoke `/skill:ultragoal` for execution by default; invoke `/skill:team` only when the user explicitly needs tmux-based interactive worker parallelization -- never implement directly
 
    Before invoking `/skill:team` or `/skill:ultragoal`, mark ralplan ready for handoff so the skill tool's chain guard permits the transition:
 

package/src/defaults/skc/skills/ultragoal/SKILL.md

@@ -107,6 +107,21 @@ Loop until `skc ultragoal status` reports all goals complete:
    `skc ultragoal checkpoint --goal-id <id> --status blocked --evidence "<completed legacy SKC goal blocks goal create in this thread>" --skc-goal-json <goal-get-json-or-path>`
 11. Resume failed goals with `skc ultragoal complete-goals --retry-failed`.
 
+## Blocker triage and pause discipline
+
+An active Ultragoal run must not give up on a blocker by pausing the goal and asking the user. Classify every blocker before deciding what to do, and default to `resolvable` when unsure:
+
+- **`resolvable`** — anything the agent can act on: failing tests, missing implementation, a dependency to install, an ambiguous-but-inferable detail, investigation. **Never pause.** Exhaust autonomous resolution first: investigate, `skc ultragoal steer --kind add_subgoal --title "Investigate blocker" --objective "..." --evidence "..." --rationale "..."`, delegate an `executor`, or preserve the blocker durably with `skc ultragoal checkpoint --status blocked` / `skc ultragoal record-review-blockers` and keep scheduling the next goal.
+- **`human_blocked`** — only the user can act: credentials/secrets, a manual or physical step, an external approval/decision, access the agent lacks. Pause is the last resort and is gated.
+
+`goal({"op":"pause"})` is **blocked at runtime** while an Ultragoal run is active unless the latest durable ledger event classifies the current blocker as `human_blocked`. To pause, record the classification immediately before pausing and cite the human-only dependency as evidence:
+
+```sh
+skc ultragoal classify-blocker --classification human_blocked --evidence "<the specific human-only dependency>" [--goal-id <id>]
+```
+
+Recording `--classification resolvable` is an audit note only; it never authorizes a pause. The `ask` tool stays blocked during active runs regardless of classification — record unresolved decisions as durable blockers instead of prompting.
+
 ## Dynamic steering
 
 Use `skc ultragoal steer` when real findings or blockers prove the current story decomposition should change while the aggregate objective and constraints stay fixed. Steering is explicit-only and evidence-backed; broad natural-language requests are rejected instead of guessed.
@@ -199,6 +214,7 @@ An ultragoal story cannot be checkpointed `complete` until the active agent has
    - CLI surfaces require runtime argv replay: `replaySafe: true`, an allowlisted argv `command`, and replayed normalized stdout matching `recordedStdout`; unsafe commands require audited `replayExempt` metadata with exact fields `reasonCode`, `reason`, `approvedBy`, and `fallbackArtifactRefs` plus a structurally valid fallback artifact. Allowed `reasonCode` values are exactly `unsafe_side_effect`, `requires_credentials`, `requires_network`, `non_deterministic_external`, `destructive`, `interactive_only`, and `platform_unavailable`.
    - Native/desktop/tui surfaces require a structurally valid screenshot, PTY capture with terminal control codes, or app-automation transcript.
    - API/package/algorithm/math surfaces require a real artifact file or typed receipt. Bare `inlineEvidence` text alone is not sufficient for any surface.
+   - The mandatory **computer-use** red-team suite (`kill-switch-bypass`, `suspended-enforcement`, `permission-revoked`, …) is conditional, not universal: require it only when computer/desktop control is genuinely part of the product surface being dogfooded. For every other product type, prove the change through the matching live surface instead — browser-use automation for web/GUI, bash/CLI live invocation or argv replay for CLI, and real artifacts or typed receipts for API/package/algorithm/math. Editing docs, prompts, or skills that merely mention computer-use does not by itself make the computer-use suite applicable; pick the red-team surface that matches what the change actually ships.
 7. The executor QA/red-team lane must report a matrix using `executorQa.contractCoverage`, `executorQa.surfaceEvidence`, `executorQa.adversarialCases`, and `executorQa.artifactRefs`. Not-applicable rows are allowed only in `contractCoverage` and `surfaceEvidence`; each `status: "not_applicable"` row requires `contractRef` plus `reason`. `adversarialCases` rows cannot be not-applicable.
 8. Run a final code review pass and fold it into the strict quality gate. Clean means `architectReview.architectureStatus`, `architectReview.productStatus`, and `architectReview.codeStatus` are all `"CLEAR"`, `architectReview.recommendation` is `"APPROVE"`, executor QA statuses are `"passed"`, iteration is `"passed"` with `fullRerun: true`, every evidence field is non-empty, every required matrix row is present, and every blockers array is empty. `COMMENT`, `WATCH`, `REQUEST CHANGES`, `BLOCK`, missing evidence, missing or shallow matrix rows, plan/code mismatches, or non-empty blockers are non-clean.
 9. If any lane finds an issue, do **not** checkpoint `complete` and do **not** call `goal({"op":"complete"})`. Record durable blocker work instead:

package/src/edit/modes/replace.ts

@@ -42,7 +42,7 @@ let scoreSequenceFuzzyNative:
 let findBestFuzzyMatchNative:
 	| ((content: string, target: string, threshold: number) => NativeBestFuzzyMatchResult)
 	| undefined;
-void import("../../../../natives/native/index.js")
+void import("@sayknow-cli/natives")
 	.then(mod => {
 		if (typeof mod.h02ScoreSequenceFuzzy === "function") {
 			scoreSequenceFuzzyNative = mod.h02ScoreSequenceFuzzy;

package/src/extensibility/extensions/runner.ts

@@ -6,6 +6,7 @@ import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMeta
 import type { KeyId } from "@sayknow-cli/tui";
 import { logger } from "@sayknow-cli/utils";
 import type { ModelRegistry } from "../../config/model-registry";
+import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/unattended-session";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { SessionManager } from "../../session/session-manager";
 import type {
@@ -180,6 +181,7 @@ export class ExtensionRunner {
 	#getContextUsageFn: () => ContextUsage | undefined = () => undefined;
 	#compactFn: (instructionsOrOptions?: string | CompactOptions) => Promise<void> = async () => {};
 	#getSystemPromptFn: () => string[] = () => [];
+	#getWorkflowGateFn: () => WorkflowGateEmitter | undefined = () => undefined;
 	#newSessionHandler: NewSessionHandler = async () => ({ cancelled: false });
 	#branchHandler: BranchHandler = async () => ({ cancelled: false });
 	#navigateTreeHandler: NavigateTreeHandler = async () => ({ cancelled: false });
@@ -234,6 +236,7 @@ export class ExtensionRunner {
 		this.#hasPendingMessagesFn = contextActions.hasPendingMessages;
 		this.#shutdownHandler = contextActions.shutdown;
 		this.#getSystemPromptFn = contextActions.getSystemPrompt;
+		this.#getWorkflowGateFn = contextActions.getWorkflowGate ?? (() => undefined);
 
 		// Command context actions (optional, only for interactive mode)
 		if (commandContextActions) {
@@ -463,6 +466,7 @@ export class ExtensionRunner {
 			shutdown: () => this.#shutdownHandler(),
 			getSystemPrompt: () => this.#getSystemPromptFn(),
 			hasQueuedMessages: () => this.#hasPendingMessagesFn(), // deprecated alias
+			workflowGate: this.#getWorkflowGateFn(),
 		};
 	}
 

package/src/extensibility/extensions/types.ts

@@ -32,6 +32,7 @@ import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { CustomEditor } from "../../modes/components/custom-editor";
+import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/unattended-session";
 import type { Theme } from "../../modes/theme/theme";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
@@ -310,6 +311,11 @@ export interface ExtensionContext {
 	getSystemPrompt(): string[];
 	/** @deprecated Use hasPendingMessages() instead */
 	hasQueuedMessages(): boolean;
+	/**
+	 * Unattended workflow-gate bridge. Present only when the session runs in
+	 * unattended/RPC mode; `undefined` in interactive/TUI mode (notify-only).
+	 */
+	workflowGate?: WorkflowGateEmitter;
 }
 
 /**
@@ -1234,6 +1240,8 @@ export interface ExtensionContextActions {
 	getContextUsage: () => ContextUsage | undefined;
 	compact: (instructionsOrOptions?: string | CompactOptions) => Promise<void>;
 	getSystemPrompt: () => string[];
+	/** Unattended workflow-gate bridge (present only in unattended/RPC mode). */
+	getWorkflowGate?: () => WorkflowGateEmitter | undefined;
 }
 
 /** Actions for ExtensionCommandContext (ctx.* in command handlers). */

package/src/extensibility/shared-events.ts

@@ -217,6 +217,7 @@ export interface AutoCompactionEndEvent {
 	errorMessage?: string;
 	/** True when compaction was skipped for a benign reason (no model, no candidates, nothing to compact). */
 	skipped?: boolean;
+	continuationSkipReason?: "auto_continue_disabled_non_resumable_tail";
 }
 
 /** Fired when auto-retry starts */

package/src/goals/tools/goal-tool.ts

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme, ThemeColor } from "../../modes/theme/theme";
 import goalDescription from "../../prompts/tools/goal.md" with { type: "text" };
-import { assertCanCompleteCurrentGoal } from "../../skc-runtime/ultragoal-guard";
+import { assertCanCompleteCurrentGoal, assertUltragoalPauseAllowed } from "../../skc-runtime/ultragoal-guard";
 import { formatDuration } from "../../slash-commands/helpers/format";
 import type { ToolSession } from "../../tools";
 import { formatErrorMessage, TRUNCATE_LENGTHS } from "../../tools/render-utils";
@@ -94,6 +94,11 @@ async function executeGoalOperation(session: ToolSession, params: GoalToolInput)
 		return buildGoalToolResponse(resumed.goal);
 	}
 	if (params.op === "pause") {
+		try {
+			await assertUltragoalPauseAllowed(session.cwd);
+		} catch (error) {
+			throw new ToolError(error instanceof Error ? error.message : String(error));
+		}
 		const paused = await runtime.pauseGoal();
 		return buildGoalToolResponse(paused?.goal ?? null);
 	}
@@ -102,7 +107,11 @@ async function executeGoalOperation(session: ToolSession, params: GoalToolInput)
 		return buildGoalToolResponse(dropped ?? null);
 	}
 	try {
-		await assertCanCompleteCurrentGoal({ cwd: session.cwd, currentGoal: session.getGoalModeState?.()?.goal ?? null });
+		await assertCanCompleteCurrentGoal({
+			cwd: session.cwd,
+			currentGoal: session.getGoalModeState?.()?.goal ?? null,
+			sessionId: session.getSessionId?.(),
+		});
 	} catch (error) {
 		throw new ToolError(error instanceof Error ? error.message : String(error));
 	}

package/src/hashline/hash.ts

@@ -9,7 +9,7 @@ import bigrams from "./bigrams.json" with { type: "json" };
 // module evaluation so this core module (and its re-exported helpers) stays
 // usable and falls back to the TS loop if the native addon is unavailable.
 let formatHashLinesNative: ((text: string, startLine?: number) => string) | undefined;
-void import("../../../natives/native/index.js")
+void import("@sayknow-cli/natives")
 	.then(mod => {
 		if (typeof mod.h06FormatHashLines === "function") {
 			formatHashLinesNative = mod.h06FormatHashLines;

package/src/i18n/messages/de.ts

@@ -30,6 +30,7 @@ export const de: Partial<Record<MsgKey, string>> = {
 	"settings.tab.appearance": "Darstellung",
 	"settings.tab.model": "Modell",
 	"settings.tab.interaction": "Interaktion",
+	"settings.tab.notifications": "Benachrichtigungen",
 	"settings.tab.context": "Kontext",
 	"settings.tab.memory": "Speicher",
 	"settings.tab.editing": "Bearbeitung",

package/src/i18n/messages/en.ts

@@ -37,6 +37,7 @@ export const en = {
 	"settings.tab.appearance": "Appearance",
 	"settings.tab.model": "Model",
 	"settings.tab.interaction": "Interaction",
+	"settings.tab.notifications": "Notifications",
 	"settings.tab.context": "Context",
 	"settings.tab.memory": "Memory",
 	"settings.tab.editing": "Editing",

package/src/i18n/messages/es.ts

@@ -30,6 +30,7 @@ export const es: Partial<Record<MsgKey, string>> = {
 	"settings.tab.appearance": "Apariencia",
 	"settings.tab.model": "Modelo",
 	"settings.tab.interaction": "Interacción",
+	"settings.tab.notifications": "Notificaciones",
 	"settings.tab.context": "Contexto",
 	"settings.tab.memory": "Memoria",
 	"settings.tab.editing": "Edición",

package/src/i18n/messages/fr.ts

@@ -30,6 +30,7 @@ export const fr: Partial<Record<MsgKey, string>> = {
 	"settings.tab.appearance": "Apparence",
 	"settings.tab.model": "Modèle",
 	"settings.tab.interaction": "Interaction",
+	"settings.tab.notifications": "Notifications",
 	"settings.tab.context": "Contexte",
 	"settings.tab.memory": "Mémoire",
 	"settings.tab.editing": "Édition",

package/src/i18n/messages/ja.ts

@@ -28,6 +28,7 @@ export const ja: Partial<Record<MsgKey, string>> = {
 	"settings.tab.appearance": "外観",
 	"settings.tab.model": "モデル",
 	"settings.tab.interaction": "操作",
+	"settings.tab.notifications": "通知",
 	"settings.tab.context": "コンテキスト",
 	"settings.tab.memory": "メモリ",
 	"settings.tab.editing": "編集",

package/src/i18n/messages/ko.ts

@@ -28,6 +28,7 @@ export const ko: Partial<Record<MsgKey, string>> = {
 	"settings.tab.appearance": "외관",
 	"settings.tab.model": "모델",
 	"settings.tab.interaction": "상호작용",
+	"settings.tab.notifications": "알림",
 	"settings.tab.context": "컨텍스트",
 	"settings.tab.memory": "메모리",
 	"settings.tab.editing": "편집",

package/src/i18n/messages/zh.ts

@@ -28,6 +28,7 @@ export const zh: Partial<Record<MsgKey, string>> = {
 	"settings.tab.appearance": "外观",
 	"settings.tab.model": "模型",
 	"settings.tab.interaction": "交互",
+	"settings.tab.notifications": "通知",
 	"settings.tab.context": "上下文",
 	"settings.tab.memory": "记忆",
 	"settings.tab.editing": "编辑",