@snoai/memory 1.7.1 → 2.0.1

package/dist/agent-state-view.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/agent-state-view.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import { a as readAgentView, c as screenAgents, n as compactAgentView, o as recordAgentHandoff, r as markAgentResultSeen, s as renderAgentScreen } from "./agent-state-BB-voJsF.js";
+import { execFile } from "node:child_process";
+import { emitKeypressEvents } from "node:readline";
+import { promisify } from "node:util";
+// config/agent-state-cli.ts
+const execute = promisify(execFile);
+function option(args, name) {
+	const index = args.indexOf(name);
+	return index < 0 ? void 0 : args[index + 1];
+}
+function renderAgentSnapshot(view) {
+	const lines = [`Sno Station · squad · ${view.observedAt}`, ""];
+	for (const group of [
+		"Needs you",
+		"Working",
+		"Finished",
+		"unknown"
+	]) {
+		lines.push(group === "unknown" ? "Unknown observations" : group);
+		for (const row of view.agents.filter((row) => row.group === group)) {
+			lines.push(`  ${row.harness} ${row.sessionId} · ${row.subgroup} · ${row.ageSeconds}s ago`, `  Doing: ${row.doing} · Process: ${row.process} · Resumable: ${row.resumable} · Waiting for a human: ${row.waitingForHuman}`, `  Reason: ${row.waitingReason} · Reach: ${row.reachAddress} · Project: ${row.cwd} · Task: ${row.description}`, `  Work: ${JSON.stringify(row.work)} · Delivery: ${row.delivery} · Resume: ${row.resumeEvidence}`, `  Result: ${row.resultId} · Seen: ${row.humanSeen} · Last event: ${JSON.stringify(row.lastEvent)}`);
+			if (row.missingReasons.length) lines.push(`  Missing: ${row.missingReasons.join("; ")}`);
+		}
+		lines.push("");
+	}
+	if (!view.agents.length) lines.push("No observed agents.");
+	lines.push("Quota", ...view.quota.length ? view.quota.map((item) => JSON.stringify(item)) : ["unknown · no account observation"]);
+	if (view.errors.length) lines.push("Operation errors", ...view.errors.map((error) => `${error.operation}: ${error.target}: ${error.error} (${error.impact})`));
+	return lines.join("\n");
+}
+/** Explicit account read only; local snapshots and status redraw never invoke this. */
+async function refreshAgentQuota(view) {
+	let output;
+	let code = 0;
+	try {
+		output = (await execute("sno", [
+			"subscription-quota-check",
+			"--vendor",
+			"both",
+			"--json",
+			"--quiet"
+		])).stdout;
+	} catch (error) {
+		const failed = error instanceof Error ? error : new Error(String(error));
+		output = "stdout" in failed && typeof failed.stdout === "string" ? failed.stdout : "";
+		code = "code" in failed && typeof failed.code === "number" ? failed.code : -1;
+		view.errors.push({
+			operation: "read account quota",
+			target: "subscription-quota-check",
+			error: failed.message,
+			impact: "unavailable account quota remains unknown"
+		});
+	}
+	try {
+		const parsed = JSON.parse(output);
+		if (!parsed || typeof parsed !== "object" || !("vendors" in parsed) || !Array.isArray(parsed.vendors)) throw new Error("quota reader returned no vendor observations");
+		const observedAt = "captured_at" in parsed ? parsed.captured_at : "unknown";
+		view.quota = parsed.vendors.map((vendor) => ({
+			observation: vendor,
+			source: "subscription-quota-check",
+			observedAt,
+			exitCode: code
+		}));
+	} catch (error) {
+		view.errors.push({
+			operation: "parse account quota",
+			target: "subscription-quota-check",
+			error: String(error),
+			impact: "quota unknown"
+		});
+	}
+}
+async function screenView() {
+	return screenAgents(await readAgentView());
+}
+async function screen() {
+	let { view, hidden } = await screenView();
+	let selected = 0;
+	let result = "";
+	const wasRaw = process.stdin.isRaw;
+	const reread = async () => {
+		const current = view.agents[selected];
+		({view, hidden} = await screenView());
+		const index = view.agents.findIndex((row) => row.harness === current?.harness && row.sessionId === current?.sessionId);
+		selected = index >= 0 ? index : Math.max(0, Math.min(selected, view.agents.length - 1));
+	};
+	const draw = () => {
+		process.stdout.write(`\x1b[H\x1b[2J${renderAgentScreen(view, selected, {
+			columns: process.stdout.columns ?? 80,
+			rows: process.stdout.rows ?? 24
+		}, result, hidden)}`);
+	};
+	process.stdout.on("resize", draw);
+	process.stdout.write("\x1B[?1049h\x1B[?25l");
+	emitKeypressEvents(process.stdin);
+	process.stdin.setRawMode(true);
+	process.stdin.resume();
+	draw();
+	try {
+		await new Promise((resolve) => {
+			const close = () => {
+				process.stdin.off("keypress", keypress);
+				process.off("SIGTERM", close);
+				process.off("SIGINT", close);
+				resolve();
+			};
+			const keypress = async (value, key) => {
+				if (value === "q" || key.name === "escape" || key.ctrl && key.name === "c") {
+					close();
+					return;
+				}
+				try {
+					if (key.name === "down" || value === "j") {
+						selected = Math.min(view.agents.length - 1, selected + 1);
+						result = "";
+					} else if (key.name === "up" || value === "k") {
+						selected = Math.max(0, selected - 1);
+						result = "";
+					} else if (key.name === "return") {
+						const row = view.agents[selected];
+						if (row) {
+							result = `Result: ${row.finalReply}`;
+							await markAgentResultSeen(row);
+							await reread();
+						}
+					} else if (value === "r") {
+						await refreshAgentQuota(view);
+						result = `Quota: ${view.quota.map((item) => JSON.stringify(item.observation ?? item)).join(" · ")}`;
+					} else if (value === " ") {
+						const quota = view.quota;
+						await reread();
+						view.quota = quota;
+					}
+					draw();
+				} catch (error) {
+					result = `refresh failed: ${String(error)}`;
+					draw();
+				}
+			};
+			process.stdin.on("keypress", keypress);
+			process.on("SIGTERM", close);
+			process.on("SIGINT", close);
+		});
+	} finally {
+		process.stdout.off("resize", draw);
+		process.stdin.setRawMode(wasRaw ?? false);
+		process.stdin.pause();
+		process.stdout.write("\x1B[?25h\x1B[?1049l");
+	}
+	return 0;
+}
+async function agentStateMain(args) {
+	if (args.includes("--record-release")) {
+		let text = "";
+		for await (const chunk of process.stdin) text += chunk;
+		await recordAgentHandoff(option(args, "--source") ?? "", option(args, "--target") ?? "", text);
+		return 0;
+	}
+	if (args.includes("--help")) {
+		process.stdout.write("sno squad [global --json] · local squad observations\n");
+		return 0;
+	}
+	if (!args.includes("--json") && !args.includes("--compact") && process.stdout.isTTY && process.stdin.isTTY) return screen();
+	const view = await readAgentView({ recent: args.includes("--compact") && !args.includes("--json") });
+	if (args.includes("--json")) process.stdout.write(`${JSON.stringify(view)}\n`);
+	else if (args.includes("--compact")) process.stdout.write(`${compactAgentView(view, {
+		harness: option(args, "--harness"),
+		sessionId: option(args, "--session-id"),
+		reachAddress: option(args, "--reach-address")
+	})}\n`);
+	else process.stdout.write(`${renderAgentSnapshot(view)}\n`);
+	return 0;
+}
+agentStateMain(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+}, (error) => {
+	process.stderr.write(`${JSON.stringify({
+		operation: "read agent inventory",
+		error: String(error),
+		impact: "squad unavailable"
+	})}\n`);
+	process.exitCode = 1;
+});
+export {};

package/dist/{atomic-memory-extraction-CWMMWF2C.js → atomic-memory-extraction-OusdO3Ig.js}

@@ -3,21 +3,21 @@ import "./internal/engine/i18n/locales.js";
 import { $ as FIXED_MEMORY_SNO_EXTRACT_PROFILE, Q as FIXED_MEMORY_SNO_EXTRACT_CHAT } from "./signed-registry-constants-CO2vv_QJ.js";
 import { redactSecrets } from "./internal/engine/security/redact.js";
 import { t as appendAuditEntry } from "./runtime-audit-log-4NJsojEj.js";
-import { a as isTerminalLlmFailure, i as createLlmClient, n as LlmClientTerminalError } from "./llm-client-BtbX4af4.js";
+import { a as isTerminalLlmFailure, i as createLlmClient, n as LlmClientTerminalError } from "./llm-client-DhBvu-U_.js";
 import { n as readModelReplyJson } from "./model-reply-text-C7jEWDXG.js";
 import { resolveLlmRoute } from "./internal/model/llm-mode-routing.js";
 import { n as ATOMIC_EXTRACTION_SKILL_HASH, r as atomicExtractionSkillReference, t as ATOMIC_EXTRACTION_SKILL } from "./atomic-extraction-skill-5lAqr8BM.js";
 import { stripEnvelopeMetadata } from "./internal/engine/extraction/extraction-text-sanitizer.js";
 import { a as sessionZoneCarriedBy, t as calculateCalendarTime } from "./calendar-instruction-uK6xsrCt.js";
-import "./memory-temporality-classifier-Bm0EiCN8.js";
+import "./memory-temporality-classifier-DTRhzXmG.js";
 import { a as parseAtomicCaptureReply, c as atomic_extraction_response_schema_default, i as fallbackAtomicCapturedFact, l as excludeProgressRecords, n as ATOMIC_ENRICHMENT_RESPONSE_JSON_SCHEMA, o as parseAtomicEnrichmentReply, r as ATOMIC_EXTRACTION_RESPONSE_JSON_SCHEMA, s as parseAtomicExtractionReply, t as ATOMIC_CAPTURE_RESPONSE_JSON_SCHEMA } from "./atomic-extraction-reply-CoxIGLmU.js";
 import { adapterAViewFromRecord, isAdapterAVerdictReply, parseAdapterAChatVerdict, renderAdapterAChatPrompt, renderAdapterAPrompt } from "./internal/engine/rem/index.js";
 import { n as state_vocabulary_default, r as attribute_dictionary_default, t as relations } from "./relation-dictionary-QVBewRQ1.js";
 import { g as randomUUID$1 } from "./memory-store-shared-B-zOxk_Q.js";
-import { b as normalizeMemoryRelationPredicate, d as normalizeEntityName, f as recordAtomicEntityIdentityJournal, g as readAtomicArrivalRetirementCandidateSet, h as journalAtomicArrivalRetirementRefusal, m as closeAtomicArrivalRetirementTargets, u as listAtomicMemoryEntityCandidates, v as AtomicExtractionCompletedElsewhere } from "./store-YX1_c1NH.js";
+import { b as normalizeMemoryRelationPredicate, d as normalizeEntityName, f as recordAtomicEntityIdentityJournal, g as readAtomicArrivalRetirementCandidateSet, h as journalAtomicArrivalRetirementRefusal, m as closeAtomicArrivalRetirementTargets, u as listAtomicMemoryEntityCandidates, v as AtomicExtractionCompletedElsewhere } from "./store-cu7Qq2OW.js";
 import { o as normalizeTopicToSectionName } from "./b-profile-section-dictionary-provider-DMGsJlYh.js";
 import { r as recordTokenCounter } from "./memory-store-write-validation-BbvoN3Li.js";
-import { i as prepareDeterministicTaskLifecycleWrite, t as PROFILE_IDENTITY_SECTION } from "./profile-section-writer-DSX6R3GF.js";
+import { i as prepareDeterministicTaskLifecycleWrite, t as PROFILE_IDENTITY_SECTION } from "./profile-section-writer-QiB0MMtt.js";
 import { z } from "zod";
 import { countTokens } from "@snoai/chunking";
 import { createLogger, currentLogContext, privateLogReference, withLogContext } from "@snoai/utils/logger";

package/dist/client.js

@@ -5,9 +5,9 @@ import { getPrincipal, getSettingsPath, getSnoStationMemStateDir, getStartupLogP
 import { checkDiscovery, processAlive, readDiscovery } from "./internal/contract/discovery.js";
 import { join } from "node:path";
 import { mkdir, open } from "node:fs/promises";
+import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { request } from "node:http";
-import { spawn } from "node:child_process";
 import { connect as connect$1 } from "node:net";
 import { setTimeout } from "node:timers/promises";
 // src/contract/start.ts

package/dist/coding-skin-lewnGLT-.js

@@ -0,0 +1,342 @@
+import { a as readAgentView, n as compactAgentView } from "./agent-state-BB-voJsF.js";
+import "./internal/engine/telemetry/observe-ledger.js";
+import "./internal/config/skill-categories.js";
+import "./internal/config/skin-defaults.js";
+import { basename, dirname, join } from "node:path";
+import { getSnoProfileDir } from "@snoai/observability";
+import { mkdir, readFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { homedir } from "node:os";
+// config/agent-statusline.ts
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function originalStatusLine(command, harness) {
+	if (typeof command !== "string" || !command.includes(`/mem-${harness}/dist/cli.js' status-line `)) return void 0;
+	const encoded = / --sno-original '([A-Za-z0-9+/=]+)'$/.exec(command)?.[1];
+	if (!encoded) return void 0;
+	const values = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+	if (!Array.isArray(values)) throw new Error("invalid original status-line configuration");
+	return { value: values[0] };
+}
+/** The owned command carries the original configuration; no separate settings backup is needed. */
+function composeAgentStatusLine(config, entryPath, harness, installing) {
+	const previous = originalStatusLine(record(config.statusLine)?.command, harness);
+	if (!installing && !previous) return;
+	const original = previous ? previous.value : config.statusLine;
+	if (!installing) {
+		if (original === void 0) delete config.statusLine;
+		else config.statusLine = original;
+		return;
+	}
+	const encoded = Buffer.from(JSON.stringify(original === void 0 ? [] : [original])).toString("base64");
+	config.statusLine = {
+		...record(original),
+		type: "command",
+		command: `${shellQuote(process.execPath)} ${shellQuote(entryPath)} status-line --sno-original '${encoded}'`
+	};
+}
+async function userOutput(command, input) {
+	return new Promise((resolve, reject) => {
+		const child = spawn("sh", ["-c", command], { stdio: [
+			"pipe",
+			"pipe",
+			"inherit"
+		] });
+		const chunks = [];
+		child.stdout.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+		child.on("error", reject);
+		child.on("close", (code) => resolve({
+			output: Buffer.concat(chunks),
+			code: code ?? 1
+		}));
+		child.stdin.on("error", (error) => {
+			if (!("code" in error) || error.code !== "EPIPE") reject(error);
+		});
+		child.stdin.end(input);
+	});
+}
+async function renderAgentStatusLine(harness, originalEncoded, input) {
+	const originals = JSON.parse(Buffer.from(originalEncoded, "base64").toString("utf8"));
+	const command = Array.isArray(originals) ? record(originals[0])?.command : void 0;
+	const user = typeof command === "string" ? await userOutput(command, input) : {
+		output: Buffer.alloc(0),
+		code: 0
+	};
+	const newlineLength = user.output.at(-1) === 10 ? user.output.at(-2) === 13 ? 2 : 1 : 0;
+	process.stdout.write(user.output.subarray(0, user.output.length - newlineLength));
+	try {
+		const sessionId = record(JSON.parse(input))?.session_id;
+		if (typeof sessionId !== "string" || !sessionId) throw new Error("current client session identity unavailable");
+		const view = await readAgentView({ recent: true });
+		const segment = compactAgentView(view, {
+			harness,
+			sessionId
+		});
+		const color = /\bneed you\b/.test(segment) ? "\x1B[1;33m" : "\x1B[2m";
+		const displayed = process.env.NO_COLOR === void 0 ? `${color}${segment}\x1b[0m` : segment;
+		process.stdout.write(`${user.output.length > newlineLength ? " | " : ""}${displayed}\n`);
+	} catch (error) {
+		process.stdout.write(user.output.subarray(user.output.length - newlineLength));
+		process.stderr.write(`${JSON.stringify({
+			operation: "agent-state-status-line",
+			target: harness,
+			error: String(error),
+			impact: "Sno segment unavailable; original output retained"
+		})}\n`);
+	}
+	return user.code;
+}
+// config/work-continuity.ts
+function object(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function failure(operation, target, error, impact) {
+	console.error(JSON.stringify({
+		operation,
+		target,
+		error: String(error),
+		impact
+	}));
+}
+function continuityBriefPath(sessionId) {
+	return join(getSnoProfileDir(), "station", "handoff", `${sessionId}.md`);
+}
+function context(output, target) {
+	if (!output.trim()) return "";
+	try {
+		const envelope = JSON.parse(output);
+		if (object(envelope) && object(envelope["hookSpecificOutput"])) {
+			const text = envelope["hookSpecificOutput"]["additionalContext"];
+			if (typeof text === "string") return text;
+		}
+		throw new Error("no hookSpecificOutput.additionalContext");
+	} catch (error) {
+		failure("read hook context", target, error, "this context was not delivered; other task context remains available");
+		return "";
+	}
+}
+async function sno(args, input, timeoutMs, env = process.env) {
+	return new Promise((resolve) => {
+		const child = execFile(env["SNO_EXECUTABLE"] ?? "sno", args, {
+			encoding: "utf8",
+			timeout: timeoutMs,
+			maxBuffer: Number.POSITIVE_INFINITY,
+			env
+		}, (error, stdout, stderr) => {
+			if (stderr) process.stderr.write(stderr);
+			if (error) failure(args.slice(0, 2).join(" "), String(input["session_id"]), error, "this operation failed; the saved brief and other available context remain usable");
+			resolve(error ? "" : stdout);
+		});
+		child.stdin?.on("error", (error) => failure("write hook input", args.join(" "), error, "this command did not receive its hook input"));
+		child.stdin?.end(JSON.stringify(input));
+	});
+}
+/** Reuse the memory hook's own deadline for the parallel lesson lookup. */
+async function recallDeadline(event) {
+	const hook = event === "UserPromptSubmit" ? CODING_SKIN_HOOKS.UserPromptSubmit : CODING_SKIN_HOOKS.SessionStart;
+	try {
+		const settings = JSON.parse(await readFile(join(getSnoProfileDir(), "settings.json"), "utf8"));
+		const key = event === "UserPromptSubmit" ? "prompt" : "sessionStart";
+		if (object(settings) && object(settings["recall"]) && object(settings["recall"][key])) {
+			const timeoutMs = settings["recall"][key]["timeoutMs"];
+			if (typeof timeoutMs === "number" && timeoutMs > 0) return timeoutMs;
+		}
+	} catch (error) {
+		failure("read recall deadline", join(getSnoProfileDir(), "settings.json"), error, "using the installed hook deadline; local continuity remains enabled");
+	}
+	return hook.timeout * 1e3;
+}
+/** The same envelope carries durable task state, memory recall and locally approved lessons. */
+async function composeContinuityContext(harness, event, input, memory) {
+	if (!object(input) || typeof input["session_id"] !== "string" || typeof input["cwd"] !== "string" || input["agent_id"] !== void 0) return JSON.stringify({ hookSpecificOutput: {
+		hookEventName: event,
+		additionalContext: ""
+	} });
+	const path = continuityBriefPath(input["session_id"]);
+	const lessons = recallDeadline(event).then((timeoutMs) => sno([
+		"rem-reflect",
+		"recall",
+		"--agent",
+		harness === "claude" ? "claude-code" : "codex",
+		"--first-message"
+	], {
+		...input,
+		hook_event_name: event
+	}, timeoutMs));
+	const recalled = memory();
+	const readBrief = () => readFile(path, "utf8").catch((error) => {
+		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) failure("read handoff brief", path, error, "task restoration from this brief failed; other context remains available");
+		return "";
+	});
+	const brief = event !== "SessionStart" ? readBrief() : (async () => {
+		const sessionId = String(input["session_id"]);
+		try {
+			await mkdir(dirname(path), {
+				recursive: true,
+				mode: 448
+			});
+			if (await readFile(path, "utf8").then(() => true, () => false)) return readBrief();
+			await sno([
+				"handoff-checkpoint",
+				"--repo",
+				String(input["cwd"]),
+				path
+			], input, await recallDeadline(event), checkpointEnvironment(harness, sessionId));
+		} catch (error) {
+			failure("prepare handoff brief", path, error, "the agent has no brief template; available context is still delivered");
+		}
+		return "";
+	})();
+	const [saved, memoryRecall, approved] = await Promise.allSettled([
+		brief,
+		recalled,
+		lessons
+	]);
+	const parts = [];
+	if (event === "SessionStart") parts.push(`Keep the current task in the readable handoff brief at ${path}; its template already exists. Start the user's task first: do not read or edit the brief before your first action on the task. Update the brief only when there is real progress to record (a finished step, a decision, a failure, or before an orderly interruption), and only with your ${harness === "claude" ? "Edit or Write tool" : "apply_patch tool"}, never through a shell command. Keep its readable sections accurate: Objective and authorization, decisions and exclusions, Done/current files, Next with the exact next action and its expected observable result, Known failure with operation/target/error, Reach card/recipient when present, and Report destination. Do not ask the owner to reconstruct lost work.`);
+	if (saved.status === "fulfilled" && saved.value) parts.push(`Current task handoff brief (complete file: ${path}). If the host reports context overflow, read that complete file before task action; do not infer the missing text. Reconcile actual file/tool results before repeating an unfinished action.\n\n${saved.value}`);
+	if (memoryRecall.status === "fulfilled") parts.push(context(memoryRecall.value, "memory recall"));
+	else failure("memory recall", input["session_id"], memoryRecall.reason, "memory recall failed; the saved brief and approved lessons remain available");
+	if (approved.status === "fulfilled") parts.push(context(approved.value, join(process.env["REM_REFLECT_STORE"] ?? join(homedir(), ".sno", "experience"), "wiki", "lessons.jsonl")));
+	else failure("read approved lessons", input["session_id"], approved.reason, "lesson delivery failed; task context remains available");
+	return JSON.stringify({ hookSpecificOutput: {
+		hookEventName: event,
+		additionalContext: parts.filter(Boolean).join("\n\n")
+	} });
+}
+/** Refresh the existing readable brief before compaction; never manufacture task facts. */
+async function refreshContinuityBrief(harness, input) {
+	if (!object(input) || typeof input["session_id"] !== "string" || typeof input["cwd"] !== "string" || input["agent_id"] !== void 0) return;
+	const path = continuityBriefPath(input["session_id"]);
+	try {
+		await readFile(path, "utf8");
+	} catch (error) {
+		failure("save before compaction", path, error, "no readable current brief was saved; recovery can use only previously durable records");
+		return;
+	}
+	await sno([
+		"handoff-checkpoint",
+		"--repo",
+		input["cwd"],
+		path
+	], input, CODING_SKIN_HOOKS.Stop.timeout * 1e3, checkpointEnvironment(harness, input["session_id"]));
+}
+function checkpointEnvironment(harness, sessionId) {
+	return {
+		...process.env,
+		CLAUDE_SESSION_ID: harness === "claude" ? sessionId : void 0,
+		CODEX_THREAD_ID: harness === "codex" ? sessionId : void 0
+	};
+}
+// config/coding-skin.ts
+const CODING_SKIN_CHILD_DEADLINE_MS = 11e4;
+const CODING_SKIN_WORKER_LIFETIME_MS = 54e4;
+const CODING_SKIN_RETRY_DELAYS_MS = [2e3, 1e4];
+const CODING_SKIN_MAX_ATTEMPTS = 3;
+const CODING_SKIN_MAX_PENDING_CAPTURES = 1e3;
+/** A session's turns wait in the spool until the session ends or has had no new turn for this long, then go together. */
+const CODING_SKIN_CAPTURE_QUIET_MS = 18e5;
+/**
+* Input per capture, estimated as UTF-8 bytes / 3 (at or above the sidecar's CJK-aware count). It keeps one capture to
+* about one 4,096-token extraction window, so a capture ends well inside its route deadline and a failed one retries
+* a small part; the rest is room for the window's JSON framing.
+*/
+const CODING_SKIN_CAPTURE_MAX_INPUT_TOKENS = 3500;
+const CODING_SKIN_IMPORT_INTERVAL_MS = 2010;
+const CODING_SKIN_CHILD_MAX_BUFFER_BYTES = 8388608;
+const CODING_SKIN_MANUAL_SESSION_ID = "manual";
+const CODING_SKIN_SESSION_QUERY = "standing decisions, open tasks, conventions and known pitfalls for this repository";
+const CODING_SKIN_LEDGER_MAX_CHARS = 12e3;
+const CODING_SKIN_RECALL_SENTENCE_MAX_CHARS = 200;
+const CODING_SKIN_RECALL_ITEM_MAX_CHARS = 240;
+const CODING_SKIN_HOOKS = {
+	SessionStart: {
+		eventName: "session_start",
+		subcommand: "session-start",
+		timeout: 15
+	},
+	UserPromptSubmit: {
+		eventName: "user_prompt_submit",
+		subcommand: "user-prompt-submit",
+		timeout: 30
+	},
+	Stop: {
+		eventName: "stop",
+		subcommand: "stop",
+		timeout: 5
+	},
+	SessionEnd: {
+		eventName: "session_end",
+		subcommand: "session-end",
+		timeout: 8
+	},
+	PreToolUse: {
+		eventName: "pre_tool_use",
+		subcommand: "pre-tool-use",
+		timeout: 5
+	},
+	PostToolUse: {
+		eventName: "post_tool_use",
+		subcommand: "post-tool-use",
+		timeout: 30
+	}
+};
+/** Cursor's hook events (`hooks.json` names); timeouts match the Claude/Codex event each one stands in for. */
+const CODING_SKIN_CURSOR_HOOKS = {
+	sessionStart: {
+		subcommand: "session-start",
+		timeout: 15
+	},
+	beforeSubmitPrompt: {
+		subcommand: "user-prompt-submit",
+		timeout: 30
+	},
+	afterAgentResponse: {
+		subcommand: "after-agent-response",
+		timeout: 5
+	},
+	afterAgentThought: {
+		subcommand: "after-agent-thought",
+		timeout: 5
+	},
+	stop: {
+		subcommand: "stop",
+		timeout: 5
+	},
+	preCompact: {
+		subcommand: "pre-compact",
+		timeout: 5
+	},
+	sessionEnd: {
+		subcommand: "session-end",
+		timeout: 8
+	}
+};
+const CODING_SKIN_MODEL_COMMANDS = [
+	"recall",
+	"get",
+	"remember",
+	"correct"
+];
+function shellQuote(value) {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+/** Linux reports a running binary that was replaced on disk as "<path> (deleted)"; the path itself is still the right one. */
+function snoProgramPath(path) {
+	return path.endsWith(" (deleted)") ? path.slice(0, -10) : path;
+}
+/** The command an agent hook runs: the `sno` binary that ran setup, then `memory hook <event> --harness <name>`. */
+function codingSkinHookCommand(snoPath, subcommand, harness) {
+	return `${shellQuote(snoPath)} memory hook ${subcommand} --harness ${harness}`;
+}
+/** True for a hook command of that shape, whatever the path to `sno` is. */
+function isCodingSkinHookCommand(command, subcommand, harness) {
+	const suffix = ` memory hook ${subcommand} --harness ${harness}`;
+	const trimmed = command.trim();
+	if (!trimmed.endsWith(suffix)) return false;
+	const encoded = trimmed.slice(0, -suffix.length);
+	const program = encoded.startsWith("'") && encoded.endsWith("'") ? encoded.slice(1, -1).replaceAll("'\\''", "'") : encoded;
+	return basename(snoProgramPath(program)) === "sno";
+}
+export { continuityBriefPath as C, renderAgentStatusLine as E, composeContinuityContext as S, composeAgentStatusLine as T, CODING_SKIN_WORKER_LIFETIME_MS as _, CODING_SKIN_CURSOR_HOOKS as a, shellQuote as b, CODING_SKIN_LEDGER_MAX_CHARS as c, CODING_SKIN_MAX_PENDING_CAPTURES as d, CODING_SKIN_MODEL_COMMANDS as f, CODING_SKIN_SESSION_QUERY as g, CODING_SKIN_RETRY_DELAYS_MS as h, CODING_SKIN_CHILD_MAX_BUFFER_BYTES as i, CODING_SKIN_MANUAL_SESSION_ID as l, CODING_SKIN_RECALL_SENTENCE_MAX_CHARS as m, CODING_SKIN_CAPTURE_QUIET_MS as n, CODING_SKIN_HOOKS as o, CODING_SKIN_RECALL_ITEM_MAX_CHARS as p, CODING_SKIN_CHILD_DEADLINE_MS as r, CODING_SKIN_IMPORT_INTERVAL_MS as s, CODING_SKIN_CAPTURE_MAX_INPUT_TOKENS as t, CODING_SKIN_MAX_ATTEMPTS as u, codingSkinHookCommand as v, refreshContinuityBrief as w, snoProgramPath as x, isCodingSkinHookCommand as y };