@danypops/jittor 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/jittor",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Just-in-Time Token Optimizing Router for Pi -- supervised daemon, router policy, and CLI",
   "type": "module",
   "main": "./src/index.ts",
@@ -16,7 +16,8 @@
     "service:install": "bun src/cli.ts service install"
   },
   "dependencies": {
-    "@danypops/daemon-kit": "^0.3.1",
+    "@danypops/vehicle-server": "^0.3.1",
+    "@danypops/vehicle-client": "^0.1.1",
     "google-auth-library": "^10.9.0"
   },
   "devDependencies": {

package/src/cli-commands/service-daemon.ts

@@ -1,7 +1,8 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
+import { createNodeServiceInstallDeps, generateSystemdUnit, installUserService, type ServiceSpec } from "@danypops/vehicle-server/service";
 import { SYSTEMD_UNIT_NAME } from "../constants.ts";
 import { resolveJittorPaths } from "../state.ts";
 import { callAndPrint, type CliDependencies } from "./support.ts";
@@ -16,23 +17,30 @@ export interface SystemdUnitOptions {
 	openRouterBenchmarks?: boolean;
 }
 
-export function renderSystemdUnit(options: SystemdUnitOptions): string {
-	return `[Unit]
-Description=Jittor token optimizing router
-After=default.target network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${options.bunBin} ${options.cliPath} serve
-${options.codexAuthFile ? `Environment="JITTOR_CODEX_AUTH_FILE=${options.codexAuthFile.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"\n` : ""}${options.openRouterBenchmarks ? "Environment=JITTOR_OPENROUTER_BENCHMARKS=1\n" : ""}Restart=always
-RestartSec=2
-NoNewPrivileges=true
-PrivateTmp=true
+function jittorServiceSpec(options: SystemdUnitOptions): ServiceSpec {
+	const env: Record<string, string> = {};
+	if (options.codexAuthFile) env["JITTOR_CODEX_AUTH_FILE"] = options.codexAuthFile;
+	if (options.openRouterBenchmarks) env["JITTOR_OPENROUTER_BENCHMARKS"] = "1";
+	return {
+		name: "jittor",
+		displayName: "Jittor token optimizing router",
+		binPath: options.bunBin,
+		args: [options.cliPath, "serve"],
+		env,
+		descriptorPath: resolveJittorPaths().serviceDescriptor,
+		// Jittor's own client (connectJittorClient) never auto-spawns -- systemd's own
+		// supervision is this daemon's only recovery path, same as Lector's.
+		restartOnFailure: true,
+		restartSec: 2,
+		noNewPrivileges: true,
+		privateTmp: true,
+		waitForNetwork: true,
+	};
+}
 
-[Install]
-WantedBy=default.target
-`;
+/** Pure text generator, delegating to vehicle-server's shared generateSystemdUnit -- kept as its own named export since jittor's own tests (and any external caller) call it directly with the same options shape as before. */
+export function renderSystemdUnit(options: SystemdUnitOptions): string {
+	return generateSystemdUnit(jittorServiceSpec(options));
 }
 
 export function systemctl(...args: string[]): void {
@@ -41,17 +49,18 @@ export function systemctl(...args: string[]): void {
 
 /** cliPath is the caller's own entrypoint file -- resolved from the real CLI script's `import.meta.url`, never this module's own, so the installed unit's ExecStart always points at the actual runnable CLI. */
 export function installService(cliPath: string): void {
-	const unitPath = resolveJittorPaths().systemdUnit;
-	mkdirSync(dirname(unitPath), { recursive: true });
 	const codexAuthFile = join(process.env["CODEX_HOME"] ?? join(homedir(), ".codex"), "auth.json");
-	writeFileSync(unitPath, renderSystemdUnit({
+	const spec = jittorServiceSpec({
 		bunBin: process.execPath,
 		cliPath,
 		...(existsSync(codexAuthFile) ? { codexAuthFile } : {}),
 		openRouterBenchmarks: process.env["JITTOR_OPENROUTER_BENCHMARKS"] === "1",
-	}));
-	systemctl("daemon-reload");
-	systemctl("enable", SYSTEMD_UNIT_NAME);
+	});
+	const result = installUserService(spec, createNodeServiceInstallDeps());
+	if (!result.installed) throw new Error(`failed to install the Jittor service: ${result.reason}`);
+	// installUserService's Linux path is `enable --now` (starts if not already running) --
+	// an explicit restart on top ensures a re-install after a Jittor upgrade actually picks
+	// up the freshly-generated unit's new ExecStart path, not just re-enables the old one.
 	systemctl("restart", SYSTEMD_UNIT_NAME);
 }
 

package/src/cli-commands/support.ts

@@ -8,7 +8,7 @@ export interface CliDependencies {
 	stderr(line: string): void;
 	systemctl(...args: string[]): void;
 	installService(): void;
-	serve(): void;
+	serve(): Promise<void>;
 }
 
 export function humanField(value: string): string {

package/src/cli.ts

@@ -52,7 +52,7 @@ function usage(stderr: (line: string) => void): number {
 export async function runCli(args: string[], deps: CliDependencies = DEFAULT_DEPENDENCIES): Promise<number> {
 	const [command, action, ...rest] = args;
 	const fail = () => usage(deps.stderr);
-	if (command === "serve") { deps.serve(); return 0; }
+	if (command === "serve") { await deps.serve(); return 0; }
 	if (command === "session") return runSessionCommand(action, rest, deps, fail);
 	if (command === "metrics") return runMetricsCommand(action, rest, deps, fail);
 	if (command === "telemetry") return runTelemetryCommand(action, rest, deps, fail);

package/src/client.ts

@@ -1,4 +1,4 @@
-import { AuthenticatedRpcClient, type FetchTransport } from "@danypops/daemon-kit/rpc-client";
+import { AuthenticatedRpcClient, type FetchTransport } from "@danypops/vehicle-client/rpc-client";
 import type { OperationInputs, OperationName, OperationOutputs } from "./service.ts";
 import { ensureAuthToken, readDaemonHandle, resolveJittorPaths, type JittorPaths } from "./state.ts";
 
@@ -6,7 +6,7 @@ export type { FetchTransport };
 
 /**
  * Jittor's typed authenticated RPC client, now a thin named subclass of
- * `@danypops/daemon-kit/rpc-client`'s `AuthenticatedRpcClient` -- the shared substrate factored
+ * `@danypops/vehicle-client/rpc-client`'s `AuthenticatedRpcClient` -- the shared substrate factored
  * out after jittor's own client.ts and web-spider-daemon's were found byte-identical (see
  * daemon-kit's README). Keeps the old 3-positional-argument constructor so every existing call
  * site is untouched by this migration.

package/src/constants.ts

@@ -115,3 +115,21 @@ export const GOOGLE_VERTEX_BUDGET_MAX_MESSAGES_PER_PULL = 20;
  */
 export const GOOGLE_VERTEX_BUDGET_CONFIDENCE = 0.6;
 export const GOOGLE_ADC_TOKEN_REFRESH_SKEW_MS = 60_000;
+/**
+ * Context Hub: the shared, versioned, multi-producer channel any extension can target to
+ * contribute one segment of the context-window breakdown (successor to the single-producer
+ * papyrus.context-injection.v1 shape) -- Papyrus's rules/tasks segment is the first producer.
+ */
+export const CONTEXT_HUB_CONTRIBUTION_CHANNEL = "jittor.context-contribution.v1";
+export const CONTEXT_HUB_CONTRIBUTION_SCHEMA = "jittor.context-contribution/v1";
+export const CONTEXT_HUB_PRODUCER_NAME_MAX_CHARACTERS = 80;
+export const CONTEXT_HUB_SEGMENT_LABEL_MAX_CHARACTERS = 160;
+export const CONTEXT_HUB_SEGMENT_KEY_MAX_CHARACTERS = 80;
+export const CONTEXT_HUB_ITEM_LABEL_MAX_CHARACTERS = 200;
+export const CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT = 500;
+export const CONTEXT_HUB_MAX_ITEM_DEPTH = 6;
+export const CONTEXT_HUB_CONTRIBUTION_MAX_AGE_MS = 5 * MILLISECONDS_PER_MINUTE;
+export const CONTEXT_HUB_CONTRIBUTION_DEDUP_LIMIT = 1_000;
+/** Matches Papyrus's own CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN; kept independent since Jittor does not depend on the Papyrus package. */
+export const CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN = 4;
+export const CONTEXT_HUB_CONFIDENCE_TIERS = ["exact-tool", "exact-cooperative", "correlated", "audited"] as const;

package/src/daemon.ts

@@ -1,4 +1,4 @@
-import { startDaemon as startDaemonKit, type RunningDaemon } from "@danypops/daemon-kit/daemon";
+import { startDaemon as startDaemonKit, type RunningDaemon } from "@danypops/vehicle-server/daemon";
 import { MAINTENANCE_INTERVAL_MS, TELEMETRY_POLL_INTERVAL_MS } from "./constants.ts";
 import { DEFAULT_POLICY, UNCONFIGURED_ROUTE } from "./config.ts";
 import { SQLiteMetricStore } from "./adapters/sqlite-metric-store.ts";
@@ -23,7 +23,7 @@ import type { GoogleVertexMetricSource } from "./providers/google-vertex-contrac
 import { ensureAuthToken, resolveJittorPaths, type JittorPaths } from "./state.ts";
 import { logEvent, logger } from "./log.ts";
 
-export type { RunningDaemon } from "@danypops/daemon-kit/daemon";
+export type { RunningDaemon } from "@danypops/vehicle-server/daemon";
 
 export function reportMaintenanceFailure(event: string, error: unknown): void {
 	logEvent("error", event, { message: error instanceof Error ? error.message : String(error) });
@@ -65,7 +65,7 @@ export function telemetrySourcesFromEnvironment(env: Record<string, string | und
 }
 
 /**
- * Composition root, now built on `@danypops/daemon-kit/daemon`'s `startDaemon` for binding,
+ * Composition root, now built on `@danypops/vehicle-server/daemon`'s `startDaemon` for binding,
  * atomic handle write, maintenance-timer driving, and clean shutdown -- the skeleton that used to
  * be hand-rolled here (and, byte-identically, in web-spider-daemon's and papyrus's daemon.ts; see
  * daemon-kit's README). Each maintenance task still catches and classifies its own failure via
@@ -74,10 +74,10 @@ export function telemetrySourcesFromEnvironment(env: Record<string, string | und
  * daemon-kit's own generic "maintenance task failed: <name>" catch, which exists as a safety net
  * for tasks that don't self-classify, not to replace a consumer's own richer classification.
  */
-export function startDaemon(
+export async function startDaemon(
 	paths: JittorPaths = resolveJittorPaths(),
 	env: Record<string, string | undefined> = process.env,
-): RunningDaemon {
+): Promise<RunningDaemon> {
 	const token = ensureAuthToken(paths);
 	const db = openJittorDb(paths.database);
 	const metrics = new SQLiteMetricStore(db);
@@ -96,7 +96,7 @@ export function startDaemon(
 	});
 	const service = new JittorService(metrics, router, benchmarks, modelRanker, sessionIdentity);
 
-	const daemon = startDaemonKit({
+	const daemon = await startDaemonKit({
 		daemonLabel: "Jittor",
 		handlePath: paths.handle,
 		logger,
@@ -115,8 +115,8 @@ export function startDaemon(
 	return daemon;
 }
 
-export function serveMain(): void {
-	const daemon = startDaemon();
+export async function serveMain(): Promise<void> {
+	const daemon = await startDaemon();
 	console.error(`[jittor] listening on ${daemon.host}:${daemon.port}`);
 	const stop = async (): Promise<void> => {
 		await daemon.stop();

package/src/db.ts

@@ -1,5 +1,5 @@
 import type { Database } from "bun:sqlite";
-import { openSqliteWithPragmas } from "@danypops/daemon-kit/storage";
+import { openSqliteWithPragmas } from "@danypops/vehicle-server/storage";
 import { SQLITE_BUSY_TIMEOUT_MS } from "./constants.ts";
 
 const INITIAL_SCHEMA = `
@@ -31,7 +31,7 @@ CREATE INDEX session_identities_last_seen_idx
 `;
 
 /**
- * Delegates bootstrap (pragmas, migration engine) to `@danypops/daemon-kit/storage`, which
+ * Delegates bootstrap (pragmas, migration engine) to `@danypops/vehicle-server/storage`, which
  * generalizes the byte-identical pragma/PRAGMA-user_version skeleton jittor's own db.ts used to
  * hand-roll (see daemon-kit's README). Jittor's only remaining responsibility is its own schema.
  */

package/src/domain/context-hub.ts

@@ -0,0 +1,226 @@
+/**
+ * Context Hub: Jittor's cross-extension context-window attribution. Two independent pieces:
+ *
+ * - The tool-schema ledger (computeToolSchemaLedger/toolLedgerSegment): exact, zero-cooperation
+ *   attribution of tool-schema cost (name + description + parameters + guidelines) per owning
+ *   extension, using Pi's own `sourceInfo` on every registered tool -- no other package needs to
+ *   change for this to work.
+ * - The shared contribution channel (validateContextContribution/contextContributionMetric): any
+ *   extension can opt in and contribute one segment of the breakdown (e.g. Papyrus's rules/tasks
+ *   segment) over `CONTEXT_HUB_CONTRIBUTION_CHANNEL`, the same shared-bus pattern already proven
+ *   by papyrus.context-injection.v1, generalized to a human-readable producer name and a nested
+ *   segment/item shape instead of one flat character count.
+ */
+import {
+	CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN,
+	CONTEXT_HUB_CONFIDENCE_TIERS,
+	CONTEXT_HUB_CONTRIBUTION_MAX_AGE_MS,
+	CONTEXT_HUB_CONTRIBUTION_SCHEMA,
+	CONTEXT_HUB_ITEM_LABEL_MAX_CHARACTERS,
+	CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT,
+	CONTEXT_HUB_MAX_ITEM_DEPTH,
+	CONTEXT_HUB_PRODUCER_NAME_MAX_CHARACTERS,
+	CONTEXT_HUB_SEGMENT_KEY_MAX_CHARACTERS,
+	CONTEXT_HUB_SEGMENT_LABEL_MAX_CHARACTERS,
+} from "../constants.ts";
+import type { MetricObservation } from "./metric.ts";
+
+export type ContextConfidenceTier = (typeof CONTEXT_HUB_CONFIDENCE_TIERS)[number];
+
+export interface ContextSegmentItem {
+	label: string;
+	estimatedTokens: number;
+	children?: ContextSegmentItem[];
+}
+
+export interface ContextSegment {
+	key: string;
+	label: string;
+	estimatedTokens: number;
+	confidence: ContextConfidenceTier;
+	items?: ContextSegmentItem[];
+}
+
+export interface ContextContribution {
+	schema: typeof CONTEXT_HUB_CONTRIBUTION_SCHEMA;
+	observedAt: number;
+	sequence: number;
+	producerName: string;
+	segment: ContextSegment;
+}
+
+function nonEmptyString(value: unknown, name: string, maxLength: number): string {
+	if (typeof value !== "string" || value.length === 0 || value.length > maxLength) throw new Error(`${name} must be a non-empty string of at most ${maxLength} characters`);
+	return value;
+}
+
+function boundedInteger(value: unknown, name: string): number {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error(`${name} must be a bounded non-negative integer`);
+	return value;
+}
+
+function countItems(items: ContextSegmentItem[]): number {
+	return items.reduce((sum, item) => sum + 1 + (item.children ? countItems(item.children) : 0), 0);
+}
+
+function validateSegmentItem(value: unknown, depth: number): ContextSegmentItem {
+	if (depth > CONTEXT_HUB_MAX_ITEM_DEPTH) throw new Error(`context segment item nesting exceeds ${CONTEXT_HUB_MAX_ITEM_DEPTH} levels`);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("context segment item must be an object");
+	const input = value as Record<string, unknown>;
+	for (const key of Object.keys(input)) {
+		if (key !== "label" && key !== "estimatedTokens" && key !== "children") throw new Error(`context segment item contains unexpected field: ${key}`);
+	}
+	const item: ContextSegmentItem = {
+		label: nonEmptyString(input["label"], "item.label", CONTEXT_HUB_ITEM_LABEL_MAX_CHARACTERS),
+		estimatedTokens: boundedInteger(input["estimatedTokens"], "item.estimatedTokens"),
+	};
+	if (input["children"] !== undefined) {
+		if (!Array.isArray(input["children"])) throw new Error("item.children must be an array");
+		item.children = input["children"].map((child) => validateSegmentItem(child, depth + 1));
+	}
+	return item;
+}
+
+/** Validates a bare segment (no contribution envelope) -- shared by validateContextContribution and Jittor's own directly-computed segments (tool ledger, base prompt, ...). */
+export function validateContextSegment(value: unknown): ContextSegment {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("context segment must be an object");
+	const input = value as Record<string, unknown>;
+	for (const key of Object.keys(input)) {
+		if (key !== "key" && key !== "label" && key !== "estimatedTokens" && key !== "confidence" && key !== "items") {
+			throw new Error(`context segment contains unexpected field: ${key}`);
+		}
+	}
+	const confidence = input["confidence"];
+	if (typeof confidence !== "string" || !CONTEXT_HUB_CONFIDENCE_TIERS.includes(confidence as ContextConfidenceTier)) {
+		throw new Error(`confidence must be one of ${CONTEXT_HUB_CONFIDENCE_TIERS.join(", ")}`);
+	}
+	const segment: ContextSegment = {
+		key: nonEmptyString(input["key"], "segment.key", CONTEXT_HUB_SEGMENT_KEY_MAX_CHARACTERS),
+		label: nonEmptyString(input["label"], "segment.label", CONTEXT_HUB_SEGMENT_LABEL_MAX_CHARACTERS),
+		estimatedTokens: boundedInteger(input["estimatedTokens"], "segment.estimatedTokens"),
+		confidence: confidence as ContextConfidenceTier,
+	};
+	if (input["items"] !== undefined) {
+		if (!Array.isArray(input["items"])) throw new Error("segment.items must be an array");
+		const items = input["items"].map((item) => validateSegmentItem(item, 1));
+		if (countItems(items) > CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT) throw new Error(`segment.items exceeds ${CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT} total items`);
+		segment.items = items;
+	}
+	return segment;
+}
+
+const CONTRIBUTION_FIELDS = new Set(["schema", "observedAt", "sequence", "producerName", "segment"]);
+
+/** Validates one contribution posted on CONTEXT_HUB_CONTRIBUTION_CHANNEL. Fails closed on schema drift or an oversized/malformed payload, the same posture as validatePapyrusContextInjection. */
+export function validateContextContribution(value: unknown, now = Date.now()): ContextContribution {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("context contribution must be an object");
+	const input = value as Record<string, unknown>;
+	for (const key of Object.keys(input)) if (!CONTRIBUTION_FIELDS.has(key)) throw new Error(`context contribution contains unexpected field: ${key}`);
+	if (input["schema"] !== CONTEXT_HUB_CONTRIBUTION_SCHEMA) throw new Error("context contribution schema is not supported");
+	const observedAt = boundedInteger(input["observedAt"], "observedAt");
+	if (Math.abs(now - observedAt) > CONTEXT_HUB_CONTRIBUTION_MAX_AGE_MS) throw new Error("context contribution is stale");
+	return {
+		schema: CONTEXT_HUB_CONTRIBUTION_SCHEMA,
+		observedAt,
+		sequence: boundedInteger(input["sequence"], "sequence"),
+		producerName: nonEmptyString(input["producerName"], "producerName", CONTEXT_HUB_PRODUCER_NAME_MAX_CHARACTERS),
+		segment: validateContextSegment(input["segment"]),
+	};
+}
+
+/** Bounded, content-free metric projection for storage/history -- mirrors papyrusContextMetric's shape. */
+export function contextContributionMetric(contribution: ContextContribution): MetricObservation {
+	return {
+		source: "context-hub",
+		scope: contribution.producerName,
+		metric: "segment-tokens",
+		value: contribution.segment.estimatedTokens,
+		unit: "count",
+		observedAt: contribution.observedAt,
+		attributes: {
+			sequence: contribution.sequence,
+			segmentKey: contribution.segment.key,
+			segmentLabel: contribution.segment.label,
+			confidence: contribution.segment.confidence,
+			itemCount: contribution.segment.items ? countItems(contribution.segment.items) : 0,
+		},
+	};
+}
+
+/**
+ * Exact, zero-cooperation attribution of tool-schema cost: every registered tool's `sourceInfo`
+ * (populated by Pi's own resource loader from the extension that registered it, never guessed)
+ * identifies its owning extension. Tool schemas are fixed overhead paid on every single turn
+ * regardless of whether the tool is ever called, so this is the walking-skeleton signal --
+ * buildable without any other package changing.
+ */
+export interface ToolLedgerEntry {
+	name: string;
+	description?: string;
+	parameters?: unknown;
+	promptGuidelines?: string[];
+	promptSnippet?: string;
+	sourceInfo?: { source?: string; path?: string };
+}
+
+export interface ToolLedgerToolUsage {
+	name: string;
+	characters: number;
+	estimatedTokens: number;
+}
+
+export interface ToolLedgerSourceUsage {
+	source: string;
+	toolCount: number;
+	characters: number;
+	estimatedTokens: number;
+	tools: ToolLedgerToolUsage[];
+}
+
+function toolCharacters(tool: ToolLedgerEntry): number {
+	const parameterCharacters = tool.parameters === undefined ? 0 : JSON.stringify(tool.parameters).length;
+	const guidelineCharacters = (tool.promptGuidelines ?? []).reduce((sum, guideline) => sum + guideline.length, 0);
+	return tool.name.length + (tool.description?.length ?? 0) + parameterCharacters + guidelineCharacters + (tool.promptSnippet?.length ?? 0);
+}
+
+/** Groups every registered tool's serialized schema size by its owning extension (`sourceInfo.source`), sorted heaviest-first at both the source and tool level. A tool with no sourceInfo (e.g. an SDK-supplied custom tool) is grouped under "unknown" rather than dropped. */
+export function computeToolSchemaLedger(tools: readonly ToolLedgerEntry[]): ToolLedgerSourceUsage[] {
+	const bySource = new Map<string, ToolLedgerToolUsage[]>();
+	for (const tool of tools) {
+		const source = tool.sourceInfo?.source && tool.sourceInfo.source.length > 0 ? tool.sourceInfo.source : "unknown";
+		const characters = toolCharacters(tool);
+		const usage: ToolLedgerToolUsage = { name: tool.name, characters, estimatedTokens: Math.ceil(characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN) };
+		const existing = bySource.get(source);
+		if (existing) existing.push(usage);
+		else bySource.set(source, [usage]);
+	}
+	return [...bySource.entries()]
+		.map(([source, toolUsages]) => {
+			const sorted = [...toolUsages].sort((left, right) => right.characters - left.characters);
+			return {
+				source,
+				toolCount: sorted.length,
+				characters: sorted.reduce((sum, tool) => sum + tool.characters, 0),
+				estimatedTokens: sorted.reduce((sum, tool) => sum + tool.estimatedTokens, 0),
+				tools: sorted,
+			};
+		})
+		.sort((left, right) => right.characters - left.characters);
+}
+
+/** Projects the tool-schema ledger into one ContextSegment (`toolDefinitions`), ready to merge alongside any contributed segment. */
+export function toolLedgerSegment(tools: readonly ToolLedgerEntry[]): ContextSegment {
+	const ledger = computeToolSchemaLedger(tools);
+	const items: ContextSegmentItem[] = ledger.map((sourceUsage) => ({
+		label: `${sourceUsage.source} (${sourceUsage.toolCount} tool${sourceUsage.toolCount === 1 ? "" : "s"})`,
+		estimatedTokens: sourceUsage.estimatedTokens,
+		children: sourceUsage.tools.map((tool) => ({ label: tool.name, estimatedTokens: tool.estimatedTokens })),
+	}));
+	return {
+		key: "toolDefinitions",
+		label: "Tool definitions",
+		estimatedTokens: items.reduce((sum, item) => sum + item.estimatedTokens, 0),
+		confidence: "exact-tool",
+		items,
+	};
+}

package/src/index.ts

@@ -32,6 +32,20 @@ export {
 	applyTaskFocusEvent,
 	validateTaskFocusEvent,
 } from "./domain/task-focus.ts";
+export {
+	type ContextConfidenceTier,
+	type ContextContribution,
+	type ContextSegment,
+	type ContextSegmentItem,
+	type ToolLedgerEntry,
+	type ToolLedgerSourceUsage,
+	type ToolLedgerToolUsage,
+	computeToolSchemaLedger,
+	contextContributionMetric,
+	toolLedgerSegment,
+	validateContextContribution,
+	validateContextSegment,
+} from "./domain/context-hub.ts";
 export {
 	METRIC_UNITS,
 	type MetricObservation,

package/src/log.ts

@@ -1,5 +1,5 @@
 /**
- * Structured daemon logging, now backed by `@danypops/daemon-kit/logging` (pino) instead of a
+ * Structured daemon logging, now backed by `@danypops/vehicle-server/logging` (pino) instead of a
  * hand-rolled `console.error(JSON.stringify(...))` -- daemon-kit's own module doc explains why:
  * level ordering/filtering/child-scoping is exactly the kind of thing worth one shared,
  * dependency-backed implementation instead of four independent hand-rolled ones. One deliberate,
@@ -8,9 +8,9 @@
  * four daemons. `component`/`level`/`timestamp` and credential-safety (callers still must pass
  * only bounded, non-sensitive fields) are unchanged.
  */
-import { createLogger, type LogLevel as DaemonKitLogLevel, type Logger } from "@danypops/daemon-kit/logging";
+import { createLogger, type LogLevel as VehicleLogLevel, type Logger } from "@danypops/vehicle-server/logging";
 
-export type LogLevel = Extract<DaemonKitLogLevel, "info" | "warn" | "error">;
+export type LogLevel = Extract<VehicleLogLevel, "info" | "warn" | "error">;
 
 /**
  * Also passed directly as `StartDaemonOptions.logger` so daemon-kit's own maintenance-task

package/src/ports/session-identity-store.ts

@@ -1,5 +1,5 @@
-import type { SessionIdentityRecord, SessionIdentityStore as DaemonKitSessionIdentityStore } from "@danypops/daemon-kit/session-identity";
+import type { SessionIdentityRecord, SessionIdentityStore as VehicleSessionIdentityStore } from "@danypops/vehicle-server/session-identity";
 
 /** Jittor's persistence port for daemon-kit's storage-agnostic session-identity primitive. */
-export type SessionIdentityStore = DaemonKitSessionIdentityStore;
+export type SessionIdentityStore = VehicleSessionIdentityStore;
 export type { SessionIdentityRecord };

package/src/service.ts

@@ -1,4 +1,4 @@
-import { errorResponse, healthResponse, readyResponse, requireBearerToken } from "@danypops/daemon-kit/http";
+import { errorResponse, healthResponse, readyResponse, requireBearerToken } from "@danypops/vehicle-server/rpc-http";
 import { SERVICE_MAX_BODY_BYTES, SERVICE_MAX_RESPONSE_BYTES } from "./constants.ts";
 import { InvalidSessionSecretError, SessionIdentity, type RegisterSessionIdentityResult } from "./session-identity-service.ts";
 import { VERSION } from "./version.ts";
@@ -188,7 +188,7 @@ export interface JittorAppOptions {
 
 /**
  * Bearer-check and the trivial health/ready/not-found responses now delegate to
- * `@danypops/daemon-kit/http` (the same handful of lines every daemon's service.ts hand-rolled).
+ * `@danypops/vehicle-server/rpc-http` (the same handful of lines every daemon's service.ts hand-rolled).
  * The response-size guard below stays jittor-specific: daemon-kit's `jsonResponse` is intentionally
  * unbounded (it has no operation dispatch of its own to guard), while jittor's `/api/v1/ops` can
  * return arbitrarily large query results that must be capped (see SERVICE_MAX_RESPONSE_BYTES).

package/src/session-identity-service.ts

@@ -1,4 +1,4 @@
-import { isSessionRegistered, registerSessionIdentity, releaseSessionIdentity, verifySessionSecret } from "@danypops/daemon-kit/session-identity";
+import { isSessionRegistered, registerSessionIdentity, releaseSessionIdentity, verifySessionSecret } from "@danypops/vehicle-server/session-identity";
 import type { SessionIdentityStore } from "./ports/session-identity-store.ts";
 
 export interface RegisterSessionIdentityResult {

package/src/state.ts

@@ -1,20 +1,20 @@
 /**
- * Jittor's XDG paths/token/handle layout, now delegating to `@danypops/daemon-kit/paths` --
+ * Jittor's XDG paths/token/handle layout, now delegating to `@danypops/vehicle-server/paths` --
  * the shared substrate factored out after jittor's own state.ts and web-spider-daemon's were
  * found byte-identical (see daemon-kit's README). Kept as a thin jittor-named wrapper (same
  * exported function names/signatures as before) so every existing call site (daemon.ts,
  * client.ts, cli.ts, and their tests) is untouched by this migration.
  */
 import {
-	ensureAuthToken as ensureDaemonKitAuthToken,
-	readDaemonHandle as readDaemonKitHandle,
-	removeDaemonHandle as removeDaemonKitHandle,
+	ensureAuthToken as ensureVehicleAuthToken,
+	readDaemonHandle as readVehicleHandle,
+	removeDaemonHandle as removeVehicleHandle,
 	resolveDaemonPaths,
-	writeDaemonHandle as writeDaemonKitHandle,
+	writeDaemonHandle as writeVehicleHandle,
 	type DaemonHandle,
 	type DaemonPaths,
 	type PathEnvironment,
-} from "@danypops/daemon-kit/paths";
+} from "@danypops/vehicle-server/paths";
 import {
 	DATABASE_FILENAME,
 	HANDLE_FILENAME,
@@ -39,17 +39,17 @@ export function resolveJittorPaths(options: PathEnvironment = {}): JittorPaths {
 }
 
 export function ensureAuthToken(paths: JittorPaths = resolveJittorPaths()): string {
-	return ensureDaemonKitAuthToken(paths.token, "Jittor");
+	return ensureVehicleAuthToken(paths.token, "Jittor");
 }
 
 export function writeDaemonHandle(paths: JittorPaths, handle: DaemonHandle): void {
-	writeDaemonKitHandle(paths.handle, handle);
+	writeVehicleHandle(paths.handle, handle);
 }
 
 export function readDaemonHandle(paths: JittorPaths = resolveJittorPaths()): DaemonHandle | null {
-	return readDaemonKitHandle(paths.handle);
+	return readVehicleHandle(paths.handle);
 }
 
 export function removeDaemonHandle(paths: JittorPaths = resolveJittorPaths()): void {
-	removeDaemonKitHandle(paths.handle);
+	removeVehicleHandle(paths.handle);
 }

package/src/version.ts

@@ -1,4 +1,4 @@
-import { readPackageVersion } from "@danypops/daemon-kit/version";
+import { readPackageVersion } from "@danypops/vehicle-server/version";
 
 /** Runtime package version; package.json is the single release source of truth. */
 export const VERSION = readPackageVersion(new URL("../package.json", import.meta.url), "Jittor");