harnery 0.34.0 → 0.35.0

package/dist/core/semantic/service.js

@@ -0,0 +1,470 @@
+import { spawn } from "node:child_process";
+import { randomBytes, randomUUID } from "node:crypto";
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync, } from "node:fs";
+import { hostname } from "node:os";
+import { dirname, resolve } from "node:path";
+import { readEventV3ControlState, readLedgerV3Since, } from "../events/v3/index.js";
+import { eventV3ActiveWatchPath } from "../events/v3/reader.js";
+import { runSemanticOnce } from "./once.js";
+import { readSemanticServiceStatus, SEMANTIC_SERVICE_STATUS_SCHEMA_VERSION, } from "./service-status.js";
+import { listSemanticAgentDocuments, readSemanticManifest, semanticPaths, writeSemanticManifest, } from "./storage.js";
+export { readSemanticServiceStatus, SEMANTIC_SERVICE_STATUS_SCHEMA_VERSION, } from "./service-status.js";
+export const SEMANTIC_SERVICE_DEFAULT_DEBOUNCE_MS = 5_000;
+export const SEMANTIC_SERVICE_DEFAULT_WAKE_MS = 1_000;
+export const SEMANTIC_SERVICE_DEFAULT_HEARTBEAT_MS = 5_000;
+const FOREIGN_STATUS_STALE_MS = 2 * 60_000;
+const MAX_FILE_BYTES = 512 * 1024;
+const MAX_LOG_BYTES = 512 * 1024;
+const REPEATED_ERROR_LOG_INTERVAL_MS = 60_000;
+export async function spawnSemanticService(coordRootRaw, options = {}) {
+    const coordRoot = resolve(coordRootRaw);
+    const current = readSemanticServiceStatus(coordRoot);
+    if (current.running) {
+        throw new Error(`semantic service is already running under pid ${current.record?.pid}`);
+    }
+    const paths = semanticPaths(coordRoot);
+    mkdirSync(paths.root, { recursive: true, mode: 0o700 });
+    const logFd = openSync(paths.log, "a", 0o600);
+    chmodSync(paths.log, 0o600);
+    const harnBin = new URL("../../../bin/harn", import.meta.url).pathname;
+    if (!existsSync(harnBin)) {
+        closeSync(logFd);
+        throw new Error(`cannot find harn executable at ${harnBin}`);
+    }
+    const args = ["semantic", "service", "daemon", "--root", coordRoot];
+    if (options.callsPerHour !== undefined) {
+        args.push("--calls-per-hour", String(options.callsPerHour));
+    }
+    let spawnError;
+    const child = spawn(harnBin, args, {
+        cwd: coordRoot,
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: {
+            ...process.env,
+            HARNERY_COORD_ROOT_OVERRIDE: coordRoot,
+            HARNERY_OUTPUT_SESSION_TEE: "0",
+        },
+    });
+    child.once("error", (error) => {
+        spawnError = error;
+    });
+    closeSync(logFd);
+    child.unref();
+    const deadline = Date.now() + 5_000;
+    while (Date.now() < deadline) {
+        await delay(50);
+        if (spawnError)
+            throw spawnError;
+        const status = readSemanticServiceStatus(coordRoot);
+        if (status.running && status.record?.pid === child.pid)
+            return status;
+        if (child.exitCode !== null)
+            break;
+    }
+    throw new Error(`semantic service failed to start; inspect ${paths.log}`);
+}
+/**
+ * Start semantic reading when V3 is active, unless an operator paused it.
+ *
+ * Dashboard hosts call this before launching their web process. A failed
+ * semantic launch is reported as data instead of throwing so the read-only
+ * dashboard remains available.
+ */
+export async function ensureSemanticServiceRunning(coordRootRaw, overrides = {}) {
+    const coordRoot = resolve(coordRootRaw);
+    const dependencies = {
+        readStatus: readSemanticServiceStatus,
+        start: spawnSemanticService,
+        isPaused: (root) => existsSync(semanticPaths(root).stop),
+        isActive: (root) => readEventV3ControlState(root).state === "active",
+        ...overrides,
+    };
+    const status = dependencies.readStatus(coordRoot);
+    if (status.running)
+        return { state: "running", status };
+    if (dependencies.isPaused(coordRoot))
+        return { state: "paused", status };
+    if (!dependencies.isActive(coordRoot))
+        return { state: "inactive", status };
+    try {
+        return { state: "started", status: await dependencies.start(coordRoot) };
+    }
+    catch (error) {
+        return {
+            state: "unavailable",
+            status: dependencies.readStatus(coordRoot),
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function requestSemanticServiceStop(coordRootRaw) {
+    const coordRoot = resolve(coordRootRaw);
+    const status = readSemanticServiceStatus(coordRoot);
+    mkdirSync(semanticPaths(coordRoot).root, { recursive: true, mode: 0o700 });
+    writePrivateJsonAtomic(semanticPaths(coordRoot).stop, {
+        requested_at: new Date().toISOString(),
+        requested_by_pid: process.pid,
+    });
+    if (status.running && status.record?.host === hostname()) {
+        try {
+            process.kill(status.record.pid, "SIGTERM");
+        }
+        catch {
+            // The durable stop request remains for a racing or restarted daemon.
+        }
+    }
+    return readSemanticServiceStatus(coordRoot);
+}
+export async function runSemanticServiceDaemon(input) {
+    const coordRoot = resolve(input.coordRoot);
+    const paths = semanticPaths(coordRoot);
+    const release = acquireSemanticServiceLease(coordRoot);
+    rmSync(paths.stop, { force: true });
+    const now = input.now ?? (() => new Date());
+    const debounceMs = Math.max(0, input.debounceMs ?? SEMANTIC_SERVICE_DEFAULT_DEBOUNCE_MS);
+    const wakeIntervalMs = positiveInterval(input.wakeIntervalMs ?? SEMANTIC_SERVICE_DEFAULT_WAKE_MS, "wake interval");
+    const heartbeatIntervalMs = positiveInterval(input.heartbeatIntervalMs ?? SEMANTIC_SERVICE_DEFAULT_HEARTBEAT_MS, "heartbeat interval");
+    const readSince = input.readSince ?? readLedgerV3Since;
+    const runOnce = input.runOnce ??
+        (async (options) => await runSemanticOnce({
+            coordRoot: options.coordRoot,
+            callsPerHour: options.callsPerHour,
+            debounceMs: options.debounceMs,
+            shouldStop: options.shouldStop,
+        }));
+    const startedAt = now().toISOString();
+    const status = {
+        schema_version: SEMANTIC_SERVICE_STATUS_SCHEMA_VERSION,
+        pid: process.pid,
+        host: hostname(),
+        nonce: randomUUID(),
+        state: "starting",
+        started_at: startedAt,
+        heartbeat_at: startedAt,
+        ...(input.callsPerHour !== undefined ? { calls_per_hour: input.callsPerHour } : {}),
+        sweep_count: 0,
+        pass_count: 0,
+        model_calls: 0,
+        cache_hits: 0,
+    };
+    let stopRequested = false;
+    let dirtySince;
+    let lastLoggedErrorCode;
+    let lastLoggedErrorAt = Number.NEGATIVE_INFINITY;
+    const writeStatus = () => {
+        status.heartbeat_at = now().toISOString();
+        writePrivateJsonAtomic(paths.service, status);
+    };
+    const requestStop = () => {
+        stopRequested = true;
+        status.state = "stopping";
+        writeStatus();
+    };
+    process.on("SIGINT", requestStop);
+    process.on("SIGTERM", requestStop);
+    status.state = "running";
+    writeStatus();
+    appendSemanticServiceLog(coordRoot, { event: "service_started" });
+    const heartbeat = setInterval(() => {
+        try {
+            writeStatus();
+        }
+        catch {
+            // A later sweep or status read will expose the stopped or stale process.
+        }
+    }, heartbeatIntervalMs);
+    try {
+        while (!stopRequested && !existsSync(paths.stop)) {
+            const sweepAt = now();
+            status.sweep_count += 1;
+            try {
+                const before = safeManifest(coordRoot);
+                let read = readSince(coordRoot, before?.cursor, { authority: "active" });
+                if (read.reset_required) {
+                    read = readSince(coordRoot, undefined, { authority: "active" });
+                }
+                requireCompleteLedger(read);
+                if (read.events.length > 0 || !before?.cursor) {
+                    dirtySince ??= sweepAt.getTime();
+                }
+                const hasPending = (before?.pending.length ?? 0) > 0;
+                const hasEligibleDeferred = listSemanticAgentDocuments(coordRoot).some((document) => document.reader_outcome === "deferred" &&
+                    Date.parse(document.receipt.eligible_after) <= sweepAt.getTime());
+                if (hasPending ||
+                    hasEligibleDeferred ||
+                    (dirtySince !== undefined && sweepAt.getTime() - dirtySince >= debounceMs)) {
+                    const report = await runOnce({
+                        coordRoot,
+                        ...(input.callsPerHour !== undefined ? { callsPerHour: input.callsPerHour } : {}),
+                        debounceMs,
+                        shouldStop: () => stopRequested || existsSync(paths.stop),
+                    });
+                    status.pass_count += 1;
+                    status.model_calls += report.model_calls;
+                    status.cache_hits += report.cache_hits;
+                    status.last_pass_at = report.completed_at;
+                    status.last_error_code = undefined;
+                    lastLoggedErrorCode = undefined;
+                    const after = safeManifest(coordRoot);
+                    if (after && read.cursor) {
+                        after.cursor = read.cursor;
+                        writeSemanticManifest(coordRoot, after);
+                    }
+                    dirtySince = undefined;
+                    const logEntry = {
+                        event: "pass",
+                        evidence_count: report.evidence_count,
+                        evidence_by_harness: report.evidence_by_harness,
+                        model_calls: report.model_calls,
+                        cache_hits: report.cache_hits,
+                        accepted: report.outcomes.filter((outcome) => outcome.action === "accepted").length,
+                        unavailable: report.outcomes.filter((outcome) => outcome.action === "unavailable")
+                            .length,
+                        invalid: report.outcomes.filter((outcome) => outcome.action === "invalid").length,
+                        deferred: report.outcomes.filter((outcome) => outcome.action === "deferred").length,
+                        harness_metrics: semanticHarnessMetrics(report),
+                    };
+                    if (report.model_calls > 0 || report.cache_hits > 0 || logEntry.unavailable > 0) {
+                        appendSemanticServiceLog(coordRoot, logEntry);
+                    }
+                }
+            }
+            catch (error) {
+                status.last_error_code = serviceErrorCode(error);
+                if (status.last_error_code !== lastLoggedErrorCode ||
+                    sweepAt.getTime() - lastLoggedErrorAt >= REPEATED_ERROR_LOG_INTERVAL_MS) {
+                    appendSemanticServiceLog(coordRoot, {
+                        event: "sweep_error",
+                        reason_code: status.last_error_code,
+                    });
+                    lastLoggedErrorCode = status.last_error_code;
+                    lastLoggedErrorAt = sweepAt.getTime();
+                }
+            }
+            status.last_sweep_at = now().toISOString();
+            writeStatus();
+            if (input.maxSweeps !== undefined && status.sweep_count >= input.maxSweeps)
+                break;
+            if (!stopRequested && !existsSync(paths.stop)) {
+                if (input.waitForWake)
+                    await input.waitForWake(wakeIntervalMs);
+                else
+                    await waitForLedgerWake(eventV3ActiveWatchPath(coordRoot), wakeIntervalMs);
+            }
+        }
+    }
+    finally {
+        clearInterval(heartbeat);
+        process.off("SIGINT", requestStop);
+        process.off("SIGTERM", requestStop);
+        status.state = "stopped";
+        status.stopped_at = now().toISOString();
+        writeStatus();
+        appendSemanticServiceLog(coordRoot, {
+            event: "service_stopped",
+            sweeps: status.sweep_count,
+            passes: status.pass_count,
+            model_calls: status.model_calls,
+        });
+        release();
+    }
+    return status;
+}
+export function acquireSemanticServiceLease(coordRootRaw) {
+    const path = semanticPaths(coordRootRaw).lease;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const owner = {
+        pid: process.pid,
+        host: hostname(),
+        nonce: randomUUID(),
+        created_at: new Date().toISOString(),
+    };
+    const acquire = () => {
+        try {
+            const fd = openSync(path, "wx", 0o600);
+            try {
+                writeFileSync(fd, `${JSON.stringify(owner)}\n`, "utf8");
+            }
+            finally {
+                closeSync(fd);
+            }
+            return true;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            return false;
+        }
+    };
+    if (!acquire()) {
+        const existing = readLease(path);
+        if (existing && leaseOwnerIsLive(existing)) {
+            throw new Error(`semantic service is already running under pid ${existing.pid}`);
+        }
+        unlinkSync(path);
+        if (!acquire())
+            throw new Error("semantic service lease raced with another process");
+    }
+    return () => {
+        try {
+            const existing = readLease(path);
+            if (existing?.nonce === owner.nonce)
+                unlinkSync(path);
+        }
+        catch {
+            // A later explicit start can recover a stale private lease.
+        }
+    };
+}
+function semanticHarnessMetrics(report) {
+    const metrics = {
+        "claude-code": emptyHarnessMetrics(report.evidence_by_harness["claude-code"]),
+        codex: emptyHarnessMetrics(report.evidence_by_harness.codex),
+        cursor: emptyHarnessMetrics(report.evidence_by_harness.cursor),
+    };
+    for (const outcome of report.outcomes) {
+        const harness = metrics[outcome.source_harness];
+        if (outcome.model_call)
+            harness.model_calls += 1;
+        if (outcome.action === "cached")
+            harness.cache_hits += 1;
+        if (outcome.action === "accepted")
+            harness.accepted += 1;
+        if (outcome.action === "unavailable")
+            harness.unavailable += 1;
+        if (outcome.action === "invalid")
+            harness.invalid += 1;
+        if (outcome.action === "deferred")
+            harness.deferred += 1;
+        if (outcome.duration_ms !== undefined)
+            harness.duration_ms.push(outcome.duration_ms);
+        if (outcome.input_bytes !== undefined)
+            harness.input_bytes.push(outcome.input_bytes);
+        if (outcome.output_bytes !== undefined)
+            harness.output_bytes.push(outcome.output_bytes);
+    }
+    return metrics;
+}
+function emptyHarnessMetrics(evidenceCount) {
+    return {
+        evidence_count: evidenceCount,
+        model_calls: 0,
+        cache_hits: 0,
+        accepted: 0,
+        unavailable: 0,
+        invalid: 0,
+        deferred: 0,
+        duration_ms: [],
+        input_bytes: [],
+        output_bytes: [],
+    };
+}
+function requireCompleteLedger(read) {
+    if (!read.complete || read.diagnostics.length > 0)
+        throw new Error("ledger_unavailable");
+}
+function serviceErrorCode(error) {
+    return error instanceof Error && error.message === "ledger_unavailable"
+        ? "ledger_unavailable"
+        : "semantic_pass_failed";
+}
+function safeManifest(coordRoot) {
+    try {
+        return readSemanticManifest(coordRoot);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readLease(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (!Number.isSafeInteger(value.pid) ||
+            (value.pid ?? 0) < 1 ||
+            typeof value.host !== "string" ||
+            typeof value.nonce !== "string" ||
+            !validTimestamp(value.created_at)) {
+            return undefined;
+        }
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function leaseOwnerIsLive(lease) {
+    if (lease.host !== hostname()) {
+        const age = Date.now() - Date.parse(lease.created_at);
+        return Number.isFinite(age) && age < FOREIGN_STATUS_STALE_MS;
+    }
+    return pidAlive(lease.pid);
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function waitForLedgerWake(path, milliseconds) {
+    await new Promise((done) => {
+        let settled = false;
+        let watcher;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            watcher?.close();
+            done();
+        };
+        const timer = setTimeout(finish, milliseconds);
+        try {
+            watcher = watch(path, { persistent: false }, finish);
+        }
+        catch {
+            // The timer is the polling fallback when the active file does not exist yet.
+        }
+    });
+}
+function appendSemanticServiceLog(coordRoot, entry) {
+    const path = semanticPaths(coordRoot).log;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    appendFileSync(path, `${JSON.stringify({ schema_version: 1, ts: new Date().toISOString(), ...entry })}\n`, { encoding: "utf8", mode: 0o600 });
+    chmodSync(path, 0o600);
+    if (statSync(path).size <= MAX_LOG_BYTES)
+        return;
+    const buffer = readFileSync(path);
+    const tail = buffer.subarray(Math.max(0, buffer.length - Math.floor(MAX_LOG_BYTES / 2)));
+    const newline = tail.indexOf(10);
+    const body = newline >= 0 ? tail.subarray(newline + 1) : tail;
+    const temporary = `${path}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+    writeFileSync(temporary, body, { flag: "wx", mode: 0o600 });
+    renameSync(temporary, path);
+}
+function writePrivateJsonAtomic(path, value) {
+    const body = `${JSON.stringify(value, null, 2)}\n`;
+    if (Buffer.byteLength(body) > MAX_FILE_BYTES) {
+        throw new Error(`semantic service file exceeds ${MAX_FILE_BYTES} bytes`);
+    }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    chmodSync(dirname(path), 0o700);
+    const temporary = `${path}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+    writeFileSync(temporary, body, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    renameSync(temporary, path);
+    chmodSync(path, 0o600);
+}
+function validTimestamp(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function positiveInterval(value, label) {
+    if (!Number.isFinite(value) || value < 1)
+        throw new Error(`${label} must be positive`);
+    return Math.floor(value);
+}
+function delay(milliseconds) {
+    return new Promise((done) => setTimeout(done, milliseconds));
+}

package/dist/core/semantic/storage.d.ts

@@ -0,0 +1,71 @@
+import type { LedgerCursorV3 } from "../events/v3/reader.js";
+import { SEMANTIC_EVIDENCE_CONTRACT_VERSION, SEMANTIC_PROMPT_CONTRACT_VERSION, type SemanticAgentReadModelV2, type SemanticConfiguredModel, type SemanticHarness } from "./contract.js";
+export declare const SEMANTIC_MANIFEST_SCHEMA_VERSION: 2;
+export interface SemanticReaderResolution {
+    harness: SemanticHarness;
+    configured_model: SemanticConfiguredModel;
+    resolved_model_id?: string;
+    model_attestation?: "verified" | "requested-only";
+    available: boolean;
+    reason_code?: "harness_unavailable" | "authentication_unavailable" | "model_unavailable" | "model_mismatch";
+    discovered_at: string;
+}
+export interface SemanticPendingItem {
+    generation_id: string;
+    evidence_digest: `sha256:${string}`;
+    band: 1 | 2;
+    pending_since: string;
+}
+export interface SemanticCallReceipt {
+    generation_id: string;
+    started_at: string;
+}
+export interface SemanticManifestV2 {
+    schema_version: typeof SEMANTIC_MANIFEST_SCHEMA_VERSION;
+    ledger_genesis_id: string;
+    cursor?: LedgerCursorV3;
+    configuration_digest: `sha256:${string}`;
+    evidence_contract_version: typeof SEMANTIC_EVIDENCE_CONTRACT_VERSION;
+    prompt_contract_version: typeof SEMANTIC_PROMPT_CONTRACT_VERSION;
+    adapter_resolutions: Partial<Record<SemanticHarness, SemanticReaderResolution>>;
+    pending: SemanticPendingItem[];
+    call_history: SemanticCallReceipt[];
+    last_first_band_generation_id?: string;
+    newest_successful_pass?: string;
+    updated_at: string;
+}
+export interface SemanticCacheIdentity {
+    evidence_digest: `sha256:${string}`;
+    source_harness: SemanticHarness;
+    configured_model: SemanticConfiguredModel;
+    resolved_model_id: string;
+    evidence_contract_version: number;
+    prompt_contract_version: number;
+}
+export declare function semanticPaths(coordRootRaw: string): {
+    root: string;
+    manifest: string;
+    agents: string;
+    cache: string;
+    service: string;
+    stop: string;
+    lease: string;
+    log: string;
+};
+export declare function semanticConfigurationDigest(resolutions: Partial<Record<SemanticHarness, SemanticReaderResolution>>): `sha256:${string}`;
+export declare function semanticCacheKey(identity: SemanticCacheIdentity): `sha256:${string}`;
+export declare function readSemanticManifest(coordRootRaw: string): SemanticManifestV2 | undefined;
+export declare function writeSemanticManifest(coordRootRaw: string, manifest: SemanticManifestV2): void;
+export declare function readSemanticAgentDocument(coordRootRaw: string, generationId: string): SemanticAgentReadModelV2 | undefined;
+export declare function listSemanticAgentDocuments(coordRootRaw: string): SemanticAgentReadModelV2[];
+export declare function inspectSemanticDocument(coordRootRaw: string, instanceOrGeneration: string): SemanticAgentReadModelV2 | undefined;
+export declare function writeSemanticAgentDocument(coordRootRaw: string, document: SemanticAgentReadModelV2): void;
+export declare function readSemanticCache(coordRootRaw: string, cacheKey: string): SemanticAgentReadModelV2 | undefined;
+export declare function writeSemanticCache(coordRootRaw: string, cacheKey: string, document: SemanticAgentReadModelV2): void;
+export declare function invalidateSemanticDerivedState(coordRootRaw: string): void;
+export declare function pruneSemanticStorage(coordRootRaw: string, options: {
+    keepGenerations: ReadonlySet<string>;
+    now?: number;
+    maxCacheFiles?: number;
+}): void;
+//# sourceMappingURL=storage.d.ts.map

package/dist/core/semantic/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/core/semantic/storage.ts"],"names":[],"mappings":"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"}