@liyang8246/dsh-codetime 0.0.0-stage → 0.1.8

package/lib/index.js

@@ -0,0 +1,1667 @@
+import { homedir, hostname, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import process from "node:process";
+// ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.6/node_modules/@deepseek-ai/cosmokit/lib/index.js
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Shared config references used by schema validators and plugin runtimes. */
+const write = Symbol.for("cosmokit.volatile.write");
+function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+	if (value === null || typeof value !== "object") return value;
+	if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("volatile config objects must be plain objects or arrays");
+		return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+/**
+* Create a detached reference containing an immutable copy of the supplied data.
+* @param value - validated config data; class instances and functions are unsupported.
+* @returns a reference whose value is updated only by its owning runtime.
+*/
+function createVolatile(value) {
+	let current = snapshot(value);
+	return Object.freeze({
+		get: () => current,
+		[write]: (value) => {
+			current = value;
+		}
+	});
+}
+/**
+* Identify references across ESM/CJS copies of the shared library.
+* @param value - a parsed config value.
+* @returns whether the value implements the shared reference protocol.
+*/
+function isVolatile(value) {
+	return typeof value === "object" && value !== null && write in value;
+}
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+Binary.fromBase64;
+Binary.toBase64;
+Binary.fromHex;
+Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/**
+* Compare values recursively, treating two volatile references as equal regardless of value.
+* Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+* compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+* @param a - first value.
+* @param b - second value.
+* @param strict - whether to require strict data equality outside volatile references.
+* @returns whether the values compare equal.
+*/
+function deepEqual(a, b, strict) {
+	const ancestors = /* @__PURE__ */ new Set();
+	function compare(a, b) {
+		if (a === b) return true;
+		if (isVolatile(a) || isVolatile(b)) return isVolatile(a) && isVolatile(b);
+		if (!strict && isNullable(a) && isNullable(b)) return true;
+		if (typeof a !== typeof b || typeof a !== "object" || !a || !b) return false;
+		if (ancestors.has(a)) return false;
+		function check(test, then) {
+			return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+		}
+		ancestors.add(a);
+		try {
+			return check(Array.isArray, (a, b) => {
+				if (a.length !== b.length) return false;
+				for (let index = 0; index < a.length; index++) if (!compare(a[index], b[index])) return false;
+				return true;
+			}) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("URL"), (a, b) => a.href === b.href) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+				if (a.byteLength !== b.byteLength) return false;
+				const viewA = new Uint8Array(a);
+				const viewB = new Uint8Array(b);
+				for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+				return true;
+			}) ?? ((!strict || [a, b].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({
+				...a,
+				...b
+			}).every((key) => compare(a[key], b[key])));
+		} finally {
+			ancestors.delete(a);
+		}
+	}
+	return compare(a, b);
+}
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
+})(Time || (Time = {}));
+// ../../node_modules/.pnpm/@deepseek-ai+schemastery@3.18.5/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+const kSchema = Symbol.for("schemastery");
+const kValidationError = Symbol.for("ValidationError");
+globalThis.__schemastery_index__ ??= 0;
+globalThis.__schemastery_refs__ = void 0;
+var ValidationError = class extends TypeError {
+	options;
+	name = "ValidationError";
+	constructor(message, options) {
+		let prefix = "$";
+		for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+		else if (typeof segment === "number") prefix += "[" + segment + "]";
+		else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+		if (prefix.startsWith(".")) prefix = prefix.slice(1);
+		super((prefix === "$" ? "" : `${prefix} `) + message);
+		this.options = options;
+	}
+	static is(error) {
+		return !!error?.[kValidationError];
+	}
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+const Schema = function(options) {
+	const schema = function(data, options = {}) {
+		return Schema.resolve(data, schema, options)[0];
+	};
+	if (options.refs) {
+		const refs = mapValues(options.refs, (options) => new Schema(options));
+		const getRef = (uid) => refs[uid];
+		for (const key in refs) {
+			const options = refs[key];
+			options.sKey = getRef(options.sKey);
+			options.inner = getRef(options.inner);
+			options.list = options.list && options.list.map(getRef);
+			options.dict = options.dict && mapValues(options.dict, getRef);
+		}
+		return refs[options.uid];
+	}
+	Object.assign(schema, options);
+	if (typeof schema.callback === "string") try {
+		schema.callback = new Function("return " + schema.callback)();
+	} catch {}
+	Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+	Object.setPrototypeOf(schema, Schema.prototype);
+	schema.meta ||= {};
+	schema.toString = schema.toString.bind(schema);
+	return schema;
+};
+Schema.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", { get() {
+	return {
+		version: 1,
+		vendor: "schemastery",
+		validate: (value) => {
+			try {
+				return { value: Schema.resolve(value, this, {})[0] };
+			} catch (error) {
+				if (ValidationError.is(error)) return { issues: [{
+					message: error.message,
+					path: error.options.path
+				}] };
+				throw error;
+			}
+		}
+	};
+} });
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = function toJSON() {
+	if (globalThis.__schemastery_refs__) {
+		globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+		return this.uid;
+	}
+	globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+	globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+	const result = {
+		uid: this.uid,
+		refs: globalThis.__schemastery_refs__
+	};
+	globalThis.__schemastery_refs__ = void 0;
+	return result;
+};
+Schema.prototype.set = function set(key, value) {
+	this.dict[key] = value;
+	return this;
+};
+Schema.prototype.push = function push(value) {
+	this.list.push(value);
+	return this;
+};
+function mergeDesc(original, messages) {
+	const result = typeof original === "string" ? { "": original } : { ...original };
+	for (const locale in messages) {
+		const value = messages[locale];
+		if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+		else if (typeof value === "string") result[locale] = value;
+	}
+	return result;
+}
+function getInner(value) {
+	return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+	return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = function i18n(messages) {
+	const schema = Schema(this);
+	const desc = mergeDesc(schema.meta.description, messages);
+	if (Object.keys(desc).length) schema.meta.description = desc;
+	if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+		return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+	});
+	if (schema.list) schema.list = schema.list.map((inner, index) => {
+		return inner.i18n(mapValues(messages, (data = {}) => {
+			if (Array.isArray(getInner(data))) return getInner(data)[index];
+			if (Array.isArray(data)) return data[index];
+			return extractKeys(data);
+		}));
+	});
+	if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+		if (getInner(data)) return getInner(data);
+		return extractKeys(data);
+	}));
+	if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+	return schema;
+};
+Schema.prototype.extra = function extra(key, value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+};
+for (const key of [
+	"required",
+	"disabled",
+	"collapse",
+	"hidden",
+	"loose"
+]) Object.assign(Schema.prototype, { [key](value = true) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.deprecated = function deprecated() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "deprecated",
+		type: "danger"
+	});
+	return schema;
+};
+Schema.prototype.experimental = function experimental() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "experimental",
+		type: "warning"
+	});
+	return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+	const schema = Schema(this);
+	const pattern = pick(regexp, ["source", "flags"]);
+	schema.meta = {
+		...schema.meta,
+		pattern
+	};
+	return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+	if (isVolatile(value)) value = value.get();
+	if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+	if (isNullable(value)) return value;
+	if (this.type === "object" || this.type === "dict") {
+		const result = {};
+		for (const key in value) {
+			const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+			if (this.type === "dict" || !isNullable(item)) result[key] = item;
+		}
+		if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+		return result;
+	} else if (this.type === "array" || this.type === "tuple") {
+		const result = [];
+		value.forEach((value, index) => {
+			const schema = this.type === "array" ? this.inner : this.list[index];
+			const item = schema ? schema.simplify(value) : value;
+			result.push(item);
+		});
+		return result;
+	} else if (this.type === "intersect") {
+		const result = {};
+		for (const item of this.list) Object.assign(result, item.simplify(value));
+		return result;
+	} else if (this.type === "union") for (const schema of this.list) try {
+		Schema.resolve(value, schema, {});
+		return schema.simplify(value);
+	} catch {}
+	return value;
+};
+Schema.prototype.toString = function toString(inline) {
+	return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role, extra) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		role,
+		extra
+	};
+	return schema;
+};
+for (const key of [
+	"default",
+	"link",
+	"comment",
+	"description",
+	"max",
+	"min",
+	"step"
+]) Object.assign(Schema.prototype, { [key](value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.volatile = function volatile() {
+	if (this.meta.volatile) throw new TypeError("volatile schema is already wrapped");
+	return this.extra("volatile", true);
+};
+const resolvers = {};
+const checkedVolatile = Symbol("checked-volatile-schema");
+function validateVolatileSchema(schema, path = [], blocked = false, seen = /* @__PURE__ */ new Map()) {
+	const states = seen.get(schema) ?? /* @__PURE__ */ new Set();
+	if (states.has(blocked)) return;
+	states.add(blocked);
+	seen.set(schema, states);
+	if (schema.meta?.volatile && blocked) throw new ValidationError("volatile fields require a fixed object path without an enclosing volatile field", { path });
+	const nested = blocked || !!schema.meta?.volatile;
+	if (schema.dict) for (const [key, child] of Object.entries(schema.dict)) validateVolatileSchema(child, [...path, key], nested, seen);
+	if (schema.sKey) validateVolatileSchema(schema.sKey, [...path, "<key>"], true, seen);
+	if (schema.inner && (schema.type !== "lazy" || schema.inner[kSchema])) validateVolatileSchema(schema.inner, [...path, "*"], true, seen);
+	if (schema.list) for (let index = 0; index < schema.list.length; index++) validateVolatileSchema(schema.list[index], [...path, String(index)], true, seen);
+}
+Schema.extend = function extend(type, resolve) {
+	resolvers[type] = resolve;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+	if (!schema) return [data];
+	if (!options[checkedVolatile]) {
+		validateVolatileSchema(schema, options.path);
+		options = {
+			...options,
+			[checkedVolatile]: true
+		};
+	}
+	if (schema.meta?.volatile) {
+		const inner = Schema(schema);
+		inner.meta = {
+			...schema.meta,
+			volatile: false
+		};
+		const [value, adapted] = Schema.resolve(data, inner, options, strict);
+		try {
+			return [createVolatile(value), adapted];
+		} catch (error) {
+			throw new ValidationError(error instanceof Error ? error.message : String(error), options);
+		}
+	}
+	if (options.ignore?.(data, schema)) return [data];
+	if (isNullable(data) && schema.type !== "lazy") {
+		if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+		let current = schema;
+		let fallback = schema.meta.default;
+		while (current?.type === "intersect" && isNullable(fallback)) {
+			current = current.list[0];
+			fallback = current?.meta.default;
+		}
+		if (isNullable(fallback)) return [data];
+		data = clone(fallback);
+	}
+	const callback = resolvers[schema.type];
+	if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+	try {
+		return callback(data, schema, options, strict);
+	} catch (error) {
+		if (!schema.meta.loose) throw error;
+		return [schema.meta.default];
+	}
+};
+Schema.from = function from(source) {
+	if (isNullable(source)) return Schema.any();
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source)) return Schema.const(source).required();
+	else if (source[kSchema]) return source;
+	else if (typeof source === "function") switch (source) {
+		case String: return Schema.string().required();
+		case Number: return Schema.number().required();
+		case Boolean: return Schema.boolean().required();
+		case Function: return Schema.function().required();
+		default: return Schema.is(source).required();
+	}
+	else throw new TypeError(`cannot infer schema from ${source}`);
+};
+Schema.lazy = function lazy(builder) {
+	const toJSON = () => {
+		if (!schema.inner[kSchema]) {
+			schema.inner = schema.builder();
+			schema.inner.meta = {
+				...schema.meta,
+				...schema.inner.meta
+			};
+		}
+		return schema.inner.toJSON();
+	};
+	const schema = new Schema({
+		type: "lazy",
+		builder,
+		inner: { toJSON }
+	});
+	return schema;
+};
+Schema.natural = function natural() {
+	return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+	return Schema.number().step(.01).min(0).max(1).role("slider");
+};
+Schema.date = function date() {
+	return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+		const date = new Date(value);
+		if (isNaN(+date)) throw new ValidationError(`invalid date "${value}"`, options);
+		return date;
+	}, true)]);
+};
+Schema.regExp = function regExp(flag = "") {
+	return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+		try {
+			return new RegExp(value, flag);
+		} catch (e) {
+			throw new ValidationError(e.message, options);
+		}
+	}, true)]);
+};
+Schema.arrayBuffer = function arrayBuffer(encoding) {
+	return Schema.union([
+		Schema.is(ArrayBuffer),
+		Schema.is(SharedArrayBuffer),
+		Schema.transform(Schema.any(), (value, options) => {
+			if (Binary.isSource(value)) return Binary.fromSource(value);
+			throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+		}, true),
+		...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+			try {
+				return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+			} catch (e) {
+				throw new ValidationError(e.message, options);
+			}
+		}, true)] : []
+	]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+	if (!schema.inner[kSchema]) {
+		schema.inner = schema.builder();
+		schema.inner.meta = {
+			...schema.meta,
+			...schema.inner.meta
+		};
+		validateVolatileSchema(schema.inner, options.path, true);
+	}
+	return Schema.resolve(data, schema.inner, options, strict);
+});
+Schema.extend("any", (data) => {
+	return [data];
+});
+Schema.extend("never", (data, _, options) => {
+	throw new ValidationError(`expected nullable but got ${data}`, options);
+});
+Schema.extend("const", (data, { value }, options) => {
+	if (deepEqual(data, value)) return [value];
+	throw new ValidationError(`expected ${value} but got ${data}`, options);
+});
+function checkWithinRange(data, meta, description, options, skipMin = false) {
+	const { max = Infinity, min = -Infinity } = meta;
+	if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+	if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+}
+Schema.extend("string", (data, { meta }, options) => {
+	if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+	if (meta.pattern) {
+		const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+		if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+	}
+	checkWithinRange(data.length, meta, "string length", options);
+	return [data];
+});
+function decimalShift(data, digits) {
+	const str = data.toString();
+	if (str.includes("e")) return data * Math.pow(10, digits);
+	const index = str.indexOf(".");
+	if (index === -1) return data * Math.pow(10, digits);
+	const frac = str.slice(index + 1);
+	const integer = str.slice(0, index);
+	if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+	return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+}
+function isMultipleOf(data, min, step) {
+	step = Math.abs(step);
+	if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+	const index = step.toString().indexOf(".");
+	const digits = step.toString().slice(index + 1).length;
+	return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+}
+Schema.extend("number", (data, { meta }, options) => {
+	if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+	checkWithinRange(data, meta, "number", options);
+	const { step } = meta;
+	if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+	return [data];
+});
+Schema.extend("boolean", (data, _, options) => {
+	if (typeof data === "boolean") return [data];
+	throw new ValidationError(`expected boolean but got ${data}`, options);
+});
+Schema.extend("bitset", (data, { bits, meta }, options) => {
+	let value = 0, keys = [];
+	if (typeof data === "number") {
+		value = data;
+		for (const key in bits) if (data & bits[key]) keys.push(key);
+	} else if (Array.isArray(data)) {
+		keys = data;
+		for (const key of keys) {
+			if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+			if (key in bits) value |= bits[key];
+		}
+	} else throw new ValidationError(`expected number or array but got ${data}`, options);
+	if (value === meta.default) return [value];
+	return [value, keys];
+});
+Schema.extend("function", (data, _, options) => {
+	if (typeof data === "function") return [data];
+	throw new ValidationError(`expected function but got ${data}`, options);
+});
+Schema.extend("is", (data, { constructor }, options) => {
+	if (typeof constructor === "function") {
+		if (data instanceof constructor) return [data];
+		throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+	} else {
+		if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+		let prototype = Object.getPrototypeOf(data);
+		while (prototype) {
+			if (prototype.constructor?.name === constructor) return [data];
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+	}
+});
+function property(data, key, schema, options) {
+	try {
+		const [value, adapted] = Schema.resolve(data[key], schema, {
+			...options,
+			path: [...options.path || [], key]
+		});
+		if (adapted !== void 0) data[key] = adapted;
+		return value;
+	} catch (e) {
+		if (!options?.autofix) throw e;
+		delete data[key];
+		return schema.meta.volatile ? createVolatile(schema.meta.default) : schema.meta.default;
+	}
+}
+Schema.extend("array", (data, { inner, meta }, options) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+	return [data.map((_, index) => property(data, index, inner, options))];
+});
+Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in data) {
+		let rKey;
+		try {
+			rKey = Schema.resolve(key, sKey, options)[0];
+		} catch (error) {
+			if (strict) continue;
+			throw error;
+		}
+		result[rKey] = property(data, key, inner, options);
+		data[rKey] = data[key];
+		if (key !== rKey) delete data[key];
+	}
+	return [result];
+});
+Schema.extend("tuple", (data, { list }, options, strict) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	const result = list.map((inner, index) => property(data, index, inner, options));
+	if (strict) return [result];
+	result.push(...data.slice(list.length));
+	return [result];
+});
+function merge(result, data) {
+	for (const key in data) {
+		if (key in result) continue;
+		result[key] = data[key];
+	}
+}
+Schema.extend("object", (data, { dict }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in dict) {
+		const value = property(data, key, dict[key], options);
+		if (!isNullable(value) || key in data) result[key] = value;
+	}
+	if (!strict) merge(result, data);
+	return [result];
+});
+Schema.extend("union", (data, { list, toString }, options, strict) => {
+	const messages = [];
+	for (const inner of list) try {
+		return Schema.resolve(data, inner, options, strict);
+	} catch (error) {
+		messages.push(error);
+	}
+	throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+	if (!list.length) return [data];
+	let result;
+	for (const inner of list) {
+		const value = Schema.resolve(data, inner, options, true)[0];
+		if (isNullable(value)) continue;
+		if (isNullable(result)) result = value;
+		else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		else if (typeof value === "object") merge(result ??= {}, value);
+		else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+	}
+	if (!strict && isPlainObject(data)) merge(result, data);
+	return [result];
+});
+Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+	const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+	if (preserve) return [callback(result)];
+	else return [callback(result), callback(adapted)];
+});
+const formatters = {};
+function defineMethod(name, keys, format) {
+	formatters[name] = format;
+	Object.assign(Schema, { [name](...args) {
+		const schema = new Schema({ type: name });
+		keys.forEach((key, index) => {
+			switch (key) {
+				case "sKey":
+					schema.sKey = args[index] ?? Schema.string();
+					break;
+				case "inner":
+					schema.inner = Schema.from(args[index]);
+					break;
+				case "list":
+					schema.list = args[index].map(Schema.from);
+					break;
+				case "dict":
+					schema.dict = mapValues(args[index], Schema.from);
+					break;
+				case "bits":
+					schema.bits = {};
+					for (const key in args[index]) {
+						if (typeof args[index][key] !== "number") continue;
+						schema.bits[key] = args[index][key];
+					}
+					break;
+				case "callback": {
+					const callback = schema.callback = args[index];
+					callback["toJSON"] ||= () => callback.toString();
+					break;
+				}
+				case "constructor": {
+					const constructor = schema.constructor = args[index];
+					if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+					break;
+				}
+				default: schema[key] = args[index];
+			}
+		});
+		if (name === "object" || name === "dict") schema.meta.default = {};
+		else if (name === "array" || name === "tuple") schema.meta.default = [];
+		else if (name === "bitset") schema.meta.default = 0;
+		return schema;
+	} });
+}
+defineMethod("is", ["constructor"], ({ constructor }) => {
+	if (typeof constructor === "function") return constructor.name;
+	else return constructor;
+});
+defineMethod("any", [], () => "any");
+defineMethod("never", [], () => "never");
+defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+defineMethod("string", [], () => "string");
+defineMethod("number", [], () => "number");
+defineMethod("boolean", [], () => "boolean");
+defineMethod("bitset", ["bits"], () => "bitset");
+defineMethod("function", [], () => "function");
+defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+defineMethod("object", ["dict"], ({ dict }) => {
+	if (Object.keys(dict).length === 0) return "{}";
+	return `{ ${Object.entries(dict).map(([key, inner]) => {
+		return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+	}).join(", ")} }`;
+});
+defineMethod("union", ["list"], ({ list }, inline) => {
+	const result = list.map(({ toString: format }) => format()).join(" | ");
+	return inline ? `(${result})` : result;
+});
+defineMethod("intersect", ["list"], ({ list }) => {
+	return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+});
+defineMethod("transform", [
+	"inner",
+	"callback",
+	"preserve"
+], ({ inner }, isInner) => inner.toString(isInner));
+// src/host/history.ts
+/**
+* Fold stored session logs into the accumulator.
+*
+* The persisted cursor makes this idempotent: a session already seen through
+* the live feed contributes only its new tail.
+* @param ctx - plugin context providing the optional query service.
+* @param folder - fold target.
+* @param days - how far back `createdAt` may reach; 0 disables the pass.
+* @returns counts for diagnostics.
+*/
+async function scanHistory(ctx, folder, days) {
+	const result = {
+		sessions: 0,
+		events: 0,
+		failed: 0
+	};
+	if (days <= 0) return result;
+	const query = ctx.get("sessionQuery");
+	if (!query) return result;
+	const records = await query.listSessions();
+	const cutoff = Date.now() - days * 864e5;
+	for (const record of records) {
+		if (record.header.createdAt < cutoff) continue;
+		result.sessions += 1;
+		try {
+			const log = await query.readSession(record.header.id);
+			result.events += folder.ingest({
+				id: log.session.id,
+				cwd: log.session.cwd
+			}, log.events);
+		} catch {
+			result.failed += 1;
+		}
+	}
+	return result;
+}
+// src/host/remote.ts
+/** The one ingest host this plugin reports to. */
+const REMOTE_URL = "https://codetime.dev";
+/** Directory the codetime CLI owns; the plugin shares it so one token works for both. */
+function codetimeHome() {
+	return join(homedir(), ".codetime");
+}
+/** Path of the shared CLI config file. */
+function configPath() {
+	return join(codetimeHome(), "config.json");
+}
+/** Raw shared config as the CLI wrote it; unknown keys are preserved on write. */
+async function readConfig() {
+	let raw;
+	try {
+		raw = await readFile(configPath(), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		throw error;
+	}
+	try {
+		const parsed = JSON.parse(raw);
+		return typeof parsed === "object" && parsed !== null ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+/** Resolve the effective upload token: process environment, then the CLI config. */
+async function resolveToken() {
+	const fromEnv = process.env.CODETIME_TOKEN;
+	if (fromEnv && fromEnv.trim()) return fromEnv.trim();
+	const token = (await readConfig()).token;
+	return typeof token === "string" && token ? token : void 0;
+}
+/**
+* Store or clear the token in the CLI's config file.
+* @param token - token to persist; `undefined` removes it.
+*/
+async function writeToken(token) {
+	const config = await readConfig();
+	if (token) config.token = token;
+	else delete config.token;
+	await mkdir(codetimeHome(), { recursive: true });
+	const temporary = `${configPath()}.tmp`;
+	await writeFile(temporary, `${JSON.stringify(config)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+	await rename(temporary, configPath()).catch(async (error) => {
+		await rm(temporary, { force: true });
+		throw error;
+	});
+}
+/** Read the machine id, minting and persisting one on first use. */
+async function ensureMachineId() {
+	const path = join(codetimeHome(), "machine-id");
+	try {
+		const existing = (await readFile(path, "utf8")).trim();
+		if (existing) return existing;
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	const created = randomUUID();
+	await mkdir(codetimeHome(), { recursive: true });
+	await writeFile(path, `${created}\n`, "utf8");
+	return created;
+}
+/** Mask a token for display: four leading and four trailing characters around twenty dots. */
+function maskToken(token) {
+	const dots = "•".repeat(20);
+	if (token.length <= 8) return dots;
+	return `${token.slice(0, 4)}${dots}${token.slice(-4)}`;
+}
+/**
+* POST one batch of session rollups to `/v3/agent/ingest` with `replace: true`,
+* so re-uploading a session refreshes it instead of duplicating it.
+* @returns inserted, skipped, and conflict counts reported by the server.
+* @throws when the host rejects the batch; the response body is included.
+*/
+async function uploadRollups(input) {
+	const response = await fetch(`${REMOTE_URL}/v3/agent/ingest`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			"user-agent": "dsh-codetime/0.1.0",
+			"authorization": `Bearer ${input.token}`,
+			"x-machine-id": input.machineId,
+			"x-machine-hostname": hostname(),
+			"x-machine-name": hostname(),
+			"x-machine-platform": platform()
+		},
+		body: JSON.stringify({
+			rollups: input.rollups,
+			replace: true
+		})
+	});
+	if (!response.ok) {
+		const body = await response.text();
+		throw new Error(`codetime API ${response.status}: ${body.slice(0, 400)}`);
+	}
+	const data = await response.json();
+	const record = typeof data === "object" && data !== null ? data : {};
+	return {
+		inserted: Number(record.inserted) || 0,
+		skipped: Number(record.skipped) || 0,
+		conflicts: Number(record.conflicts) || 0
+	};
+}
+// src/host/state.ts
+const SAVE_DELAY_MS = 1e3;
+/** Blank token counters. */
+function emptyTokens() {
+	return {
+		inputTokens: 0,
+		cachedInputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0,
+		outputTokens: 0,
+		reasoningOutputTokens: 0,
+		totalTokens: 0
+	};
+}
+/** State with no folded activity. */
+function createState() {
+	return {
+		version: 1,
+		sessions: {},
+		settings: { autoUpload: true }
+	};
+}
+/** Drop sessions that have been quiet past the retention window. */
+function prune(state, retentionDays, now) {
+	const cutoff = now - retentionDays * 864e5;
+	for (const [id, session] of Object.entries(state.sessions)) if (Date.parse(session.lastEventAt) < cutoff) delete state.sessions[id];
+}
+/**
+* Durable JSON state. Writes are debounced and atomic; concurrent writes are
+* serialized so the file never contains a partial body.
+*/
+var StateFile = class {
+	path;
+	state = createState();
+	timer;
+	writing = Promise.resolve();
+	closed = false;
+	retentionDays;
+	constructor(path, retentionDays) {
+		this.path = path;
+		this.retentionDays = retentionDays;
+	}
+	/** Load previous state, or start empty when the file is absent. */
+	async load() {
+		let raw;
+		try {
+			raw = await readFile(this.path, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return;
+			throw error;
+		}
+		const parsed = JSON.parse(raw);
+		this.state = isPluginState(parsed) ? parsed : createState();
+	}
+	/** Request a debounced write. */
+	schedule() {
+		if (this.closed || this.timer) return;
+		this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.write();
+		}, SAVE_DELAY_MS);
+		this.timer.unref?.();
+	}
+	/** Write the current state now. */
+	write() {
+		this.writing = this.writing.then(() => this.writeNow());
+		return this.writing;
+	}
+	/** Flush pending activity and stop accepting writes. */
+	async flush() {
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = void 0;
+		}
+		this.closed = true;
+		await this.write();
+	}
+	async writeNow() {
+		prune(this.state, this.retentionDays, Date.now());
+		const body = `${JSON.stringify(this.state)}\n`;
+		const temporary = `${this.path}.tmp`;
+		await mkdir(dirname(this.path), { recursive: true });
+		await writeFile(temporary, body, "utf8");
+		await rename(temporary, this.path).catch(async (error) => {
+			await rm(temporary, { force: true });
+			throw error;
+		});
+	}
+};
+/** Validate a decoded state file at the durable-file boundary. */
+function isPluginState(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return candidate.version === 1 && typeof candidate.sessions === "object" && candidate.sessions !== null && typeof candidate.settings === "object" && candidate.settings !== null && typeof candidate.settings.autoUpload === "boolean";
+}
+// src/host/rollups.ts
+const BUCKET_MS = 9e5;
+const MAX_TURN_MS = 72e5;
+/** ISO timestamp of the 15-minute bucket that owns `time`. */
+function bucketStamp(time) {
+	return (/* @__PURE__ */ new Date(Math.floor(time / BUCKET_MS) * BUCKET_MS)).toISOString();
+}
+/** Last path segment of a working directory, used as the project label. */
+function projectName(cwd) {
+	if (!cwd) return void 0;
+	const segments = cwd.split(/[\\/]/).filter(Boolean);
+	return segments[segments.length - 1];
+}
+/** Empty time bucket. */
+function emptyBucket(ts) {
+	return {
+		ts,
+		activityCount: 0,
+		sessionStarts: 0,
+		modelCalls: 0,
+		toolCalls: 0,
+		commandCalls: 0,
+		fileReads: 0,
+		fileWrites: 0,
+		linesAdded: 0,
+		linesRemoved: 0,
+		inputTokens: 0,
+		cachedInputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheReadInputTokens: 0,
+		outputTokens: 0,
+		reasoningOutputTokens: 0,
+		totalTokens: 0,
+		estimatedCostUsd: 0
+	};
+}
+/** Empty model rollup. */
+function emptyModel(model) {
+	return {
+		model,
+		callCount: 0,
+		inputTokens: 0,
+		cachedInputTokens: 0,
+		cacheCreationInputTokens: 0,
+		cacheCreation5mInputTokens: 0,
+		cacheCreation1hInputTokens: 0,
+		cacheReadInputTokens: 0,
+		outputTokens: 0,
+		reasoningOutputTokens: 0,
+		totalTokens: 0,
+		estimatedCostUsd: 0
+	};
+}
+/**
+* Folds DSH session events into codetime rollups, one accumulator per session.
+* The persisted cursor makes a repeated history scan add only new events.
+*/
+var SessionFolder = class {
+	state;
+	currentTurn = /* @__PURE__ */ new Map();
+	callNames = /* @__PURE__ */ new Map();
+	constructor(state) {
+		this.state = state;
+	}
+	/** Fold one session's events; returns how many were new. */
+	ingest(session, events) {
+		let folded = 0;
+		for (const event of events) {
+			const existing = this.state.sessions[session.id];
+			if (existing && event.seq <= existing.cursor) continue;
+			const accumulator = this.accumulator(session, event.time);
+			this.record(session.id, accumulator, event);
+			folded += 1;
+		}
+		return folded;
+	}
+	/** Sessions whose local fold differs from the last accepted upload. */
+	pendingSessions() {
+		return Object.values(this.state.sessions).filter((session) => session.uploadedHash !== toWireRollup(session).payloadHash);
+	}
+	accumulator(session, time) {
+		const existing = this.state.sessions[session.id];
+		if (existing) return existing;
+		const stamp = new Date(time).toISOString();
+		const created = {
+			sessionId: session.id,
+			project: projectName(session.cwd),
+			cwd: session.cwd,
+			startedAt: stamp,
+			lastEventAt: stamp,
+			cursor: -1,
+			eventCount: 0,
+			promptCount: 0,
+			turnCount: 0,
+			toolCallCount: 0,
+			commandCallCount: 0,
+			tokens: emptyTokens(),
+			timeBuckets: {},
+			modelRollups: {},
+			modelBuckets: {},
+			toolRollups: {},
+			turnRollups: {}
+		};
+		this.state.sessions[session.id] = created;
+		return created;
+	}
+	bucket(accumulator, time) {
+		const ts = bucketStamp(time);
+		const existing = accumulator.timeBuckets[ts];
+		if (existing) return existing;
+		const created = emptyBucket(ts);
+		accumulator.timeBuckets[ts] = created;
+		return created;
+	}
+	turn(accumulator, turn, time) {
+		const turnId = `turn-${turn}`;
+		const existing = accumulator.turnRollups[turnId];
+		if (existing) return existing;
+		const stamp = new Date(time).toISOString();
+		const created = {
+			turnId,
+			startedAt: stamp,
+			lastEventAt: stamp,
+			promptChars: 0,
+			eventCount: 0,
+			toolCallCount: 0,
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0,
+			durationMs: 0
+		};
+		accumulator.turnRollups[turnId] = created;
+		return created;
+	}
+	record(sessionId, accumulator, event) {
+		const time = event.time;
+		const stamp = new Date(time).toISOString();
+		accumulator.cursor = Math.max(accumulator.cursor, event.seq);
+		accumulator.eventCount += 1;
+		accumulator.lastEventAt = stamp;
+		if (stamp < accumulator.startedAt) accumulator.startedAt = stamp;
+		const bucket = this.bucket(accumulator, time);
+		const current = this.currentTurn.get(sessionId);
+		if (event.type === "turn/start") {
+			accumulator.turnCount += 1;
+			bucket.activityCount += 1;
+			this.turn(accumulator, event.data.turn, time);
+			this.currentTurn.set(sessionId, `turn-${event.data.turn}`);
+		}
+		const turn = current ? accumulator.turnRollups[current] : void 0;
+		if (turn) {
+			turn.lastEventAt = stamp;
+			turn.eventCount += 1;
+		}
+		switch (event.type) {
+			case "user/message":
+				if (event.data.source.kind !== "user") break;
+				accumulator.promptCount += 1;
+				bucket.activityCount += 1;
+				if (turn) {
+					turn.promptSubmittedAt ??= stamp;
+					turn.promptChars += textLength(event.data.content);
+				}
+				break;
+			case "assistant/message": {
+				const source = event.data.message.source;
+				const model = `${source.provider}/${source.model}`;
+				const usage = event.data.usage;
+				const modelRollup = accumulator.modelRollups[model] ?? (accumulator.modelRollups[model] = emptyModel(model));
+				modelRollup.callCount += 1;
+				bucket.modelCalls += 1;
+				bucket.activityCount += 1;
+				const modelBucket = this.modelBucket(accumulator, time, model);
+				modelBucket.callCount += 1;
+				if (usage) {
+					const tokens = {
+						inputTokens: usage.inputTokens,
+						cachedInputTokens: 0,
+						cacheCreationInputTokens: usage.cacheWriteTokens ?? 0,
+						cacheReadInputTokens: usage.cacheReadTokens ?? 0,
+						outputTokens: usage.outputTokens,
+						reasoningOutputTokens: usage.reasoningTokens ?? 0,
+						totalTokens: usage.totalTokens ?? usage.inputTokens + usage.outputTokens
+					};
+					addTokens(modelRollup, tokens);
+					addTokens(modelBucket, tokens);
+					addTokens(accumulator.tokens, tokens);
+					addTokens(bucket, tokens);
+					if (turn) {
+						turn.inputTokens += tokens.inputTokens;
+						turn.outputTokens += tokens.outputTokens;
+						turn.totalTokens += tokens.totalTokens;
+					}
+				}
+				break;
+			}
+			case "tool/call": {
+				const name = event.data.name;
+				accumulator.toolCallCount += 1;
+				bucket.toolCalls += 1;
+				bucket.activityCount += 1;
+				const toolRollup = accumulator.toolRollups[name] ?? (accumulator.toolRollups[name] = {
+					tool: name,
+					callCount: 0,
+					failureCount: 0,
+					totalDurationMs: 0
+				});
+				toolRollup.callCount += 1;
+				this.callNames.set(`${sessionId}:${event.data.callId}`, name);
+				if (turn) turn.toolCallCount += 1;
+				break;
+			}
+			case "tool/result": {
+				if (!event.data.message.isError) break;
+				const key = `${sessionId}:${event.data.message.toolCallId}`;
+				const name = this.callNames.get(key);
+				this.callNames.delete(key);
+				if (!name) break;
+				const toolRollup = accumulator.toolRollups[name] ?? {
+					tool: name,
+					callCount: 0,
+					failureCount: 0,
+					totalDurationMs: 0
+				};
+				toolRollup.failureCount += 1;
+				accumulator.toolRollups[name] = toolRollup;
+				break;
+			}
+			case "turn/end": {
+				const closing = accumulator.turnRollups[`turn-${event.data.turn}`];
+				if (closing) {
+					closing.completedAt = stamp;
+					closing.durationMs = Math.min(Math.max(0, time - Date.parse(closing.startedAt)), MAX_TURN_MS);
+				}
+				this.currentTurn.delete(sessionId);
+				break;
+			}
+		}
+	}
+	modelBucket(accumulator, time, model) {
+		const ts = bucketStamp(time);
+		const key = `${ts}\0${model}`;
+		const existing = accumulator.modelBuckets[key];
+		if (existing) return existing;
+		const { estimatedCostUsd: _ignored, ...rest } = emptyModel(model);
+		const created = {
+			...rest,
+			ts
+		};
+		accumulator.modelBuckets[key] = created;
+		return created;
+	}
+};
+/** Sum text blocks of one message's content. */
+function textLength(content) {
+	let total = 0;
+	for (const block of content) if (block.type === "text" && block.text) total += block.text.length;
+	return total;
+}
+/** Add token counters onto any record that carries the seven token fields. */
+function addTokens(target, tokens) {
+	target.inputTokens += tokens.inputTokens;
+	target.cachedInputTokens += tokens.cachedInputTokens;
+	target.cacheCreationInputTokens += tokens.cacheCreationInputTokens;
+	target.cacheReadInputTokens += tokens.cacheReadInputTokens;
+	target.outputTokens += tokens.outputTokens;
+	target.reasoningOutputTokens += tokens.reasoningOutputTokens;
+	target.totalTokens += tokens.totalTokens;
+}
+/** Deterministic JSON with sorted object keys. */
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value !== null && typeof value === "object") {
+		const record = value;
+		return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+	}
+	return JSON.stringify(value) ?? "null";
+}
+/** `sha256:` hash of a rollup without its own hash field. */
+function payloadHash(rollup) {
+	const { payloadHash: _ignored, ...rest } = rollup;
+	return `sha256:${createHash("sha256").update(stableStringify(rest)).digest("hex")}`;
+}
+/** Project one folded session into the ingest wire body. */
+function toWireRollup(session) {
+	const durationMs = Math.max(0, Date.parse(session.lastEventAt) - Date.parse(session.startedAt));
+	const base = {
+		rollupKey: `rollup:dsh:${session.sessionId}`,
+		payloadHash: "",
+		schemaVersion: 3,
+		source: "dsh",
+		project: session.project,
+		sessionId: session.sessionId,
+		agent: "dsh",
+		startedAt: session.startedAt,
+		lastEventAt: session.lastEventAt,
+		eventCount: session.eventCount,
+		promptCount: session.promptCount,
+		turnCount: session.turnCount,
+		toolCallCount: session.toolCallCount,
+		commandCallCount: session.commandCallCount,
+		inputTokens: session.tokens.inputTokens,
+		cachedInputTokens: session.tokens.cachedInputTokens,
+		cacheCreationInputTokens: session.tokens.cacheCreationInputTokens,
+		cacheReadInputTokens: session.tokens.cacheReadInputTokens,
+		outputTokens: session.tokens.outputTokens,
+		reasoningOutputTokens: session.tokens.reasoningOutputTokens,
+		totalTokens: session.tokens.totalTokens,
+		linesAdded: 0,
+		linesRemoved: 0,
+		durationMs,
+		timeBuckets: Object.values(session.timeBuckets).sort((left, right) => left.ts.localeCompare(right.ts)),
+		modelRollups: Object.values(session.modelRollups).sort((left, right) => right.callCount - left.callCount || left.model.localeCompare(right.model)),
+		modelBuckets: Object.values(session.modelBuckets).sort((left, right) => left.ts.localeCompare(right.ts) || left.model.localeCompare(right.model)),
+		toolRollups: Object.values(session.toolRollups).sort((left, right) => right.callCount - left.callCount || left.tool.localeCompare(right.tool)),
+		fileRollups: [],
+		turnRollups: Object.values(session.turnRollups).sort((left, right) => left.startedAt.localeCompare(right.startedAt))
+	};
+	return {
+		...base,
+		payloadHash: payloadHash(base)
+	};
+}
+// src/index.ts
+/** Cordis plugin name used by loader diagnostics. */
+const name = "codetime";
+/** The Host session store feeds the fold. */
+const inject = ["sessions"];
+/** Schemastery validation for {@link ConfigOptions}. */
+const Config = Schema.object({
+	historyDays: Schema.number().min(0).max(3650).default(30),
+	syncMinutes: Schema.number().min(0).max(1440).default(5),
+	retentionDays: Schema.number().min(7).max(3650).default(120),
+	statePath: Schema.string()
+});
+/** Rollups per ingest request. */
+const BATCH_SIZE = 10;
+/** Quiet period after the last folded event before an automatic upload. */
+const SETTLE_MS = 2e4;
+/** Largest request body the route accepts. */
+const MAX_BODY_BYTES = 4096;
+/** Read one JSON body, tolerating an empty payload. */
+async function readBody(request) {
+	const text = await request.text();
+	if (text.length > MAX_BODY_BYTES) throw new Error("request body too large");
+	if (!text.trim()) return { action: "status" };
+	const parsed = JSON.parse(text);
+	if (typeof parsed !== "object" || parsed === null) throw new Error("request body must be an object");
+	const record = parsed;
+	const action = record.action;
+	return {
+		action: action === "save" || action === "clear" || action === "sync" ? action : "status",
+		token: typeof record.token === "string" ? record.token : void 0,
+		autoUpload: typeof record.autoUpload === "boolean" ? record.autoUpload : void 0
+	};
+}
+/**
+* Fold Harness activity into codetime rollups and keep them uploaded.
+* @param ctx - plugin context; every registration is disposed with it.
+* @param config - fold window, upload cadence, retention, and host overrides.
+*/
+function apply(ctx, config) {
+	const state = new StateFile(config.statePath ?? join(homedir(), ".dsh", "codetime", "state.json"), config.retentionDays ?? 120);
+	const historyDays = config.historyDays ?? 30;
+	const syncMinutes = config.syncMinutes ?? 5;
+	let folder;
+	let scanning = false;
+	let uploading = false;
+	let settle;
+	const queued = [];
+	const scheduleSync = () => {
+		if (settle || !state.state.settings.autoUpload) return;
+		settle = setTimeout(() => {
+			settle = void 0;
+			sync();
+		}, SETTLE_MS);
+		settle.unref?.();
+	};
+	const fold = (id, cwd, events) => {
+		if (!folder) {
+			for (const event of events) queued.push({
+				id,
+				cwd,
+				event
+			});
+			return;
+		}
+		if (folder.ingest({
+			id,
+			cwd
+		}, events) > 0) {
+			state.schedule();
+			scheduleSync();
+		}
+	};
+	ctx.effect(() => ctx.on("session/event", (session, event) => {
+		fold(session.header.id, session.header.cwd, [event]);
+	}));
+	const sync = async () => {
+		if (uploading || !folder) return;
+		const changed = folder.pendingSessions();
+		if (changed.length === 0) return;
+		const token = await resolveToken();
+		if (!token) {
+			state.state.lastError = "token is not configured";
+			await state.write();
+			return;
+		}
+		uploading = true;
+		try {
+			const machineId = await ensureMachineId();
+			const rollups = changed.map(toWireRollup);
+			const totals = {
+				inserted: 0,
+				skipped: 0,
+				conflicts: 0
+			};
+			for (let index = 0; index < rollups.length; index += BATCH_SIZE) {
+				const batch = rollups.slice(index, index + BATCH_SIZE);
+				const result = await uploadRollups({
+					token,
+					machineId,
+					rollups: batch
+				});
+				totals.inserted += result.inserted;
+				totals.skipped += result.skipped;
+				totals.conflicts += result.conflicts;
+				for (const rollup of batch) {
+					const session = state.state.sessions[rollup.sessionId];
+					if (session) session.uploadedHash = rollup.payloadHash;
+				}
+			}
+			state.state.lastUploadAt = Date.now();
+			state.state.lastSync = totals;
+			state.state.lastError = void 0;
+			await state.write();
+		} catch (error) {
+			state.state.lastError = error instanceof Error ? error.message : String(error);
+			await state.write();
+		} finally {
+			uploading = false;
+		}
+	};
+	const status = async () => {
+		const token = await resolveToken();
+		return {
+			configured: Boolean(token),
+			maskedToken: token ? maskToken(token) : void 0,
+			autoUpload: state.state.settings.autoUpload,
+			machineId: await ensureMachineId(),
+			sessions: Object.keys(state.state.sessions).length,
+			pending: folder ? folder.pendingSessions().length : 0,
+			uploading,
+			lastUploadAt: state.state.lastUploadAt,
+			lastError: state.state.lastError,
+			lastSync: state.state.lastSync
+		};
+	};
+	const scan = async () => {
+		if (!folder || scanning) return;
+		scanning = true;
+		try {
+			await scanHistory(ctx, folder, historyDays);
+			state.state.lastScanAt = Date.now();
+			await state.write();
+		} finally {
+			scanning = false;
+			if (state.state.settings.autoUpload) sync();
+		}
+	};
+	const ready = (async () => {
+		await state.load();
+		folder = new SessionFolder(state.state);
+		const pending = queued.splice(0);
+		for (const item of pending) folder.ingest({
+			id: item.id,
+			cwd: item.cwd
+		}, [item.event]);
+		await scan();
+	})().catch((error) => {
+		console.error("codetime: initial fold failed:", error);
+	});
+	ctx.effect(() => {
+		if (syncMinutes <= 0) return () => {};
+		const timer = setInterval(() => {
+			if (state.state.settings.autoUpload) sync();
+		}, syncMinutes * 6e4);
+		timer.unref?.();
+		return () => {
+			clearInterval(timer);
+			if (settle) {
+				clearTimeout(settle);
+				settle = void 0;
+			}
+		};
+	});
+	ctx.effect(() => () => {
+		state.flush();
+	});
+	const connection = ctx.get("connection");
+	if (!connection) return;
+	ctx.effect(() => connection.fetch.register({
+		path: "/api/codetime",
+		methods: ["POST"],
+		requestBody: "buffered",
+		async fetch(request) {
+			try {
+				const body = await readBody(request);
+				await ready;
+				if (body.action === "save") {
+					const token = body.token?.trim();
+					if (token !== void 0 && !token) throw new Error("token must not be empty");
+					if (token !== void 0) await writeToken(token);
+					if (body.autoUpload !== void 0) {
+						state.state.settings.autoUpload = body.autoUpload;
+						await state.write();
+					}
+					sync();
+				}
+				if (body.action === "clear") {
+					await writeToken(void 0);
+					state.state.lastError = void 0;
+					await state.write();
+				}
+				if (body.action === "sync") await sync();
+				return Response.json(await status(), { headers: { "Cache-Control": "no-store" } });
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return Response.json({ error: message }, {
+					status: 400,
+					headers: { "Cache-Control": "no-store" }
+				});
+			}
+		}
+	}));
+}
+export { Config, apply, inject, name };