oh-my-opencode 4.8.0 → 4.9.0

package/packages/omo-codex/plugin/components/start-work-continuation/dist/codex-hook.js

@@ -0,0 +1,80 @@
+import { readContinuationState } from "./boulder-reader.js";
+import { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";
+export function runStopHook(input, fs) {
+    if (!isStopInput(input))
+        return "";
+    if (input.stop_hook_active)
+        return "";
+    if (transcriptHasContextPressureMarker(input.transcript_path, fs))
+        return "";
+    const state = readContinuationState(input.cwd, input.session_id, fs);
+    if (state === null)
+        return "";
+    return JSON.stringify({
+        decision: "block",
+        reason: renderDirective(state, input.session_id),
+    });
+}
+function renderDirective(state, sessionId) {
+    const lineBreak = String.fromCharCode(10);
+    const worktreeBlock = state.worktreePath === null
+        ? ""
+        : `${lineBreak}- Worktree: \`${state.worktreePath}\` (all edits, tests, and commands run inside this directory)`;
+    const replacements = {
+        PLAN_NAME: state.planName,
+        PLAN_PATH: state.planPath,
+        BOULDER_PATH: state.boulderPath,
+        REMAINING_COUNT: String(state.checklist.remaining),
+        TOTAL_COUNT: String(state.checklist.total),
+        NEXT_TASK_LABEL: state.checklist.nextTaskLabel ?? "",
+        WORKTREE_BLOCK: worktreeBlock,
+        LEDGER_PATH: state.ledgerPath,
+        SESSION_ID: sessionId,
+    };
+    let rendered = START_WORK_CONTINUATION_DIRECTIVE;
+    for (const [placeholder, value] of Object.entries(replacements)) {
+        rendered = rendered.replaceAll(`{{${placeholder}}}`, value);
+    }
+    return rendered;
+}
+const CONTEXT_PRESSURE_MARKERS = [
+    "context compacted",
+    "context_length_exceeded",
+    "skill descriptions were shortened",
+    "context_too_large",
+    "codex ran out of room in the model's context window",
+    "your input exceeds the context window",
+    "long threads and multiple compactions",
+];
+function transcriptHasContextPressureMarker(transcriptPath, fs) {
+    try {
+        const transcript = fs.readFileSync(transcriptPath, "utf8").toLowerCase();
+        return CONTEXT_PRESSURE_MARKERS.some((marker) => transcript.includes(marker));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+function isStopInput(value) {
+    return (isRecord(value) &&
+        isStopHookEventName(value["hook_event_name"]) &&
+        typeof value["session_id"] === "string" &&
+        typeof value["turn_id"] === "string" &&
+        typeof value["transcript_path"] === "string" &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["stop_hook_active"] === "boolean" &&
+        optionalString(value["last_assistant_message"]));
+}
+function isStopHookEventName(value) {
+    return value === "Stop" || value === "SubagentStop";
+}
+function optionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/start-work-continuation/dist/directive.d.ts

@@ -0,0 +1 @@
+export declare const START_WORK_CONTINUATION_DIRECTIVE: string;

package/packages/omo-codex/plugin/components/start-work-continuation/dist/directive.js

@@ -0,0 +1,2 @@
+import { readFileSync } from "node:fs";
+export const START_WORK_CONTINUATION_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");

package/packages/omo-codex/plugin/components/start-work-continuation/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { ContinuationState, PlanChecklist } from "./boulder-reader.js";
+export { parsePlanChecklist, readContinuationState } from "./boulder-reader.js";
+export { runStopHook } from "./codex-hook.js";
+export { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";
+export type { ReadonlyFileSystem, StopHookEventName, StopHookOutput, StopInput } from "./types.js";

package/packages/omo-codex/plugin/components/start-work-continuation/dist/index.js

@@ -0,0 +1,3 @@
+export { parsePlanChecklist, readContinuationState } from "./boulder-reader.js";
+export { runStopHook } from "./codex-hook.js";
+export { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";

package/packages/omo-codex/plugin/components/start-work-continuation/dist/types.d.ts

@@ -0,0 +1,20 @@
+export declare const STOP_HOOK_EVENTS: readonly ["Stop", "SubagentStop"];
+export type StopHookEventName = (typeof STOP_HOOK_EVENTS)[number];
+export type StopInput = {
+    readonly hook_event_name: StopHookEventName;
+    readonly session_id: string;
+    readonly turn_id: string;
+    readonly transcript_path: string;
+    readonly cwd: string;
+    readonly model: string;
+    readonly permission_mode: string;
+    readonly stop_hook_active: boolean;
+    readonly last_assistant_message?: string;
+};
+export type StopHookOutput = {
+    readonly decision: "block";
+    readonly reason: string;
+};
+export type ReadonlyFileSystem = {
+    readFileSync(path: string, encoding: "utf8"): string;
+};

package/packages/omo-codex/plugin/components/start-work-continuation/dist/types.js

@@ -0,0 +1 @@
+export const STOP_HOOK_EVENTS = ["Stop", "SubagentStop"];

package/packages/omo-codex/plugin/components/start-work-continuation/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js\" hook stop",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Checking Start-Work Continuation"
+						"statusMessage": "LazyCodex(4.9.0): Checking Start-Work Continuation"
 					}
 				]
 			}
@@ -19,7 +19,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js\" hook subagent-stop",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Checking Start-Work Continuation"
+						"statusMessage": "LazyCodex(4.9.0): Checking Start-Work Continuation"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/start-work-continuation/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-start-work-continuation",
-	"version": "0.1.0",
+	"version": "4.9.0",
 	"description": "Codex Stop hook continuation injector for omo-codex start-work plans.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/start-work-continuation/test/codex-hook.test.ts

@@ -112,12 +112,34 @@ describe("start-work Stop hook", () => {
 		// then
 		const parsed = parseBlockOutput(output);
 		expect(parsed.reason).toMatch(/TASK:/);
-		expect(parsed.reason).toMatch(/fork_turns:\s*"none"/);
+		expect(parsed.reason).toMatch(/fork_context:\s*false/);
 		expect(parsed.reason).toMatch(/wait_agent.*mailbox signals/);
 		expect(parsed.reason).toMatch(/TASK STILL ACTIVE/);
 		expect(parsed.reason).toMatch(/respawn.*smaller/);
 		expect(parsed.reason).toMatch(/WORKING:/);
-		expect(parsed.reason).toMatch(/single `list_agents`/);
+	});
+
+	it("#given active codex work #when continuation directive is emitted #then QA weight is tier-scoped without echo bloat", () => {
+		// given
+		const fs = createMemoryFs({
+			[BOULDER_PATH]: createBoulderJson({
+				sessionIds: ["codex:sess_abc"],
+				status: "active",
+			}),
+			[PLAN_PATH]: ["# Plan", "", "## TODOs", "- [ ] First"].join("\n"),
+		});
+
+		// when
+		const output = runStopHook(createStopInput(), fs);
+
+		// then
+		const parsed = parseBlockOutput(output);
+		expect(parsed.reason).toMatch(/LIGHT/);
+		expect(parsed.reason).toMatch(/HEAVY/);
+		expect(parsed.reason).toMatch(/When unsure[^.]{0,30}HEAVY/);
+		expect(parsed.reason).toMatch(/mirrors its implementation/);
+		expect((parsed.reason.match(/malformed input, prompt injection/g) ?? []).length).toBe(1);
+		expect(parsed.reason.split(/\s+/).filter(Boolean).length).toBeLessThanOrEqual(1100);
 	});
 
 	it("#given active work belongs to another harness #when hook runs #then returns empty output", () => {

package/packages/omo-codex/plugin/components/telemetry/dist/atomic-write.d.ts

@@ -0,0 +1 @@
+export declare function writeFileAtomically(filePath: string, content: string): void;

package/packages/omo-codex/plugin/components/telemetry/dist/atomic-write.js

@@ -0,0 +1,18 @@
+import { renameSync, unlinkSync, writeFileSync } from "node:fs";
+export function writeFileAtomically(filePath, content) {
+    const tempPath = `${filePath}.tmp`;
+    writeFileSync(tempPath, content, "utf-8");
+    try {
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        const isPermissionError = error instanceof Error &&
+            (error.message.includes("EPERM") || error.message.includes("EACCES"));
+        if (process.platform === "win32" && isPermissionError) {
+            unlinkSync(filePath);
+            renameSync(tempPath, filePath);
+            return;
+        }
+        throw error;
+    }
+}

package/packages/omo-codex/plugin/components/telemetry/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/packages/omo-codex/plugin/components/telemetry/dist/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { runSessionStartHook } from "./codex-hook.js";
+const command = process.argv[2];
+const subcommand = process.argv[3];
+if (command === "hook" && subcommand === "session-start") {
+    await runHookCli();
+}
+else {
+    process.stderr.write("Usage: omo-telemetry hook session-start\n");
+    process.exitCode = 1;
+}
+async function runHookCli() {
+    const raw = await readStdin();
+    if (raw.trim().length === 0)
+        return;
+    const parsed = parseHookInput(raw);
+    if (!isCodexSessionStartInput(parsed))
+        return;
+    const output = await runSessionStartHook(parsed);
+    if (output.length > 0) {
+        processStdout.write(output);
+    }
+}
+function parseHookInput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCodexSessionStartInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "SessionStart" &&
+        typeof value["session_id"] === "string" &&
+        isStringOrNull(value["transcript_path"]) &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["source"] === "string");
+}
+function isStringOrNull(value) {
+    return typeof value === "string" || value === null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        processStdin.setEncoding("utf8");
+        processStdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        processStdin.once("error", reject);
+        processStdin.once("end", () => {
+            resolve(data);
+        });
+    });
+}

package/packages/omo-codex/plugin/components/telemetry/dist/codex-hook.d.ts

@@ -0,0 +1,15 @@
+import { type PostHogClient } from "./posthog.js";
+export type CodexSessionStartInput = {
+    session_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "SessionStart";
+    model: string;
+    permission_mode: string;
+    source: "startup" | "resume" | "clear";
+};
+export type CodexTelemetryHookOptions = {
+    createClient?: () => PostHogClient | Promise<PostHogClient>;
+    getDistinctId?: () => string;
+};
+export declare function runSessionStartHook(_input: CodexSessionStartInput, options?: CodexTelemetryHookOptions): Promise<string>;

package/packages/omo-codex/plugin/components/telemetry/dist/codex-hook.js

@@ -0,0 +1,42 @@
+import { writeTelemetryDiagnostic, } from "./diagnostics.js";
+import { createPluginPostHog, getPostHogDistinctId, } from "./posthog.js";
+const SESSION_START_REASON = "session_start";
+function writeHookDiagnostic(event, error, errorKind) {
+    writeTelemetryDiagnostic({
+        event,
+        source: "plugin",
+        error,
+        errorKind,
+    });
+}
+export async function runSessionStartHook(_input, options = {}) {
+    const createClient = options.createClient ?? createPluginPostHog;
+    const getDistinctId = options.getDistinctId ?? getPostHogDistinctId;
+    let client;
+    try {
+        client = await createClient();
+    }
+    catch (error) {
+        writeHookDiagnostic("telemetry_posthog_init_failed", error, error instanceof Error ? "error" : "non_error");
+        return "";
+    }
+    try {
+        client.trackActive(getDistinctId(), SESSION_START_REASON);
+    }
+    catch (error) {
+        writeHookDiagnostic("telemetry_capture_failed", error, error instanceof Error ? "error" : "non_error");
+        await safeShutdown(client);
+        return "";
+    }
+    await safeShutdown(client);
+    return "";
+}
+async function safeShutdown(client) {
+    try {
+        await client.shutdown();
+    }
+    catch (error) {
+        writeHookDiagnostic("telemetry_shutdown_failed", error, error instanceof Error ? "error" : "non_error");
+        return;
+    }
+}

package/packages/omo-codex/plugin/components/telemetry/dist/data-path.d.ts

@@ -0,0 +1,10 @@
+import os from "node:os";
+type OsProvider = Pick<typeof os, "homedir" | "tmpdir">;
+export declare function getOsProvider(): OsProvider;
+/** @internal test-only */
+export declare function __setOsProviderForTesting(provider: OsProvider): void;
+/** @internal test-only */
+export declare function __resetOsProviderForTesting(): void;
+export declare function getDataDir(): string;
+export declare function getActivityStateDir(): string;
+export {};

package/packages/omo-codex/plugin/components/telemetry/dist/data-path.js

@@ -0,0 +1,35 @@
+import { accessSync, constants, mkdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CACHE_DIR_NAME } from "./product-identity.js";
+let osProviderOverride = null;
+export function getOsProvider() {
+    return osProviderOverride ?? os;
+}
+/** @internal test-only */
+export function __setOsProviderForTesting(provider) {
+    osProviderOverride = provider;
+}
+/** @internal test-only */
+export function __resetOsProviderForTesting() {
+    osProviderOverride = null;
+}
+function resolveWritableDirectory(preferredDir, fallbackSuffix) {
+    try {
+        mkdirSync(preferredDir, { recursive: true });
+        accessSync(preferredDir, constants.W_OK);
+        return preferredDir;
+    }
+    catch {
+        const fallbackDir = path.join(getOsProvider().tmpdir(), fallbackSuffix);
+        mkdirSync(fallbackDir, { recursive: true });
+        return fallbackDir;
+    }
+}
+export function getDataDir() {
+    const preferredDataDir = process.env["XDG_DATA_HOME"] ?? path.join(getOsProvider().homedir(), ".local", "share");
+    return resolveWritableDirectory(preferredDataDir, "omo-codex-data");
+}
+export function getActivityStateDir() {
+    return path.join(getDataDir(), CACHE_DIR_NAME);
+}

package/packages/omo-codex/plugin/components/telemetry/dist/diagnostics.d.ts

@@ -0,0 +1,12 @@
+export type TelemetryDiagnosticEvent = "telemetry_activity_state_read_failed" | "telemetry_activity_state_write_failed" | "telemetry_capture_failed" | "telemetry_cpu_info_unavailable" | "telemetry_posthog_import_failed" | "telemetry_posthog_init_failed" | "telemetry_shutdown_failed";
+export type TelemetryDiagnosticSource = "cli" | "install" | "plugin" | "shared";
+export type TelemetryDiagnosticErrorKind = "error" | "non_error";
+export type TelemetryDiagnosticInput = {
+    readonly event: TelemetryDiagnosticEvent;
+    readonly source: TelemetryDiagnosticSource;
+    readonly error?: unknown;
+    readonly errorKind?: TelemetryDiagnosticErrorKind;
+};
+export declare function getTelemetryDiagnosticsFilePath(): string;
+export declare function writeTelemetryDiagnostic(input: TelemetryDiagnosticInput, now?: Date): void;
+export declare function cleanupTelemetryDiagnostics(now?: Date): void;

package/packages/omo-codex/plugin/components/telemetry/dist/diagnostics.js

@@ -0,0 +1,108 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomically } from "./atomic-write.js";
+import { getActivityStateDir } from "./data-path.js";
+const DIAGNOSTICS_FILE_NAME = "telemetry-diagnostics.jsonl";
+const DIAGNOSTICS_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const DIAGNOSTICS_MAX_BYTES = 256 * 1024;
+export function getTelemetryDiagnosticsFilePath() {
+    return join(getActivityStateDir(), DIAGNOSTICS_FILE_NAME);
+}
+export function writeTelemetryDiagnostic(input, now = new Date()) {
+    try {
+        cleanupTelemetryDiagnostics(now);
+        mkdirSync(getActivityStateDir(), { recursive: true });
+        appendFileSync(getTelemetryDiagnosticsFilePath(), `${JSON.stringify(toDiagnosticRecord(input, now))}\n`, "utf-8");
+    }
+    catch {
+        return;
+    }
+}
+export function cleanupTelemetryDiagnostics(now = new Date()) {
+    const diagnosticsFilePath = getTelemetryDiagnosticsFilePath();
+    if (!existsSync(diagnosticsFilePath)) {
+        return;
+    }
+    try {
+        const cutoffMs = now.getTime() - DIAGNOSTICS_RETENTION_MS;
+        const retainedLines = trimToMaxBytes(readFileSync(diagnosticsFilePath, "utf-8")
+            .split("\n")
+            .filter((line) => shouldRetainLine(line, cutoffMs)));
+        writeFileAtomically(diagnosticsFilePath, retainedLines.length === 0 ? "" : `${retainedLines.join("\n")}\n`);
+    }
+    catch {
+        return;
+    }
+}
+function toDiagnosticRecord(input, now) {
+    return {
+        timestamp: now.toISOString(),
+        event: input.event,
+        source: input.source,
+        ...serializeError(input.error, input.errorKind),
+    };
+}
+function serializeError(error, errorKind) {
+    if (error instanceof Error) {
+        return {
+            error_kind: errorKind ?? "error",
+            error_name: error.name,
+            error_message: error.message,
+        };
+    }
+    if (error === undefined) {
+        return {};
+    }
+    return {
+        error_kind: errorKind ?? "non_error",
+        error_name: typeof error,
+        error_message: String(error),
+    };
+}
+function shouldRetainLine(line, cutoffMs) {
+    if (line.length === 0) {
+        return false;
+    }
+    const parsed = parseDiagnosticLine(line);
+    if (parsed === null) {
+        return false;
+    }
+    const timestamp = parsed["timestamp"];
+    if (typeof timestamp !== "string") {
+        return false;
+    }
+    const timestampMs = Date.parse(timestamp);
+    return Number.isFinite(timestampMs) && timestampMs >= cutoffMs;
+}
+function parseDiagnosticLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (!isRecord(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function trimToMaxBytes(lines) {
+    const retained = [];
+    let totalBytes = 0;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (line === undefined) {
+            continue;
+        }
+        const lineBytes = Buffer.byteLength(`${line}\n`, "utf-8");
+        if (totalBytes + lineBytes > DIAGNOSTICS_MAX_BYTES) {
+            break;
+        }
+        retained.unshift(line);
+        totalBytes += lineBytes;
+    }
+    return retained;
+}

package/packages/omo-codex/plugin/components/telemetry/dist/env-flags.d.ts

@@ -0,0 +1,4 @@
+export declare function shouldDisablePostHog(): boolean;
+export declare function getPostHogApiKey(): string;
+export declare function hasPostHogApiKey(): boolean;
+export declare function getPostHogHost(): string;

package/packages/omo-codex/plugin/components/telemetry/dist/env-flags.js

@@ -0,0 +1,31 @@
+import { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST, } from "./product-identity.js";
+function normalizeEnvValue(value) {
+    return value?.trim().toLowerCase();
+}
+function isDisableFlag(value) {
+    const normalized = normalizeEnvValue(value);
+    return normalized === "1" || normalized === "true";
+}
+function isTelemetryOptOutFlag(value) {
+    const normalized = normalizeEnvValue(value);
+    return normalized === "0" || normalized === "false" || normalized === "no";
+}
+export function shouldDisablePostHog() {
+    return (isDisableFlag(process.env["OMO_DISABLE_POSTHOG"]) ||
+        isTelemetryOptOutFlag(process.env["OMO_SEND_ANONYMOUS_TELEMETRY"]) ||
+        isDisableFlag(process.env["OMO_CODEX_DISABLE_POSTHOG"]) ||
+        isTelemetryOptOutFlag(process.env["OMO_CODEX_SEND_ANONYMOUS_TELEMETRY"]));
+}
+export function getPostHogApiKey() {
+    const explicit = process.env["POSTHOG_API_KEY"];
+    if (explicit === undefined) {
+        return DEFAULT_POSTHOG_API_KEY;
+    }
+    return explicit.trim();
+}
+export function hasPostHogApiKey() {
+    return getPostHogApiKey().length > 0;
+}
+export function getPostHogHost() {
+    return process.env["POSTHOG_HOST"]?.trim() || DEFAULT_POSTHOG_HOST;
+}

package/packages/omo-codex/plugin/components/telemetry/dist/posthog-activity-state.d.ts

@@ -0,0 +1,8 @@
+export type PostHogActivityState = {
+    readonly lastActiveDayUTC?: string;
+};
+export type PostHogActivityCaptureState = {
+    readonly dayUTC: string;
+    readonly captureDaily: boolean;
+};
+export declare function getPostHogActivityCaptureState(now?: Date): PostHogActivityCaptureState;

package/packages/omo-codex/plugin/components/telemetry/dist/posthog-activity-state.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomically } from "./atomic-write.js";
+import { getActivityStateDir } from "./data-path.js";
+import { writeTelemetryDiagnostic } from "./diagnostics.js";
+const POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
+function getPostHogActivityStateFilePath() {
+    return join(getActivityStateDir(), POSTHOG_ACTIVITY_STATE_FILE);
+}
+function getUtcDayString(date) {
+    return date.toISOString().slice(0, 10);
+}
+function isPostHogActivityState(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function writeActivityStateDiagnostic(event, error, errorKind) {
+    writeTelemetryDiagnostic({
+        event,
+        source: "shared",
+        error,
+        errorKind,
+    });
+}
+function readPostHogActivityState() {
+    const stateFilePath = getPostHogActivityStateFilePath();
+    if (!existsSync(stateFilePath)) {
+        return {};
+    }
+    try {
+        const stateContent = readFileSync(stateFilePath, "utf-8");
+        const stateJson = JSON.parse(stateContent);
+        if (!isPostHogActivityState(stateJson)) {
+            return {};
+        }
+        return stateJson;
+    }
+    catch (error) {
+        writeActivityStateDiagnostic("telemetry_activity_state_read_failed", error, error instanceof Error ? "error" : "non_error");
+        return {};
+    }
+}
+function writePostHogActivityState(nextState) {
+    const stateDir = getActivityStateDir();
+    const stateFilePath = getPostHogActivityStateFilePath();
+    try {
+        mkdirSync(stateDir, { recursive: true });
+        writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}\n`);
+    }
+    catch (error) {
+        writeActivityStateDiagnostic("telemetry_activity_state_write_failed", error, error instanceof Error ? "error" : "non_error");
+        return;
+    }
+}
+export function getPostHogActivityCaptureState(now = new Date()) {
+    const state = readPostHogActivityState();
+    const dayUTC = getUtcDayString(now);
+    const captureDaily = state.lastActiveDayUTC !== dayUTC;
+    if (captureDaily) {
+        writePostHogActivityState({
+            ...state,
+            lastActiveDayUTC: dayUTC,
+        });
+    }
+    return {
+        dayUTC,
+        captureDaily,
+    };
+}

package/packages/omo-codex/plugin/components/telemetry/dist/posthog.d.ts

@@ -0,0 +1,21 @@
+import os from "node:os";
+import { getPostHogActivityCaptureState } from "./posthog-activity-state.js";
+import { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST } from "./product-identity.js";
+export { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST };
+export type PostHogActivityReason = "session_start";
+export type PostHogClient = {
+    trackActive: (distinctId: string, reason: PostHogActivityReason) => void;
+    shutdown: () => Promise<void>;
+};
+type OsProvider = Pick<typeof os, "arch" | "cpus" | "hostname" | "platform" | "release" | "totalmem" | "type">;
+type ActivityStateProvider = typeof getPostHogActivityCaptureState;
+export declare function createPluginPostHog(): Promise<PostHogClient>;
+export declare function getPostHogDistinctId(): string;
+/** @internal test-only */
+export declare function __setOsProviderForTesting(provider: OsProvider): void;
+/** @internal test-only */
+export declare function __resetOsProviderForTesting(): void;
+/** @internal test-only */
+export declare function __setActivityStateProviderForTesting(provider: ActivityStateProvider): void;
+/** @internal test-only */
+export declare function __resetActivityStateProviderForTesting(): void;