harnery 0.32.0 → 0.34.0

package/dist/core/events/v3/producers/command-recorder.js

@@ -0,0 +1,477 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { hostname } from "node:os";
+import { join, resolve } from "node:path";
+import { fsyncParentDirectory } from "../../../workflow/durable-record.js";
+import { acquireNoClobberLease } from "../../../workflow/workspaces/leases.js";
+import { selectCommandParentSpan } from "../../span-parent.js";
+import { buildEventV3 } from "../builder.js";
+import { normalizeNativeIdV3 } from "../canonical.js";
+import { markObservedClockRegressionV3 } from "../clock-order.js";
+import { readEventV3ControlState } from "../control.js";
+import { fingerprintContextV3 } from "../fingerprint-keys.js";
+import { clockIdV3, spanIdV3 } from "../ids.js";
+import { tryWriteLiveDisplayV3 } from "../live-feed.js";
+import { closeSpanStateV3, openSpanStateV3 } from "../span-state.js";
+import { assertEventV3, validateEventV3 } from "../validate.js";
+import { EVENT_V3_LEDGER_RELATIVE_ROOT, writeEventV3, } from "../writer.js";
+import { normalizeCommandEventV3, } from "./command.js";
+import { readHookProducerStateByInstanceV3 } from "./recorder.js";
+const COMMAND_STATE_FORMAT = "harnery-v3-command-producer";
+const COMMAND_STATE_VERSION = 1;
+const MAX_OBSERVATIONS = 512;
+/**
+ * Join a CLI/session-tee command to an already-started hook generation and
+ * record it through its own crash-recoverable producer sequence. This is
+ * inert until the exact candidate or active control gate is open.
+ */
+export function recordCommandSignalV3(input) {
+    const control = readEventV3ControlState(input.coordRoot);
+    if (control.state !== input.mode) {
+        return { state: "gate_closed", reason: control.state };
+    }
+    const hook = readHookProducerStateByInstanceV3(input.coordRoot, input.instance_id);
+    if (!hook || hook.adapter !== input.adapter) {
+        return { state: "generation_unavailable", reason: "hook_generation_not_joinable" };
+    }
+    if (!hook.current_turn_id) {
+        return { state: "generation_unavailable", reason: "turn_not_started" };
+    }
+    const rootId = control.genesis.event.scope.root_id;
+    const epochId = control.genesis.profile.privacy_key_epoch;
+    const rootContext = fingerprintContextV3(input.coordRoot, rootId, undefined, epochId);
+    const commandSource = normalizeNativeIdV3(rootContext, "session-tee.command", `${input.adapter}\0${hook.session_id}\0${input.observation.native_command_id}`);
+    const sourceId = observationSourceId(input, rootContext);
+    if (!sourceId)
+        return { state: "missing_observation_id" };
+    const path = commandStatePath(input.coordRoot, commandSource);
+    const lease = acquireCommandLease(input.coordRoot, path);
+    try {
+        let state = existsSync(path) ? readCommandState(path) : undefined;
+        if (state && !matchesHookState(state, hook, input, epochId)) {
+            throw new Error("V3 command producer state does not match the joined hook generation");
+        }
+        let recovered = false;
+        if (state?.pending) {
+            const pending = state.pending;
+            const durability = writeEventV3(input.coordRoot, pending.event);
+            applyCommandEvent(state, pending.source_id, pending.event);
+            state.pending = undefined;
+            publishCommandState(path, state);
+            if (pending.source_id === sourceId) {
+                maybeWriteCommandLiveDisplay(input.coordRoot, pending.event, input.observation);
+                return { state: "recorded", event: pending.event, durability, recovered: true };
+            }
+            recovered = true;
+        }
+        if (state) {
+            const already = state.observations.find((observation) => observation.source_id === sourceId);
+            if (already)
+                return { state: "already_recorded", event_id: already.event_id };
+        }
+        if (input.signal === "command.started") {
+            if (state) {
+                return {
+                    state: "already_recorded",
+                    event_id: state.observations[0]?.event_id ?? state.last_event_id,
+                };
+            }
+            state = newCommandState(input, hook, epochId);
+        }
+        else if (!state) {
+            return { state: "command_span_unstarted" };
+        }
+        if (state.terminal)
+            return { state: "command_span_unstarted" };
+        const fingerprintContext = fingerprintContextV3(input.coordRoot, rootId, state.generation_id, state.privacy_epoch_id);
+        const event = normalizeCommandEventV3(input.signal, input.observation, {
+            root_id: rootId,
+            instance_id: state.instance_id,
+            session_id: state.session_id,
+            generation_id: state.generation_id,
+            turn_id: state.turn_id,
+            attestation_id: state.attestation_id,
+            producer_id: input.producer_id,
+            boot_id: state.boot_id,
+            sequence: state.next_sequence,
+            build_id: input.build_id,
+            platform: input.platform,
+            bridge: input.bridge,
+            span_id: state.span_id,
+            parent_span_id: state.parent_span_id,
+            caused_by: [
+                state.last_event_id,
+                ...(input.signal === "command.completed" && state.open_event_id
+                    ? [state.open_event_id]
+                    : []),
+            ].filter((value, index, values) => values.indexOf(value) === index),
+            observed_at: input.observed_at,
+            monotonic_ns: input.monotonic_ns,
+            clock_id: state.clock_id,
+            terminal_span: input.signal === "command.completed"
+                ? closeSpanStateV3({
+                    span_id: state.span_id,
+                    ...(state.parent_span_id ? { parent_span_id: state.parent_span_id } : {}),
+                    opened_at: state.opened_at,
+                    boot_id: state.boot_id,
+                    ...(state.opened_monotonic_ns
+                        ? { opened_monotonic_ns: state.opened_monotonic_ns }
+                        : {}),
+                    ...(state.open_event_id ? { open_event_id: state.open_event_id } : {}),
+                }, {
+                    boot_id: state.boot_id,
+                    clock: {
+                        observed_at: input.observed_at ?? new Date().toISOString(),
+                        ...(input.monotonic_ns ? { monotonic_ns: input.monotonic_ns } : {}),
+                    },
+                })
+                : undefined,
+            fingerprintContext,
+            attribution_method: "session_env",
+        });
+        if (!event)
+            return { state: "command_span_unstarted" };
+        markObservedClockRegressionV3(event, state.last_observed_at);
+        state.pending = { source_id: sourceId, event };
+        publishCommandState(path, state);
+        const durability = writeEventV3(input.coordRoot, event, input.writerOptions);
+        applyCommandEvent(state, sourceId, event);
+        state.pending = undefined;
+        publishCommandState(path, state);
+        maybeWriteCommandLiveDisplay(input.coordRoot, event, input.observation);
+        return { state: "recorded", event, durability, recovered };
+    }
+    finally {
+        lease.release();
+    }
+}
+/**
+ * Session-end command closer (ADR 0078): every non-terminal command span of
+ * the ending generation gets a derived `command.completed` with an unknown
+ * outcome, so a `process.exit` or SIGKILL that outran the CLI's finalize can
+ * no longer leave the generation with an unpaired command forever. Command
+ * spans never block turns; this exists for corpus honesty and invariant 11.
+ */
+export function closeAbandonedCommandSpansV3(input) {
+    const result = { closed: 0, skipped: 0 };
+    const control = readEventV3ControlState(input.coordRoot);
+    if (control.state !== input.mode)
+        return result;
+    const rootId = control.genesis.event.scope.root_id;
+    const directory = join(resolve(input.coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "private-producers/session-tee");
+    if (!existsSync(directory))
+        return result;
+    for (const name of readdirSync(directory).filter((entry) => /^hid_[a-f0-9]{64}\.json$/.test(entry))) {
+        const path = join(directory, name);
+        let preview;
+        try {
+            preview = readCommandState(path);
+        }
+        catch {
+            result.skipped += 1;
+            continue;
+        }
+        if (preview.generation_id !== input.generation_id || preview.terminal)
+            continue;
+        let lease;
+        try {
+            lease = acquireCommandLease(input.coordRoot, path);
+        }
+        catch {
+            result.skipped += 1;
+            continue;
+        }
+        try {
+            const state = readCommandState(path);
+            if (state.generation_id !== input.generation_id)
+                continue;
+            if (state.pending) {
+                const pending = state.pending;
+                writeEventV3(input.coordRoot, pending.event, input.writerOptions);
+                applyCommandEvent(state, pending.source_id, pending.event);
+                state.pending = undefined;
+                publishCommandState(path, state);
+            }
+            if (state.terminal)
+                continue;
+            const context = fingerprintContextV3(input.coordRoot, rootId, state.generation_id, state.privacy_epoch_id);
+            const sourceId = normalizeNativeIdV3(context, "session-tee.observation", `recovery:${state.span_id}`);
+            const event = buildEventV3("command.completed", {
+                producer: {
+                    producer_id: "prd_agent-finalizer",
+                    boot_id: `boot_${randomUUID()}`,
+                    sequence: 1,
+                    component: "session-tee",
+                    build_id: input.build_id,
+                    platform: input.platform,
+                },
+                scope: {
+                    root_id: rootId,
+                    instance_id: state.instance_id,
+                    session_id: state.session_id,
+                    generation_id: state.generation_id,
+                    turn_id: state.turn_id,
+                },
+                attestation_id: state.attestation_id,
+                links: {
+                    caused_by: [
+                        state.last_event_id,
+                        ...(state.open_event_id ? [state.open_event_id] : []),
+                    ].filter((value, index, values) => values.indexOf(value) === index),
+                    span_id: state.span_id,
+                    ...(state.parent_span_id ? { parent_span_id: state.parent_span_id } : {}),
+                },
+                provenance: {
+                    source_event: "session-tee.recovery",
+                    attestation: "derived",
+                    confidence: "medium",
+                    attribution: {
+                        method: "session_env",
+                        state: "verified",
+                        subject_instance_id: state.instance_id,
+                    },
+                },
+                observed_at: input.observed_at,
+                clock_id: state.clock_id,
+                payload: {
+                    outcome: "unknown",
+                    duration_ms: { state: "unknown", reason: "command_completion_not_observed" },
+                    span: closeSpanStateV3({
+                        span_id: state.span_id,
+                        ...(state.parent_span_id ? { parent_span_id: state.parent_span_id } : {}),
+                        opened_at: state.opened_at,
+                        boot_id: state.boot_id,
+                        ...(state.opened_monotonic_ns
+                            ? { opened_monotonic_ns: state.opened_monotonic_ns }
+                            : {}),
+                        ...(state.open_event_id ? { open_event_id: state.open_event_id } : {}),
+                    }, {
+                        boot_id: state.boot_id,
+                        clock: { observed_at: input.observed_at },
+                        recovery_reason: "command_completion_not_observed",
+                    }),
+                    recovery: { reason: "command_completion_not_observed" },
+                },
+            });
+            markObservedClockRegressionV3(event, state.last_observed_at);
+            assertEventV3(event);
+            state.pending = { source_id: sourceId, event };
+            publishCommandState(path, state);
+            writeEventV3(input.coordRoot, event, input.writerOptions);
+            applyCommandEvent(state, sourceId, event);
+            state.pending = undefined;
+            publishCommandState(path, state);
+            result.closed += 1;
+        }
+        finally {
+            lease.release();
+        }
+    }
+    return result;
+}
+function newCommandState(input, hook, epochId) {
+    const parentSpanId = selectCommandParentSpan(hook.spans, hook.current_turn_id);
+    const bootId = `boot_${randomUUID()}`;
+    const opened = openSpanStateV3({
+        span_id: spanIdV3(),
+        ...(parentSpanId ? { parent_span_id: parentSpanId } : {}),
+        boot_id: bootId,
+        clock: {
+            observed_at: input.observed_at ?? new Date().toISOString(),
+            ...(input.monotonic_ns ? { monotonic_ns: input.monotonic_ns } : {}),
+        },
+    });
+    return {
+        format: COMMAND_STATE_FORMAT,
+        format_version: COMMAND_STATE_VERSION,
+        adapter: input.adapter,
+        instance_id: input.instance_id,
+        session_id: hook.session_id,
+        generation_id: hook.generation_id,
+        turn_id: hook.current_turn_id,
+        attestation_id: hook.attestation_id,
+        privacy_epoch_id: epochId,
+        boot_id: bootId,
+        clock_id: clockIdV3(),
+        span_id: opened.span_id,
+        ...(parentSpanId ? { parent_span_id: parentSpanId } : {}),
+        opened_at: opened.opened_at,
+        ...(opened.opened_monotonic_ns ? { opened_monotonic_ns: opened.opened_monotonic_ns } : {}),
+        next_sequence: 1,
+        last_event_id: hook.last_event_id,
+        terminal: false,
+        observations: [],
+    };
+}
+function matchesHookState(state, hook, input, epochId) {
+    return (state.adapter === input.adapter &&
+        state.instance_id === input.instance_id &&
+        state.session_id === hook.session_id &&
+        state.generation_id === hook.generation_id &&
+        state.turn_id === hook.current_turn_id &&
+        state.attestation_id === hook.attestation_id &&
+        state.privacy_epoch_id === epochId);
+}
+function observationSourceId(input, context) {
+    const nativeObservation = input.signal === "command.output_observed"
+        ? input.observation.native_observation_id
+        : `${input.signal}:${input.observation.native_command_id}`;
+    return nativeObservation
+        ? normalizeNativeIdV3(context, "session-tee.observation", nativeObservation)
+        : undefined;
+}
+function applyCommandEvent(state, sourceId, event) {
+    // Only events on the state's own producer chain advance its sequence; the
+    // finalizer's derived closer uses a fresh boot at sequence 1.
+    if (event.producer.boot_id === state.boot_id)
+        state.next_sequence += 1;
+    state.last_event_id = event.event_id;
+    state.last_observed_at = event.time.observed_at;
+    state.observations.push({ source_id: sourceId, event_id: event.event_id });
+    if (state.observations.length > MAX_OBSERVATIONS)
+        state.observations.shift();
+    if (event.event_type === "command.started") {
+        state.open_event_id = event.event_id;
+    }
+    if (event.event_type === "command.completed")
+        state.terminal = true;
+}
+function commandStatePath(coordRoot, commandSource) {
+    return join(resolve(coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "private-producers/session-tee", `${commandSource}.json`);
+}
+function acquireCommandLease(coordRoot, statePath) {
+    const directory = join(statePath, "..");
+    const producerRoot = join(resolve(coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "private-producers");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(producerRoot, 0o700);
+    chmodSync(directory, 0o700);
+    return acquireNoClobberLease({
+        path: `${statePath}.lease`,
+        scope: "event-v3-command-producer",
+        authoritySha256: createHash("sha256")
+            .update(resolve(coordRoot))
+            .update("\0")
+            .update(statePath)
+            .digest("hex"),
+        staleAfterMs: 5_000,
+        validateStaleOwner: (owner) => owner.host === hostname() && !pidIsAlive(owner.pid),
+    });
+}
+function publishCommandState(path, state) {
+    const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+    let fd;
+    try {
+        fd = openSync(temporary, "wx", 0o600);
+        writeFileSync(fd, `${JSON.stringify(state)}\n`, "utf8");
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(temporary, path);
+        chmodSync(path, 0o600);
+        fsyncParentDirectory(path);
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+}
+function readCommandState(path) {
+    if ((statSync(path).mode & 0o077) !== 0)
+        throw new Error("V3 command state is not owner-only");
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error("V3 command state is unreadable");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("V3 command state is invalid");
+    }
+    const state = parsed;
+    const allowed = new Set([
+        "adapter",
+        "attestation_id",
+        "boot_id",
+        "clock_id",
+        "format",
+        "format_version",
+        "generation_id",
+        "instance_id",
+        "last_event_id",
+        "last_observed_at",
+        "next_sequence",
+        "observations",
+        "opened_at",
+        "opened_monotonic_ns",
+        "open_event_id",
+        "parent_span_id",
+        "pending",
+        "privacy_epoch_id",
+        "session_id",
+        "span_id",
+        "terminal",
+        "turn_id",
+    ]);
+    if (Object.keys(state).some((key) => !allowed.has(key)) ||
+        state.format !== COMMAND_STATE_FORMAT ||
+        state.format_version !== COMMAND_STATE_VERSION ||
+        !["claude-code", "codex", "cursor"].includes(state.adapter) ||
+        !/^inst_[a-zA-Z0-9._-]{1,128}$/.test(state.instance_id) ||
+        !/^sid_[a-f0-9]{64}$/.test(state.session_id) ||
+        !/^gen_[0-9a-f-]{36}$/.test(state.generation_id) ||
+        !/^tid_[a-f0-9]{64}$/.test(state.turn_id) ||
+        !/^att_[0-9a-f-]{36}$/.test(state.attestation_id) ||
+        !/^pep_[a-zA-Z0-9._-]+$/.test(state.privacy_epoch_id) ||
+        !/^boot_[a-zA-Z0-9._-]+$/.test(state.boot_id) ||
+        !/^clk_[0-9a-f-]{36}$/.test(state.clock_id) ||
+        !/^span_[0-9a-f-]{36}$/.test(state.span_id) ||
+        !Number.isFinite(Date.parse(state.opened_at)) ||
+        (state.opened_monotonic_ns !== undefined && !/^\d+$/.test(state.opened_monotonic_ns)) ||
+        (state.open_event_id !== undefined && !/^evt_[0-9a-f-]{36}$/.test(state.open_event_id)) ||
+        (state.parent_span_id !== undefined && !/^span_[0-9a-f-]{36}$/.test(state.parent_span_id)) ||
+        !/^evt_[0-9a-f-]{36}$/.test(state.last_event_id) ||
+        (state.last_observed_at !== undefined &&
+            !Number.isFinite(Date.parse(state.last_observed_at))) ||
+        !Number.isSafeInteger(state.next_sequence) ||
+        state.next_sequence < 1 ||
+        typeof state.terminal !== "boolean" ||
+        !Array.isArray(state.observations) ||
+        state.observations.length > MAX_OBSERVATIONS ||
+        state.observations.some((observation) => !/^hid_[a-f0-9]{64}$/.test(observation.source_id) ||
+            !/^evt_[0-9a-f-]{36}$/.test(observation.event_id)) ||
+        (state.pending !== undefined &&
+            (!/^hid_[a-f0-9]{64}$/.test(state.pending.source_id) ||
+                !validateEventV3(state.pending.event).ok))) {
+        throw new Error("V3 command state is invalid");
+    }
+    return state;
+}
+function pidIsAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid < 1)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+function maybeWriteCommandLiveDisplay(coordRoot, event, observation) {
+    if (event.event_type !== "command.started")
+        return;
+    if (!("generation_id" in event.scope))
+        return;
+    const intent = observation.intent;
+    if (typeof intent !== "string" || intent.length === 0)
+        return;
+    tryWriteLiveDisplayV3(coordRoot, {
+        generation_id: event.scope.generation_id,
+        event_id: event.event_id,
+        executable: event.payload.executable,
+        intent_display: intent,
+    });
+}

package/dist/core/events/v3/producers/command.d.ts

@@ -0,0 +1,50 @@
+import { type FingerprintContextV3 } from "../canonical.js";
+import type { EventV3, SpanSummaryV3 } from "../contract.js";
+export type CommandSignalV3 = "command.started" | "command.output_observed" | "command.completed";
+export interface CommandProducerContextV3 {
+    root_id: `root_${string}`;
+    instance_id: `inst_${string}`;
+    session_id: `sid_${string}`;
+    generation_id: `gen_${string}`;
+    turn_id: `tid_${string}`;
+    attestation_id: `att_${string}`;
+    producer_id: `prd_${string}`;
+    boot_id: `boot_${string}`;
+    sequence: number;
+    build_id: `build_${string}`;
+    platform: "linux" | "windows" | "macos" | "unknown";
+    bridge?: "codex-wsl";
+    span_id: `span_${string}`;
+    parent_span_id?: `span_${string}`;
+    caused_by?: `evt_${string}`[];
+    event_id?: `evt_${string}`;
+    observed_at?: string;
+    recorded_at?: string;
+    monotonic_ns?: string;
+    clock_id?: `clk_${string}`;
+    fingerprintContext: FingerprintContextV3;
+    attribution_method: "session_env" | "heartbeat_match" | "explicit_argument";
+    terminal_span?: SpanSummaryV3;
+}
+export interface CommandObservationV3 {
+    native_command_id: string;
+    native_observation_id?: string;
+    executable?: string;
+    executable_class?: string;
+    argv?: readonly string[];
+    intent?: string;
+    intent_kind?: string;
+    sensitive_argument_count?: number;
+    stream?: "stdout" | "stderr" | "combined";
+    output?: unknown;
+    output_bytes?: number;
+    output_lines?: number;
+    outcome?: "succeeded" | "failed" | "cancelled" | "timed_out" | "interrupted" | "unknown";
+    exit_code?: number;
+    signal?: string;
+    duration_ms?: number;
+    error_class?: string;
+}
+/** Translate one session-tee observation without retaining command, intent, or output literals. */
+export declare function normalizeCommandEventV3(signal: CommandSignalV3, observation: CommandObservationV3, context: CommandProducerContextV3): EventV3 | null;
+//# sourceMappingURL=command.d.ts.map

package/dist/core/events/v3/producers/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/v3/producers/command.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAsC,MAAM,iBAAiB,CAAC;AAChG,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG7D,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG,yBAAyB,GAAG,mBAAmB,CAAC;AAElG,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC1B,WAAW,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC9B,UAAU,EAAE,OAAO,MAAM,EAAE,CAAC;IAC5B,aAAa,EAAE,OAAO,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,OAAO,MAAM,EAAE,CAAC;IACzB,cAAc,EAAE,OAAO,MAAM,EAAE,CAAC;IAChC,WAAW,EAAE,OAAO,MAAM,EAAE,CAAC;IAC7B,OAAO,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IACpD,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,QAAQ,MAAM,EAAE,CAAC;IAClC,SAAS,CAAC,EAAE,OAAO,MAAM,EAAE,EAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,OAAO,MAAM,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,MAAM,EAAE,CAAC;IAC3B,kBAAkB,EAAE,oBAAoB,CAAC;IACzC,kBAAkB,EAAE,aAAa,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;IAC5E,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;IACzF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,mGAAmG;AACnG,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,EACvB,WAAW,EAAE,oBAAoB,EACjC,OAAO,EAAE,wBAAwB,GAChC,OAAO,GAAG,IAAI,CAkHhB"}

package/dist/core/events/v3/producers/command.js

@@ -0,0 +1,135 @@
+import { buildEventV3 } from "../builder.js";
+import { fingerprintV3, normalizeNativeIdV3 } from "../canonical.js";
+import { eventIdV3 } from "../ids.js";
+/** Translate one session-tee observation without retaining command, intent, or output literals. */
+export function normalizeCommandEventV3(signal, observation, context) {
+    const eventId = context.event_id ?? eventIdV3();
+    const sourceRecordId = normalizeNativeIdV3(context.fingerprintContext, "session-tee.command-source", observation.native_command_id);
+    const producer = {
+        producer_id: context.producer_id,
+        boot_id: context.boot_id,
+        sequence: context.sequence,
+        component: "session-tee",
+        build_id: context.build_id,
+        platform: context.platform,
+        ...(context.bridge ? { bridge: context.bridge } : {}),
+    };
+    const scope = {
+        root_id: context.root_id,
+        instance_id: context.instance_id,
+        session_id: context.session_id,
+        generation_id: context.generation_id,
+        turn_id: context.turn_id,
+    };
+    const provenance = {
+        source_event: `session-tee.${signal}`,
+        attestation: "derived",
+        confidence: "exact",
+        source_record_id: sourceRecordId,
+        attribution: {
+            method: context.attribution_method,
+            state: "verified",
+            subject_instance_id: context.instance_id,
+        },
+    };
+    const common = {
+        event_id: eventId,
+        producer,
+        scope,
+        attestation_id: context.attestation_id,
+        provenance,
+        observed_at: context.observed_at,
+        recorded_at: context.recorded_at,
+        monotonic_ns: context.monotonic_ns,
+        clock_id: context.clock_id,
+        links: {
+            caused_by: context.caused_by ?? [],
+            span_id: context.span_id,
+            ...(context.parent_span_id ? { parent_span_id: context.parent_span_id } : {}),
+        },
+    };
+    switch (signal) {
+        case "command.started": {
+            const argv = [...(observation.argv ?? [])];
+            const intent = observation.intent?.normalize("NFC") ?? "";
+            return buildEventV3("command.started", {
+                ...common,
+                payload: {
+                    executable: safeToken(observation.executable ?? argv[0] ?? "unknown", "unknown"),
+                    executable_class: safeToken(observation.executable_class ?? "cli", "cli"),
+                    exact_command: fingerprintV3(context.fingerprintContext, "exact-command", argv),
+                    intent_kind: safeToken(observation.intent_kind ?? "unknown", "unknown"),
+                    intent_length: Buffer.byteLength(intent, "utf8"),
+                    ...(intent
+                        ? { intent_fingerprint: fingerprintV3(context.fingerprintContext, "intent", intent) }
+                        : {}),
+                    sensitive_argument_count: safeCount(observation.sensitive_argument_count),
+                },
+            });
+        }
+        case "command.output_observed": {
+            const bytes = observation.output_bytes ??
+                (observation.output === undefined ? 0 : byteLengthOfUnknown(observation.output));
+            return buildEventV3("command.output_observed", {
+                ...common,
+                payload: {
+                    stream: observation.stream ?? "combined",
+                    bytes: safeCount(bytes),
+                    ...(observation.output_lines === undefined
+                        ? {}
+                        : { lines: safeCount(observation.output_lines) }),
+                    ...(observation.output === undefined
+                        ? {}
+                        : {
+                            content_fingerprint: fingerprintV3(context.fingerprintContext, "command.output_observed", observation.output),
+                        }),
+                },
+            });
+        }
+        case "command.completed": {
+            if (!context.terminal_span)
+                return null;
+            const outcome = observation.outcome ?? outcomeFromExit(observation.exit_code);
+            return buildEventV3("command.completed", {
+                ...common,
+                payload: {
+                    outcome,
+                    ...(observation.exit_code === undefined ? {} : { exit_code: observation.exit_code }),
+                    ...(observation.signal
+                        ? { signal: safeToken(observation.signal, "unknown_signal") }
+                        : {}),
+                    duration_ms: context.terminal_span.duration_ms,
+                    span: context.terminal_span,
+                    ...(observation.error_class
+                        ? { error_class: safeToken(observation.error_class, "command_error") }
+                        : {}),
+                },
+            });
+        }
+    }
+}
+function outcomeFromExit(exitCode) {
+    if (exitCode === undefined)
+        return "unknown";
+    return exitCode === 0 ? "succeeded" : "failed";
+}
+function safeToken(value, fallback) {
+    const normalized = value
+        .normalize("NFC")
+        .replace(/[^a-zA-Z0-9._:/+-]/g, "_")
+        .slice(0, 128);
+    return /^[a-zA-Z0-9]/.test(normalized) ? normalized : fallback;
+}
+function safeCount(value) {
+    return Number.isSafeInteger(value) && (value ?? -1) >= 0 ? value : 0;
+}
+function byteLengthOfUnknown(value) {
+    if (typeof value === "string")
+        return Buffer.byteLength(value, "utf8");
+    try {
+        return Buffer.byteLength(JSON.stringify(value) ?? "null", "utf8");
+    }
+    catch {
+        return 0;
+    }
+}