@snoai/memory 0.0.0-stage → 1.0.0

package/dist/classifier-C96uH9OF.d.ts

@@ -0,0 +1,272 @@
+import { C as RemVerdictCheckpoint, _ as RemOwner, g as RemOperationType, u as RemDatabaseLike, y as RemRowState } from "./types-pVomjzqR.js";
+//#region src/engine/rem/repository.d.ts
+type BudgetReservation = {
+  status: "reserved";
+  tokens: number;
+  idempotencyKey: string;
+} | {
+  status: "pending";
+  reason: "invocation_row_missing" | "tokenizer_unavailable";
+};
+type RowClaimRefusalReason = "claim_changed" | "content_changed" | "content_changed_released" | "holder_alive" | "inconsistent_state" | "missing";
+interface CreateVerdictGenerationInput {
+  generationId: string;
+  corpusSnapshotHash: string;
+  pairingConfigHash: string;
+  maxLlmCalls: number;
+  maxTokens: number;
+  pairs: ReadonlyArray<{
+    pairId: string;
+    leftRowId: string;
+    rightRowId: string;
+    sortKey: string;
+  }>;
+  inheritedRefusalsFromGenerationId?: string;
+}
+interface VerdictGenerationRef {
+  generationId: string;
+  corpusSnapshotHash: string;
+}
+interface VerdictPairQueueItem {
+  pairId: string;
+  leftRowId: string;
+  rightRowId: string;
+  sortKey: string;
+  claimState: "unvisited" | "claimed" | "done";
+  invocationId: string | null;
+}
+interface JournalEntry {
+  stage: string;
+  outcome: "done" | "failed" | "disabled" | "pending" | "refused" | "no-action";
+  pairsScanned: number;
+  verdicts: number;
+  actionsApplied: number;
+  reason?: string;
+  /**
+   * Which condition produced this row, as its own value rather than folded into `reason`. PRD 50
+   * ACC-27 requires the persisted refusal to carry the failing condition as a FIELD: a reader
+   * asking "which condition" must not have to parse a string, and `reason` must stay groupable —
+   * `topRefusalReasons` counts distinct `reason` values, so a detail concatenated into it would
+   * give every refusal its own bucket and destroy the statistic.
+   */
+  detail?: string;
+  rowId?: string;
+  pairId?: string;
+}
+interface RemRepository {
+  recordClassification(input: {
+    rowId: string;
+    contentHash: string;
+    state: RemRowState;
+    classifiedAt: string;
+  }): void;
+  claimRow(input: {
+    rowId: string;
+    contentHash: string;
+    owner: Exclude<RemOwner, "none">;
+    claimToken: string;
+    claimTs: string;
+    holderPid: number;
+  }): {
+    claimed: true;
+  } | {
+    claimed: false;
+    reason: "content_changed" | "missing";
+  } | {
+    claimed: false;
+    reason: "already_claimed";
+    claimToken: string;
+  };
+  recoverRowClaim(input: {
+    rowId: string;
+    contentHash: string;
+    owner: Exclude<RemOwner, "none">;
+    expectedClaimToken: string;
+    claimToken: string;
+    claimTs: string;
+    holderPid: number;
+  }): {
+    recovered: true;
+  } | {
+    recovered: false;
+    reason: RowClaimRefusalReason;
+  };
+  completeRowClaim(input: {
+    rowId: string;
+    contentHash: string;
+    currentContentHash: string;
+    owner: Exclude<RemOwner, "none">;
+    claimToken: string;
+    completedAt: string;
+    jobId: string;
+    jobType: RemOperationType;
+  }): {
+    completed: true;
+  } | {
+    completed: false;
+    reason: Exclude<RowClaimRefusalReason, "holder_alive">;
+  };
+  releaseRowClaim(input: {
+    rowId: string;
+    contentHash: string;
+    owner: Exclude<RemOwner, "none">;
+    claimToken: string;
+  }): {
+    released: true;
+  } | {
+    released: false;
+    reason: Exclude<RowClaimRefusalReason, "holder_alive">;
+  };
+  createVerdictGeneration(input: CreateVerdictGenerationInput): void;
+  findOpenVerdictGeneration(input: {
+    corpusSnapshotHash: string;
+    pairingConfigHash: string;
+  }): VerdictGenerationRef | undefined;
+  listVerdictPairs(generationId: string): VerdictPairQueueItem[];
+  /** The given pairs already closed with a recorded verdict in any generation (PRD 140 REQ-9). */
+  readClosedVerdictPairIds(pairIds: readonly string[]): Set<string>;
+  claimNextPair(input: {
+    generationId: string;
+    invocationId: string;
+    claimedAt: string;
+    holderPid: number;
+  }): {
+    pairId: string;
+    leftRowId: string;
+    rightRowId: string;
+  } | undefined;
+  releasePairClaim(input: {
+    generationId: string;
+    pairId: string;
+    invocationId: string;
+  }): void;
+  completePair(input: {
+    generationId: string;
+    pairId: string;
+    invocationId: string;
+  }): void;
+  refusePair(input: {
+    generationId: string;
+    pairId: string;
+    invocationId: string;
+    reason: string;
+    jobId: string;
+    jobType: RemOperationType;
+  }): {
+    state: "refused" | "exhausted";
+    attemptCount: number;
+  };
+  reserveLlmBudget(input: {
+    generationId: string;
+    pairId: string;
+    invocationId: string;
+    stage: string;
+    prompt: string;
+    outputTokenCap: number;
+    providerUsage?: {
+      inputTokens: number;
+      outputTokens: number;
+    };
+    countTokens?: (text: string) => number;
+  }): BudgetReservation;
+  readGeneration(generationId: string): {
+    generationId: string;
+    pendingStages: string[];
+    llmCallsUsed: number;
+    tokensUsed: number;
+  };
+  readInvocation(input: {
+    generationId: string;
+    invocationId: string;
+  }): {
+    llmCallsUsed: number;
+    tokensUsed: number;
+  };
+  appendJournal(jobId: string, jobType: RemOperationType, entry: JournalEntry): void;
+  listJournal(jobId: string, jobType?: RemOperationType): JournalEntry[];
+  recordVerdictCheckpoint(input: {
+    generationId: string;
+    pairId: string;
+    invocationId: string;
+    checkpoint: RemVerdictCheckpoint;
+    recordedAt: string;
+    verdict?: string;
+  }): void;
+  resumeVerdictPair(input: {
+    generationId: string;
+    pairId: string;
+    expectedInvocationId: string;
+    invocationId: string;
+    resumedAt: string;
+    holderPid: number;
+  }): {
+    next: "call_llm";
+    claimToken: string;
+  } | {
+    next: "apply_action";
+    verdict: string;
+    claimToken: string;
+  } | {
+    next: "complete";
+    claimToken: string;
+  } | {
+    next: "refused";
+    reason: "holder_alive";
+  };
+  readVerdictPair(generationId: string, pairId: string): {
+    checkpoint: RemVerdictCheckpoint | null;
+    actionsApplied: number;
+  };
+}
+declare function createRemRepository(database: RemDatabaseLike): RemRepository;
+//#endregion
+//#region src/engine/rem/classifier.d.ts
+declare const REM_TRANSITION_GRAMMAR_SHA256 = "8fd5439ec2b85ca27bfa462600869973f991a6f44f956c734596ee9c9d44153d";
+declare const REM_ADDITIONAL_TRANSITION_PATTERN_SHA256 = "cb42c6a25ccd51b16da6a3de7d931f1165af284a89cdc365860bd359ae84bd9f";
+declare const REM_CURRENT_PROGRESSIVE_PATTERN_SHA256 = "ddc1c0119c1f9c4e5178dc0e6eec9ca8a7594ed10e2dd8305646f5363e9d24ad";
+declare const REM_HISTORICAL_FACT_PATTERN_SHA256 = "c5a9cdc0bc2936e6c0252e7c785accf1e3cef646921b92e736d01811c92838ff";
+declare const REM_PURE_NEGATION_PATTERN_SHA256 = "610118ddf1ba956d7082b7f0b7e265f1fcbf81655a9f0e3f6ce753c0df2cbc1d";
+declare const REM_AMBIGUOUS_PATTERN_SHA256 = "ba3ac7245cd7c6d9178989b4d8f95b000467244b028308916354a0fa653f954a";
+interface RemClassifiedRow {
+  rowId: string;
+  text: string;
+  contentHash: string;
+  state: RemRowState;
+  owner: RemOwner;
+  ambiguous: boolean;
+}
+/** Classifies one live database row with the same pinned router used by the conformance entry. */
+declare function classifyRemRow(row: {
+  rowId: string;
+  text: string;
+  contentHash: string;
+}): RemClassifiedRow;
+interface RemClassifierCounts {
+  total: number;
+  transition: number;
+  staleCurrent: number;
+  pureNegation: number;
+  ambiguous: number;
+}
+interface RemClassifierClaims {
+  claimed: string[];
+  skipped: string[];
+  refused: Array<{
+    rowId: string;
+    reason: "content_changed" | "already_claimed" | "missing";
+  }>;
+}
+interface RemClassifierReport {
+  counts: RemClassifierCounts;
+  rows: RemClassifiedRow[];
+  claims?: RemClassifierClaims;
+}
+interface RemClassifierPersistence {
+  repository: Pick<RemRepository, "recordClassification" | "claimRow">;
+  classifiedAt: string;
+  claimTs: string;
+}
+declare function runVerdictClassifierEntry(populationValue: unknown, persistence?: RemClassifierPersistence): RemClassifierReport;
+declare function runRestateClassifierEntry(populationValue: unknown, persistence?: RemClassifierPersistence): RemClassifierReport;
+//#endregion
+export { RemRepository as _, REM_PURE_NEGATION_PATTERN_SHA256 as a, createRemRepository as b, RemClassifierClaims as c, RemClassifierReport as d, classifyRemRow as f, JournalEntry as g, CreateVerdictGenerationInput as h, REM_HISTORICAL_FACT_PATTERN_SHA256 as i, RemClassifierCounts as l, runVerdictClassifierEntry as m, REM_AMBIGUOUS_PATTERN_SHA256 as n, REM_TRANSITION_GRAMMAR_SHA256 as o, runRestateClassifierEntry as p, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256 as r, RemClassifiedRow as s, REM_ADDITIONAL_TRANSITION_PATTERN_SHA256 as t, RemClassifierPersistence as u, VerdictGenerationRef as v, VerdictPairQueueItem as y };

package/dist/client.d.ts

@@ -0,0 +1,34 @@
+import { Discovery } from "./internal/contract/discovery.js";
+import { A as HostEvent, B as UsageSignal, F as Mutation, I as RecallOptions, L as Registration, M as Inspection, N as JsonValue, P as Message, Q as ContractError, R as ScopeCtx, _ as ContractOutputs, et as DegradedReason, j as InitRegistration, n as MemoryContract, z as Turn } from "./index-DQ7VL6d3.js";
+//#region src/contract/client.d.ts
+export interface ConnectOptions {
+  skinId: string;
+}
+export interface DegradedConnection {
+  degraded: true;
+  reason: DegradedReason;
+  error?: string;
+}
+export declare function connect(options: ConnectOptions): Promise<MemoryClient | DegradedConnection>;
+export declare class MemoryClient implements MemoryContract {
+  #private;
+  readonly skinId: string;
+  readonly storePath: string;
+  readonly degraded = false;
+  readonly principal: string;
+  readonly pid: number;
+  readonly port: number;
+  constructor(skinId: string, storePath: string, discovery: Discovery);
+  private request;
+  init(scope: ScopeCtx, registration: InitRegistration): Promise<ContractOutputs["init"]>;
+  hostEvent(event: HostEvent, scope: ScopeCtx): Promise<ContractOutputs["hostEvent"]>;
+  getRecall(query: string, scope: ScopeCtx, options: RecallOptions, signal?: AbortSignal): Promise<ContractOutputs["getRecall"]>;
+  capture(turn: Turn, scope: ScopeCtx): Promise<ContractOutputs["capture"]>;
+  mutate(op: Mutation, scope: ScopeCtx): Promise<ContractOutputs["mutate"]>;
+  inspect(op: Inspection, scope: ScopeCtx): Promise<ContractOutputs["inspect"]>;
+  recordUsage(recallId: string, signal: UsageSignal, scope: ScopeCtx): Promise<ContractOutputs["recordUsage"]>;
+  onSessionEnd(messages: Message[], scope: ScopeCtx): Promise<ContractOutputs["onSessionEnd"]>;
+  staticBlock(scope: ScopeCtx): Promise<ContractOutputs["staticBlock"]>;
+}
+//#endregion
+export { ContractError, type ContractOutputs, type HostEvent, type InitRegistration, type Inspection, type JsonValue, type MemoryContract, type Message, type Mutation, type RecallOptions, type Registration, type ScopeCtx, type Turn, type UsageSignal };

package/dist/client.js

@@ -0,0 +1,305 @@
+import { n as DEGRADED_REASONS, t as ContractError } from "./error-D-wb-rZw.js";
+import { r as outputSchemas } from "./results-C3ZLroMb.js";
+import { MEMORY_ROUTES, MEMORY_SKIN_HEADER, MEMORY_START_TIMEOUT_MS } from "./internal/contract/routes.js";
+import { getPrincipal, getSettingsPath, getSnoStationMemStateDir, getStartupLogPath } from "./internal/contract/profile.js";
+import { checkDiscovery, processAlive, readDiscovery } from "./internal/contract/discovery.js";
+import { join } from "node:path";
+import { mkdir, open } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { request } from "node:http";
+import { spawn } from "node:child_process";
+import { setTimeout } from "node:timers/promises";
+//#region src/contract/start.ts
+async function startSidecar(memoryPackage) {
+	const current = await readDiscovery();
+	if (current && processAlive(current.pid)) {
+		const deadline = Date.now() + MEMORY_START_TIMEOUT_MS;
+		while (Date.now() < deadline) {
+			if (await checkDiscovery(current).then(() => true, () => false)) return current;
+			await setTimeout(Math.min(250, Math.max(0, deadline - Date.now())));
+		}
+		throw new ContractError("sidecar-unresponsive");
+	}
+	await mkdir(getSnoStationMemStateDir(), {
+		recursive: true,
+		mode: 448
+	});
+	const log = await open(getStartupLogPath(), "a", 384);
+	let failed = false;
+	try {
+		const entry = join(memoryPackage.path, "dist", "sidecar", "main.js");
+		const child = spawn(memoryPackage.node, [entry], {
+			detached: true,
+			stdio: [
+				"ignore",
+				log.fd,
+				log.fd
+			],
+			env: process.env
+		});
+		child.once("error", () => {
+			failed = true;
+		});
+		child.once("exit", (code) => {
+			if (code !== 0) failed = true;
+		});
+		child.unref();
+	} finally {
+		await log.close();
+	}
+	const deadline = Date.now() + MEMORY_START_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		const discovery = await readDiscovery();
+		if (discovery && processAlive(discovery.pid)) {
+			await checkDiscovery(discovery);
+			return discovery;
+		}
+		if (failed) throw new ContractError("storage-unavailable");
+		await setTimeout(50);
+	}
+	throw new ContractError("sidecar-unreachable");
+}
+//#endregion
+//#region src/contract/client.ts
+function clientSettings() {
+	const path = getSettingsPath();
+	let value;
+	try {
+		value = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		throw new ContractError("storage-unavailable", `settings unavailable: ${path}: file; see https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md`);
+	}
+	const record = value && typeof value === "object" ? value : {};
+	const memoryPackage = record.memoryPackage && typeof record.memoryPackage === "object" ? record.memoryPackage : {};
+	for (const field of ["path", "node"]) if (typeof memoryPackage[field] !== "string" || !memoryPackage[field]) throw new ContractError("storage-unavailable", `settings unavailable: ${path}: memoryPackage.${field}; see https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md`);
+	const store = record.store && typeof record.store === "object" ? record.store : {};
+	return {
+		storePath: typeof store.path === "string" ? store.path : "",
+		memoryPackage
+	};
+}
+function failureReason(error) {
+	if (error instanceof ContractError) return error.reason;
+	if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) return "timeout";
+	return "sidecar-unreachable";
+}
+/**
+* Plain node:http instead of fetch: undici's default dispatcher cuts headers and body at
+* 300 s, silently under the 900 s route budgets; here the route deadline is the only clock.
+*/
+function postJson(port, path, headers, body, signal) {
+	return new Promise((resolve, reject) => {
+		const request$1 = request({
+			host: "127.0.0.1",
+			port,
+			path,
+			method: "POST",
+			signal,
+			headers: {
+				...headers,
+				"Content-Length": Buffer.byteLength(body)
+			}
+		}, (response) => {
+			const chunks = [];
+			response.on("data", (chunk) => chunks.push(chunk));
+			response.on("error", reject);
+			response.on("end", () => {
+				const status = response.statusCode ?? 0;
+				try {
+					resolve({
+						ok: status >= 200 && status < 300,
+						body: JSON.parse(Buffer.concat(chunks).toString("utf8"))
+					});
+				} catch (error) {
+					reject(error);
+				}
+			});
+		});
+		request$1.on("error", reject);
+		request$1.end(body);
+	});
+}
+function responseError(body) {
+	if (body && typeof body === "object" && "reason" in body) {
+		const reason = DEGRADED_REASONS.find((value) => value === body.reason);
+		if (reason) return new ContractError(reason, "error" in body && typeof body.error === "string" ? body.error : reason);
+		if (typeof body.reason === "string") return new ContractError("engine-failed", body.reason);
+	}
+	return new ContractError("engine-failed");
+}
+async function connect(options) {
+	try {
+		const { storePath, memoryPackage } = clientSettings();
+		let discovery = await readDiscovery();
+		if (discovery) try {
+			await checkDiscovery(discovery);
+		} catch (error) {
+			if (error instanceof ContractError && error.message.startsWith("settings unavailable:")) throw error;
+			discovery = void 0;
+		}
+		if (!discovery) discovery = await startSidecar(memoryPackage);
+		if (!discovery) throw new ContractError("sidecar-unreachable");
+		await checkDiscovery(discovery);
+		return new MemoryClient(options.skinId, storePath, discovery);
+	} catch (error) {
+		return {
+			degraded: true,
+			reason: failureReason(error),
+			...error instanceof Error && { error: error.message }
+		};
+	}
+}
+var MemoryClient = class {
+	skinId;
+	storePath;
+	degraded = false;
+	principal = getPrincipal();
+	pid;
+	port;
+	#registration;
+	#registeredPid;
+	constructor(skinId, storePath, discovery) {
+		this.skinId = skinId;
+		this.storePath = storePath;
+		this.pid = discovery.pid;
+		this.port = discovery.port;
+	}
+	async request(method, input, signal) {
+		const route = MEMORY_ROUTES[method];
+		try {
+			signal?.throwIfAborted();
+			let discovery = await readDiscovery();
+			if (!discovery || !processAlive(discovery.pid)) {
+				const { memoryPackage } = clientSettings();
+				discovery = await startSidecar(memoryPackage);
+			}
+			if (method !== "init" && this.#registration && this.#registeredPid !== discovery.pid) await this.request("init", this.#registration, signal);
+			const response = await postJson(discovery.port, route.path, {
+				"Content-Type": "application/json",
+				[MEMORY_SKIN_HEADER]: this.skinId
+			}, JSON.stringify({
+				...input,
+				scope: {
+					...input.scope,
+					principal: this.principal
+				}
+			}), signal ? AbortSignal.any([signal, AbortSignal.timeout(route.timeoutMs)]) : AbortSignal.timeout(route.timeoutMs));
+			const body = response.body;
+			if (!response.ok) throw responseError(body);
+			const parsed = outputSchemas[method].safeParse(body);
+			if (!parsed.success) throw new ContractError("engine-failed");
+			if (parsed.data.degraded) throw new ContractError(parsed.data.reason, parsed.data.error ?? parsed.data.reason);
+			if (method === "init") this.#registeredPid = discovery.pid;
+			return parsed.data;
+		} catch (error) {
+			throw error instanceof ContractError ? error : new ContractError(failureReason(error));
+		}
+	}
+	init(scope, registration) {
+		this.#registration = {
+			scope,
+			registration
+		};
+		return this.request("init", {
+			scope,
+			registration
+		});
+	}
+	hostEvent(event, scope) {
+		return this.request("hostEvent", {
+			scope,
+			event
+		});
+	}
+	async getRecall(query, scope, options, signal) {
+		try {
+			return await this.request("getRecall", {
+				query,
+				scope,
+				options
+			}, signal);
+		} catch (error) {
+			return {
+				degraded: true,
+				reason: failureReason(error),
+				error: error instanceof Error ? error.message : String(error),
+				recallId: "",
+				contextText: ""
+			};
+		}
+	}
+	capture(turn, scope) {
+		return this.request("capture", {
+			turn,
+			scope
+		});
+	}
+	mutate(op, scope) {
+		return this.request("mutate", {
+			op,
+			scope
+		});
+	}
+	async inspect(op, scope) {
+		try {
+			return await this.request("inspect", {
+				op,
+				scope
+			});
+		} catch (error) {
+			let result;
+			if (op.op === "storage") result = {
+				op: "storage",
+				dimension: null,
+				failed: true
+			};
+			else if (op.op === "stats") result = {
+				op: "stats",
+				total: 0,
+				projectBreakdown: {},
+				categoryBreakdown: {}
+			};
+			else if (op.op === "get") result = {
+				op: "get",
+				entry: null
+			};
+			else result = {
+				op: op.op,
+				project: scope.project,
+				entries: []
+			};
+			return {
+				degraded: true,
+				reason: failureReason(error),
+				error: error instanceof Error ? error.message : String(error),
+				result
+			};
+		}
+	}
+	recordUsage(recallId, signal, scope) {
+		return this.request("recordUsage", {
+			recallId,
+			signal,
+			scope
+		});
+	}
+	onSessionEnd(messages, scope) {
+		return this.request("onSessionEnd", {
+			messages,
+			scope
+		});
+	}
+	async staticBlock(scope) {
+		try {
+			return await this.request("staticBlock", { scope });
+		} catch (error) {
+			return {
+				degraded: true,
+				reason: failureReason(error),
+				contextText: ""
+			};
+		}
+	}
+};
+//#endregion
+export { ContractError, MemoryClient, connect };

package/dist/coding-skin.d.ts

@@ -0,0 +1,51 @@
+import { ObserveLedgerRow, appendObserveLedgerRows } from "./internal/engine/telemetry/observe-ledger.js";
+import { SKILL_CATEGORIES, skillVersionFor } from "./internal/config/skill-categories.js";
+import { HOST_MODEL_CALLBACK_HOST, HOST_MODEL_CALLBACK_PATH } from "./internal/config/skin-defaults.js";
+//#region config/coding-skin.d.ts
+export declare const CODING_SKIN_CHILD_DEADLINE_MS = 11e4;
+export declare const CODING_SKIN_WORKER_LIFETIME_MS: number;
+export declare const CODING_SKIN_RETRY_DELAYS_MS: readonly [2_000, 10_000];
+export declare const CODING_SKIN_MAX_ATTEMPTS = 3;
+export declare const CODING_SKIN_IMPORT_INTERVAL_MS = 2010;
+export declare const CODING_SKIN_CHILD_MAX_BUFFER_BYTES: number;
+export declare const CODING_SKIN_MANUAL_SESSION_ID = "manual";
+export declare const CODING_SKIN_SESSION_QUERY = "standing decisions, open tasks, conventions and known pitfalls for this repository";
+export declare const CODING_SKIN_LEDGER_MAX_CHARS = 12e3;
+export declare const CODING_SKIN_RECALL_SENTENCE_MAX_CHARS = 200;
+export declare const CODING_SKIN_RECALL_ITEM_MAX_CHARS = 240;
+export declare const CODING_SKIN_HOOKS: {
+  readonly SessionStart: {
+    readonly eventName: "session_start";
+    readonly subcommand: "session-start";
+    readonly timeout: 15;
+  };
+  readonly UserPromptSubmit: {
+    readonly eventName: "user_prompt_submit";
+    readonly subcommand: "user-prompt-submit";
+    readonly timeout: 8;
+  };
+  readonly Stop: {
+    readonly eventName: "stop";
+    readonly subcommand: "stop";
+    readonly timeout: 5;
+  };
+  readonly SessionEnd: {
+    readonly eventName: "session_end";
+    readonly subcommand: "session-end";
+    readonly timeout: 8;
+  };
+  readonly PreToolUse: {
+    readonly eventName: "pre_tool_use";
+    readonly subcommand: "pre-tool-use";
+    readonly timeout: 5;
+  };
+  readonly PostToolUse: {
+    readonly eventName: "post_tool_use";
+    readonly subcommand: "post-tool-use";
+    readonly timeout: 8;
+  };
+};
+export type CodingSkinHookName = keyof typeof CODING_SKIN_HOOKS;
+export declare const CODING_SKIN_MODEL_COMMANDS: readonly ["recall", "get", "remember", "correct"];
+//#endregion
+export { HOST_MODEL_CALLBACK_HOST, HOST_MODEL_CALLBACK_PATH, type ObserveLedgerRow, SKILL_CATEGORIES, appendObserveLedgerRows, skillVersionFor };