@nghyane/arcane 0.1.16 → 0.1.17

package/src/patch/hashline.ts

@@ -566,6 +566,37 @@ export function validateLineRef(ref: { line: number; hash: string }, fileLines:
 // Edit Application
 // ═══════════════════════════════════════════════════════════════════════════
 
+/**
+ * Detect suspicious Unicode escape placeholders in edit lines.
+ * LLMs sometimes emit literal `\uDDDD` strings instead of actual Unicode characters.
+ * Returns a warning message if detected, undefined otherwise.
+ */
+function detectUnicodeEscapePlaceholders(lines: string[]): string | undefined {
+	for (const line of lines) {
+		if (/\\u[0-9A-Fa-f]{4}/.test(line)) {
+			return "Warning: edit content contains literal Unicode escape sequences (\\uXXXX). These may be intended as actual Unicode characters.";
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Auto-correct escaped tab indentation in edit lines.
+ * When enabled via ARCANE_HASHLINE_AUTOCORRECT_ESCAPED_TABS=1, replaces
+ * leading `\\t` sequences (literal backslash-t from JSON) with real tab characters.
+ */
+function autocorrectEscapedTabs(lines: string[]): string[] {
+	if (Bun.env.ARCANE_HASHLINE_AUTOCORRECT_ESCAPED_TABS !== "1") {
+		return lines;
+	}
+	return lines.map(line => {
+		const match = line.match(/^((?:\\t)+)/);
+		if (!match) return line;
+		const tabCount = match[1].length / 2; // each \\t is 2 chars
+		return "\t".repeat(tabCount) + line.slice(match[1].length);
+	});
+}
+
 /**
  * Apply an array of hashline edits to file content.
  *
@@ -599,6 +630,16 @@ export function applyHashlineEdits(
 
 	const autocorrect = Bun.env.ARCANE_HL_AUTOCORRECT === "1";
 
+	// Collect warnings and auto-correct edit content
+	const warnings: string[] = [];
+	for (const edit of edits) {
+		const unicodeWarning = detectUnicodeEscapePlaceholders(edit.content);
+		if (unicodeWarning && !warnings.includes(unicodeWarning)) {
+			warnings.push(unicodeWarning);
+		}
+		edit.content = autocorrectEscapedTabs(edit.content);
+	}
+
 	function collectExplicitlyTouchedLines(): Set<number> {
 		const touched = new Set<number>();
 		for (const edit of edits) {
@@ -914,6 +955,7 @@ export function applyHashlineEdits(
 	return {
 		content: finalContent,
 		firstChangedLine,
+		...(warnings.length > 0 ? { warnings } : {}),
 		...(noopEdits.length > 0 ? { noopEdits } : {}),
 	};
 

package/src/prompts/system/system-prompt.md

@@ -162,6 +162,20 @@ Best practices:
 - Run multiple sub-agents concurrently if tasks are independent with disjoint write targets.
 {{/has}}
 
+### Cross-session Knowledge
+
+Tools: `find_thread`, `read_thread`, `save_memory`
+**Proactive search triggers** — use `find_thread` when:
+- User mentions past work: "we did this before", "last time", "in a previous session"
+- User asks "what did we do about X" or "how did we solve Y"
+- Task seems related to work that may have been done before
+- Handoff context references a parent thread and you need more detail
+**Do NOT search when:**
+- Question is about current session context
+- Generic coding question with no project-specific history
+- User explicitly provides all needed context
+**save_memory**: only when user says "remember this" or states a clear preference. If unsure, ask.
+
 ### Verification
 After completing changes, verify using commands from AGENTS.md or the project's config. Format → typecheck/lint → test (if relevant) → build (if required).
 Report evidence concisely: counts, pass/fail, error summary.
@@ -252,16 +266,6 @@ Scan descriptions vs task domain — read skill if ≥50% likely relevant.
 </rules>
 {{/if}}
 
-{{#if memories.length}}
-<memories>
-{{#each memories}}
-<memory path="{{path}}">
-{{content}}
-</memory>
-{{/each}}
-</memories>
-{{/if}}
-
 {{#if preloadedSkills.length}}
 {{#each preloadedSkills}}
 <skill name="{{name}}">

package/src/prompts/thread-extract.md

@@ -0,0 +1,16 @@
+You are helping extract relevant information from a conversation thread based on a goal.
+
+## Task
+
+I am providing a conversation thread rendered as markdown, along with a goal describing what information to extract.
+
+Your job is to:
+1. Analyze the thread content
+2. Identify information that is relevant to the goal
+3. Extract and preserve those relevant parts with full fidelity
+
+## Rules
+- Be concise but complete — include all relevant details
+- Preserve code snippets, file paths, commands, and decisions exactly as they appear
+- Omit pleasantries, failed attempts, and thinking-out-loud unless the goal asks for them
+- If nothing relevant is found, say so briefly

package/src/prompts/tools/render-mermaid.md

@@ -0,0 +1,9 @@
+Convert Mermaid graph source into ASCII diagram output.
+
+Parameters:
+- `mermaid` (required): Mermaid graph text to render.
+- `config` (optional): JSON render configuration (spacing and layout options).
+Behavior:
+- Returns ASCII diagram text.
+- Saves full ASCII output to an artifact URL (`artifact://<id>`) when artifact storage is available.
+- Returns an error when the Mermaid input is invalid or rendering fails.

package/src/sdk.ts

@@ -42,13 +42,11 @@ import {
 	ArtifactProtocolHandler,
 	DocsProtocolHandler,
 	InternalUrlRouter,
-	MemoryProtocolHandler,
 	RuleProtocolHandler,
 	SkillProtocolHandler,
 } from "./internal-urls";
 import { disposeAllKernelSessions } from "./ipy/executor";
 import { discoverAndLoadMCPTools, type MCPManager, type MCPToolsLoadResult } from "./mcp";
-import { buildMemoryToolDeveloperInstructions, getMemoryRoot, startMemoryStartupTask } from "./memories";
 import { collectEnvSecrets, loadSecrets, obfuscateMessages, SecretObfuscator } from "./secrets";
 import { AgentSession } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";
@@ -735,7 +733,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		settings,
 	};
 
-	// Initialize internal URL router for internal protocols (agent://, artifact://, memory://, skill://, rule://)
+	// Initialize internal URL router for internal protocols (agent://, artifact://, skill://, rule://)
 	const internalRouter = new InternalUrlRouter();
 	const getArtifactsDir = () => {
 		const sessionFile = sessionManager.getSessionFile();
@@ -743,11 +741,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	};
 	internalRouter.register(new AgentProtocolHandler({ getArtifactsDir }));
 	internalRouter.register(new ArtifactProtocolHandler({ getArtifactsDir }));
-	internalRouter.register(
-		new MemoryProtocolHandler({
-			getMemoryRoot: () => getMemoryRoot(agentDir, settings.getCwd()),
-		}),
-	);
 	internalRouter.register(
 		new SkillProtocolHandler({
 			getSkills: () => skills,
@@ -1027,7 +1020,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
-		const memoryInstructions = await buildMemoryToolDeveloperInstructions(agentDir, settings);
 		const defaultPrompt = await buildSystemPromptInternal({
 			cwd,
 			skills,
@@ -1037,7 +1029,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			toolNames,
 			rules: rulebookRules,
 			skillsSettings: settings.getGroup("skills") as SkillsSettings,
-			appendSystemPrompt: memoryInstructions,
 		});
 
 		if (options.systemPrompt === undefined) {
@@ -1054,7 +1045,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				rules: rulebookRules,
 				skillsSettings: settings.getGroup("skills") as SkillsSettings,
 				customPrompt: options.systemPrompt,
-				appendSystemPrompt: memoryInstructions,
 			});
 		}
 		return options.systemPrompt(defaultPrompt);
@@ -1258,14 +1248,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
-	startMemoryStartupTask({
-		session,
-		settings,
-		modelRegistry,
-		agentDir,
-		isSubagent,
-	});
-
 	return {
 		session,
 		extensionsResult,

package/src/session/agent-session.ts

@@ -2067,9 +2067,10 @@ Be thorough - include exact file paths, function names, error messages, and tech
 				return undefined;
 			}
 
-			// Start a new session
+			// Start a new session with parent reference
+			const parentThreadId = this.sessionManager.getSessionId();
 			await this.sessionManager.flush();
-			await this.sessionManager.newSession();
+			await this.sessionManager.newSession({ parentSession: parentThreadId });
 			this.agent.reset();
 			this.agent.sessionId = this.sessionManager.getSessionId();
 			this.#steeringMessages = [];
@@ -2078,7 +2079,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			this.#todoReminderCount = 0;
 
 			// Inject the handoff document as a custom message
-			const handoffContent = `<handoff-context>\n${handoffText}\n</handoff-context>\n\nThe above is a handoff document from a previous session. Use this context to continue the work seamlessly.`;
+			const handoffContent = `<handoff-context thread="${parentThreadId}">\n${handoffText}\n</handoff-context>\n\nThe above is a handoff document from thread \`${parentThreadId}\`. Use this context to continue the work seamlessly. If you need additional details not covered above, use \`read_thread("${parentThreadId}", "your specific question")\` to query the original session.`;
 			this.sessionManager.appendCustomMessageEntry("handoff", handoffContent, true);
 
 			// Rebuild agent messages from session

package/src/session/retry-utils.ts

@@ -17,7 +17,7 @@ export function isRetryableErrorMessage(errorMessage: string): boolean {
  * Check if an error message indicates a usage/billing limit (non-transient).
  */
 export function isUsageLimitErrorMessage(errorMessage: string): boolean {
-	return /usage.?limit|usage_limit_reached|limit_reached/i.test(errorMessage);
+	return /usage.?limit|usage_limit_reached|limit_reached|quota.?exhaust/i.test(errorMessage);
 }
 
 /**

package/src/session/session-index.ts

@@ -0,0 +1,329 @@
+import { Database, type Statement } from "bun:sqlite";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logger, parseJsonlLenient } from "@nghyane/arcane-utils";
+import { getAgentDir } from "@nghyane/arcane-utils/dirs";
+
+export interface SessionIndexEntry {
+	sessionId: string;
+	title: string;
+	firstMessage: string;
+	files: string;
+	cwd: string;
+	createdAt: number;
+	messageCount: number;
+}
+
+export interface SessionSearchResult {
+	threadId: string;
+	title: string;
+	date: string;
+	messageCount: number;
+	snippet: string;
+}
+
+interface SearchRow {
+	session_id: string;
+	title: string;
+	created_at: number;
+	message_count: number;
+	snippet: string;
+}
+
+const FILE_PATH_PARAMS = new Set(["path", "file", "filePath", "glob", "pattern", "command_working_directory"]);
+
+export class SessionIndex {
+	#db: Database;
+	static #instance?: SessionIndex;
+
+	#upsertStmt: Statement;
+	#hasStmt: Statement;
+
+	private constructor(dbPath: string) {
+		const dir = path.dirname(dbPath);
+		fs.mkdirSync(dir, { recursive: true });
+
+		this.#db = new Database(dbPath);
+
+		this.#db.exec(`
+PRAGMA journal_mode=WAL;
+PRAGMA synchronous=NORMAL;
+PRAGMA busy_timeout=5000;
+
+CREATE TABLE IF NOT EXISTS session_index (
+    session_id TEXT PRIMARY KEY,
+    title TEXT,
+    first_message TEXT,
+    files TEXT,
+    cwd TEXT,
+    created_at INTEGER,
+    message_count INTEGER
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS session_fts USING fts5(
+    title, first_message, files,
+    content='session_index', content_rowid='rowid'
+);
+
+CREATE TRIGGER IF NOT EXISTS session_index_ai AFTER INSERT ON session_index BEGIN
+    INSERT INTO session_fts(rowid, title, first_message, files)
+    VALUES (new.rowid, new.title, new.first_message, new.files);
+END;
+
+CREATE TRIGGER IF NOT EXISTS session_index_ad AFTER DELETE ON session_index BEGIN
+    INSERT INTO session_fts(session_fts, rowid, title, first_message, files)
+    VALUES ('delete', old.rowid, old.title, old.first_message, old.files);
+END;
+
+CREATE TRIGGER IF NOT EXISTS session_index_au AFTER UPDATE ON session_index BEGIN
+    INSERT INTO session_fts(session_fts, rowid, title, first_message, files)
+    VALUES ('delete', old.rowid, old.title, old.first_message, old.files);
+    INSERT INTO session_fts(rowid, title, first_message, files)
+    VALUES (new.rowid, new.title, new.first_message, new.files);
+END;
+`);
+
+		this.#upsertStmt = this.#db.prepare(
+			"INSERT OR REPLACE INTO session_index (session_id, title, first_message, files, cwd, created_at, message_count) VALUES (?, ?, ?, ?, ?, ?, ?)",
+		);
+		this.#hasStmt = this.#db.prepare("SELECT 1 FROM session_index WHERE session_id = ?");
+	}
+
+	static open(dbPath: string = path.join(getAgentDir(), "session-index.db")): SessionIndex {
+		if (!SessionIndex.#instance) {
+			SessionIndex.#instance = new SessionIndex(dbPath);
+		}
+		return SessionIndex.#instance;
+	}
+
+	upsert(entry: SessionIndexEntry): void {
+		try {
+			this.#upsertStmt.run(
+				entry.sessionId,
+				entry.title,
+				entry.firstMessage,
+				entry.files,
+				entry.cwd,
+				entry.createdAt,
+				entry.messageCount,
+			);
+		} catch (error) {
+			logger.error("SessionIndex upsert failed", { error: String(error) });
+		}
+	}
+
+	has(sessionId: string): boolean {
+		return this.#hasStmt.get(sessionId) != null;
+	}
+
+	search(query: string, limit: number): SessionSearchResult[] {
+		const safeLimit = Math.min(Math.max(1, Math.floor(limit)), 50);
+		const { ftsQuery, afterTs, beforeTs } = this.#parseQuery(query);
+		if (!ftsQuery) return [];
+
+		const conditions = ["session_fts MATCH ?"];
+		const params: (string | number)[] = [ftsQuery];
+
+		if (afterTs != null) {
+			conditions.push("si.created_at >= ?");
+			params.push(afterTs);
+		}
+		if (beforeTs != null) {
+			conditions.push("si.created_at <= ?");
+			params.push(beforeTs);
+		}
+		params.push(safeLimit);
+
+		const sql = `SELECT si.session_id, si.title, si.created_at, si.message_count,
+       snippet(session_fts, -1, '<match>', '</match>', '...', 32) as snippet
+FROM session_fts f
+JOIN session_index si ON si.rowid = f.rowid
+WHERE ${conditions.join(" AND ")}
+ORDER BY si.created_at DESC
+LIMIT ?`;
+
+		try {
+			const rows = this.#db.prepare(sql).all(...params) as SearchRow[];
+			return rows.map(row => ({
+				threadId: row.session_id,
+				title: row.title || "Untitled",
+				date: new Date(row.created_at * 1000).toISOString().slice(0, 10),
+				messageCount: row.message_count,
+				snippet: row.snippet || "",
+			}));
+		} catch (error) {
+			logger.error("SessionIndex search failed", { error: String(error) });
+			return [];
+		}
+	}
+
+	async indexSessionFile(filePath: string): Promise<void> {
+		try {
+			const content = await Bun.file(filePath).text();
+			const entries = parseJsonlLenient<Record<string, unknown>>(content);
+			if (entries.length === 0) return;
+
+			const header = entries.find(e => e.type === "session") as
+				| { type: string; id?: string; title?: string; cwd?: string; timestamp?: string }
+				| undefined;
+			if (!header?.id) return;
+
+			let firstMessage = "";
+			let messageCount = 0;
+			const fileSet = new Set<string>();
+
+			for (const entry of entries) {
+				if (entry.type !== "message") continue;
+				const msg = entry.message as { role?: string; content?: unknown } | undefined;
+				if (!msg?.role) continue;
+
+				messageCount++;
+
+				if (msg.role === "user" && !firstMessage) {
+					firstMessage = extractTextContent(msg.content);
+				}
+
+				if (msg.role === "assistant") {
+					extractFilePaths(msg.content, fileSet);
+				}
+			}
+
+			const title = header.title || firstMessage.slice(0, 100) || "Untitled";
+			const createdAt = header.timestamp ? Math.floor(new Date(header.timestamp).getTime() / 1000) : 0;
+
+			this.upsert({
+				sessionId: header.id,
+				title,
+				firstMessage: firstMessage.slice(0, 500),
+				files: [...fileSet].join(" "),
+				cwd: header.cwd || "",
+				createdAt,
+				messageCount,
+			});
+		} catch (error) {
+			logger.warn("SessionIndex indexSessionFile failed", { path: filePath, error: String(error) });
+		}
+	}
+
+	async indexAllSessions(sessionsDir?: string): Promise<void> {
+		const dir = sessionsDir ?? path.join(getAgentDir(), "sessions");
+		let subdirs: string[];
+		try {
+			subdirs = fs.readdirSync(dir);
+		} catch {
+			return;
+		}
+
+		for (const subdir of subdirs) {
+			const subdirPath = path.join(dir, subdir);
+			let stat: fs.Stats;
+			try {
+				stat = fs.statSync(subdirPath);
+			} catch {
+				continue;
+			}
+			if (!stat.isDirectory()) continue;
+
+			let files: string[];
+			try {
+				files = fs.readdirSync(subdirPath).filter(f => f.endsWith(".jsonl"));
+			} catch {
+				continue;
+			}
+
+			for (const file of files) {
+				const filePath = path.join(subdirPath, file);
+				try {
+					const firstLine = await Bun.file(filePath).text();
+					const headerLine = firstLine.split("\n")[0];
+					if (!headerLine) continue;
+					const header = JSON.parse(headerLine) as { id?: string };
+					if (!header.id) continue;
+					if (this.has(header.id)) continue;
+					await this.indexSessionFile(filePath);
+				} catch {}
+			}
+		}
+	}
+
+	#parseQuery(query: string): { ftsQuery: string | null; afterTs: number | null; beforeTs: number | null } {
+		let afterTs: number | null = null;
+		let beforeTs: number | null = null;
+
+		const remaining = query.replace(/\b(after|before):(\S+)/g, (_, dir: string, val: string) => {
+			const ts = this.#parseDate(val);
+			if (ts != null) {
+				if (dir === "after") afterTs = ts;
+				else beforeTs = ts;
+			}
+			return "";
+		});
+
+		const ftsQuery = this.#buildFtsQuery(remaining);
+		return { ftsQuery, afterTs, beforeTs };
+	}
+
+	#parseDate(value: string): number | null {
+		const relMatch = value.match(/^(\d+)([dwm])$/);
+		if (relMatch) {
+			const n = Number.parseInt(relMatch[1], 10);
+			const unit = relMatch[2];
+			const now = Date.now();
+			let ms = 0;
+			if (unit === "d") ms = n * 86400_000;
+			else if (unit === "w") ms = n * 7 * 86400_000;
+			else if (unit === "m") ms = n * 30 * 86400_000;
+			return Math.floor((now - ms) / 1000);
+		}
+
+		const d = new Date(value);
+		if (!Number.isNaN(d.getTime())) {
+			return Math.floor(d.getTime() / 1000);
+		}
+		return null;
+	}
+
+	#buildFtsQuery(query: string): string | null {
+		const tokens = query
+			.trim()
+			.split(/\s+/)
+			.map(t => t.trim())
+			.filter(Boolean);
+
+		if (tokens.length === 0) return null;
+
+		return tokens
+			.map(token => {
+				const escaped = token.replace(/"/g, '""');
+				return `"${escaped}"*`;
+			})
+			.join(" ");
+	}
+}
+
+function extractTextContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		for (const block of content) {
+			if (block && typeof block === "object" && "type" in block && block.type === "text" && "text" in block) {
+				return String(block.text);
+			}
+		}
+	}
+	return "";
+}
+
+function extractFilePaths(content: unknown, fileSet: Set<string>): void {
+	if (!Array.isArray(content)) return;
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		if (!("type" in block) || block.type !== "toolCall") continue;
+		const args = "arguments" in block ? (block.arguments as Record<string, unknown>) : null;
+		if (!args) continue;
+		for (const [key, val] of Object.entries(args)) {
+			if (FILE_PATH_PARAMS.has(key) && typeof val === "string" && val.length > 0) {
+				fileSet.add(val);
+			}
+		}
+	}
+}

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

@@ -349,22 +349,6 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
-	{
-		name: "memory",
-		description: "Inspect and operate memory maintenance",
-		subcommands: [
-			{ name: "view", description: "Show current memory injection payload" },
-			{ name: "clear", description: "Clear persisted memory data and artifacts" },
-			{ name: "reset", description: "Alias for clear" },
-			{ name: "enqueue", description: "Enqueue memory consolidation maintenance" },
-			{ name: "rebuild", description: "Alias for enqueue" },
-		],
-		allowArgs: true,
-		handle: async (command, runtime) => {
-			runtime.ctx.editor.setText("");
-			await runtime.ctx.handleMemoryCommand(command.text);
-		},
-	},
 	{
 		name: "move",
 		description: "Move session to a different working directory",

package/src/task/index.ts

@@ -189,7 +189,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 				modelRegistry: this.session.subagentContext?.modelRegistry,
 				settings: this.session.settings,
 				mcpManager: this.session.subagentContext?.mcpManager,
-				contextFiles: this.session.contextFiles,
+				contextFiles: this.session.contextFiles?.filter(f => !f.path.endsWith("AGENTS.md")),
 				skills: this.session.skills,
 				promptTemplates: this.session.promptTemplates,
 			});

package/src/tools/ask.ts

@@ -111,14 +111,15 @@ interface UIContext {
 	select(
 		prompt: string,
 		options: string[],
-		options_?: { initialIndex?: number; timeout?: number; outline?: boolean },
+		options_?: { initialIndex?: number; timeout?: number; outline?: boolean; signal?: AbortSignal },
 	): Promise<string | undefined>;
-	input(prompt: string): Promise<string | undefined>;
+	input(prompt: string, placeholder?: string, options_?: { signal?: AbortSignal }): Promise<string | undefined>;
 }
 
 interface AskQuestionOptions {
 	/** Timeout in milliseconds, null/undefined to disable */
 	timeout?: number | null;
+	signal?: AbortSignal;
 }
 
 async function askSingleQuestion(
@@ -158,6 +159,7 @@ async function askSingleQuestion(
 				initialIndex: cursorIndex,
 				timeout: timeout ?? undefined,
 				outline: true,
+				signal: options?.signal,
 			});
 			const elapsed = Date.now() - selectionStart;
 			const timedOut = timeout != null && elapsed >= timeout;
@@ -166,7 +168,7 @@ async function askSingleQuestion(
 
 			if (choice === OTHER_OPTION) {
 				if (!timedOut) {
-					const input = await ui.input("Enter your response:");
+					const input = await ui.input("Enter your response:", undefined, { signal: options?.signal });
 					if (input) customInput = input;
 				}
 				break;
@@ -205,9 +207,10 @@ async function askSingleQuestion(
 			timeout: timeout ?? undefined,
 			initialIndex: recommended,
 			outline: true,
+			signal: options?.signal,
 		});
 		if (choice === OTHER_OPTION) {
-			const input = await ui.input("Enter your response:");
+			const input = await ui.input("Enter your response:", undefined, { signal: options?.signal });
 			if (input) customInput = input;
 		} else if (choice) {
 			selectedOptions = [stripRecommendedSuffix(choice)];
@@ -300,7 +303,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails, Them
 				optionLabels,
 				q.multi ?? false,
 				q.recommended,
-				{ timeout },
+				{ timeout, signal: _signal },
 			);
 
 			const details: AskToolDetails = {
@@ -335,7 +338,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails, Them
 				optionLabels,
 				q.multi ?? false,
 				q.recommended,
-				{ timeout },
+				{ timeout, signal: _signal },
 			);
 
 			results.push({

package/src/tools/bash-skill-urls.ts

@@ -9,9 +9,9 @@ const SKILL_URL_PATTERN = /'skill:\/\/[^'\s")`\\]+'|"skill:\/\/[^"\s')`\\]+"|ski
 
 /** Regex to find supported internal URL tokens in command text. */
 const INTERNAL_URL_PATTERN =
-	/'(?:skill|agent|artifact|plan|memory|rule):\/\/[^'\s")`\\]+'|"(?:skill|agent|artifact|plan|memory|rule):\/\/[^"\s')`\\]+"|(?:skill|agent|artifact|plan|memory|rule):\/\/[^\s'")`\\]+/g;
+	/'(?:skill|agent|artifact|plan|rule):\/\/[^'\s")`\\]+'|"(?:skill|agent|artifact|plan|rule):\/\/[^"\s')`\\]+"|(?:skill|agent|artifact|plan|rule):\/\/[^\s'")`\\]+/g;
 
-const SUPPORTED_INTERNAL_SCHEMES = ["skill", "agent", "artifact", "plan", "memory", "rule"] as const;
+const SUPPORTED_INTERNAL_SCHEMES = ["skill", "agent", "artifact", "plan", "rule"] as const;
 
 type SupportedInternalScheme = (typeof SUPPORTED_INTERNAL_SCHEMES)[number];
 
@@ -152,7 +152,7 @@ export function expandSkillUrls(command: string, skills: readonly Skill[]): stri
 
 /**
  * Expand supported internal URLs in a bash command string to shell-escaped absolute paths.
- * Supported schemes: skill://, agent://, artifact://, plan://, memory://, rule://
+ * Supported schemes: skill://, agent://, artifact://, plan://, rule://
  */
 export async function expandInternalUrls(command: string, options: InternalUrlExpansionOptions): Promise<string> {
 	if (!command.includes("://")) return command;