opensquid 0.5.395

package/dist/runtime/agent_bridge/types.d.ts

@@ -0,0 +1,320 @@
+/**
+ * agent_bridge — shared types (WAB.2, 0.5.94).
+ *
+ * Authoritative source: `docs/tasks/WAB.1-architecture.md` decisions (b) +
+ * (c), and `docs/tasks/T-warm-agent-chat-bridge.md` WAB.2 spec.
+ *
+ * Why one types module: all six WAB sub-modules (event_bus, transport_bridge,
+ * session_manager, agent_loop, batch, dispatcher) share the SessionKey +
+ * InboundChatEvent + OutboundChatReply contracts. Inlining them per-module
+ * would either duplicate the zod schemas (drift risk) or chain imports
+ * deeply (re-export thrash). One types module + barrel re-export keeps
+ * the public surface flat for consumers.
+ *
+ * Schema validation discipline: every type that crosses an external
+ * boundary (chokidar-watched JSONL file, MCP tool args, future RPC) has a
+ * zod schema declared next to its TS interface; the schema is the runtime
+ * gate and the TS type is `z.infer<typeof schema>`. This matches the
+ * pattern in `src/runtime/types.ts`.
+ *
+ * Imports from: zod.
+ * Imported by: event_bus.ts, transport_bridge.ts, (future) session_manager,
+ *   agent_loop, batch, dispatcher.
+ */
+import { z } from 'zod';
+export declare const SessionPlatform: z.ZodEnum<["telegram", "discord", "slack"]>;
+export type SessionPlatform = z.infer<typeof SessionPlatform>;
+export declare const sessionKeySchema: z.ZodObject<{
+    platform: z.ZodEnum<["telegram", "discord", "slack"]>;
+    chatId: z.ZodString;
+    threadId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    chatId: string;
+    platform: "telegram" | "discord" | "slack";
+    threadId?: string | undefined;
+}, {
+    chatId: string;
+    platform: "telegram" | "discord" | "slack";
+    threadId?: string | undefined;
+}>;
+export type SessionKey = z.infer<typeof sessionKeySchema>;
+/**
+ * Canonical slug form. `<platform>:<chatId>[:<threadId>]`.
+ *
+ * Used as the LRU cache key (WAB.3) and as the on-disk filename base for
+ * persisted session history. Hex-encoded by the persistence layer before
+ * touching the filesystem; this function is the pre-encoding form.
+ */
+export declare function sessionKeyString(k: SessionKey): string;
+export declare const inboundChatEventSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"inbound_message">;
+    sessionKey: z.ZodObject<{
+        platform: z.ZodEnum<["telegram", "discord", "slack"]>;
+        chatId: z.ZodString;
+        threadId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    }, {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    }>;
+    messageId: z.ZodString;
+    sender: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+    }, {
+        id: string;
+        name?: string | undefined;
+    }>;
+    text: z.ZodString;
+    receivedAt: z.ZodString;
+    enqueuedAt: z.ZodString;
+    projectUuid: z.ZodString;
+    /**
+     * Owning umbrella id (T-CHAT-AS-TERMINAL CAT.5). Stamped by a
+     * umbrella-keyed transport bridge (one umbrella ↔ one chat session,
+     * invariants #2/#4). The dispatcher's T-DEL arbitration reads
+     * `umbrellaLiveSessionLease(umbrellaId)` to decide whether to answer. A
+     * project-keyed transport (legacy / general session) omits it, in which case
+     * the dispatcher falls back to the project lease (`liveSessionLease`).
+     */
+    umbrellaId: z.ZodOptional<z.ZodString>;
+    raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    kind: "inbound_message";
+    receivedAt: string;
+    sender: {
+        id: string;
+        name?: string | undefined;
+    };
+    text: string;
+    messageId: string;
+    sessionKey: {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    };
+    enqueuedAt: string;
+    projectUuid: string;
+    umbrellaId?: string | undefined;
+    raw?: Record<string, unknown> | undefined;
+}, {
+    kind: "inbound_message";
+    receivedAt: string;
+    sender: {
+        id: string;
+        name?: string | undefined;
+    };
+    text: string;
+    messageId: string;
+    sessionKey: {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    };
+    enqueuedAt: string;
+    projectUuid: string;
+    umbrellaId?: string | undefined;
+    raw?: Record<string, unknown> | undefined;
+}>;
+export type InboundChatEvent = z.infer<typeof inboundChatEventSchema>;
+export declare const outboundChatReplySchema: z.ZodObject<{
+    sessionKey: z.ZodObject<{
+        platform: z.ZodEnum<["telegram", "discord", "slack"]>;
+        chatId: z.ZodString;
+        threadId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    }, {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    }>;
+    text: z.ZodString;
+    /** Optional source message id to thread under (Telegram reply_to_message_id). */
+    replyTo: z.ZodOptional<z.ZodString>;
+    projectUuid: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    sessionKey: {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    };
+    projectUuid: string;
+    replyTo?: string | undefined;
+}, {
+    text: string;
+    sessionKey: {
+        chatId: string;
+        platform: "telegram" | "discord" | "slack";
+        threadId?: string | undefined;
+    };
+    projectUuid: string;
+    replyTo?: string | undefined;
+}>;
+export type OutboundChatReply = z.infer<typeof outboundChatReplySchema>;
+export declare const chatHistoryContentBlockSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "text";
+    text: string;
+}, {
+    type: "text";
+    text: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input?: unknown;
+}, {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input?: unknown;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_use_id: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "tool_result";
+    content: string;
+    tool_use_id: string;
+}, {
+    type: "tool_result";
+    content: string;
+    tool_use_id: string;
+}>]>;
+export type ChatHistoryContentBlock = z.infer<typeof chatHistoryContentBlockSchema>;
+export declare const chatHistoryEntrySchema: z.ZodObject<{
+    role: z.ZodEnum<["user", "assistant"]>;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input?: unknown;
+    }, {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input?: unknown;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool_use_id: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "tool_result";
+        content: string;
+        tool_use_id: string;
+    }, {
+        type: "tool_result";
+        content: string;
+        tool_use_id: string;
+    }>]>, "many">;
+    timestamp: z.ZodString;
+    cacheMark: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    content: ({
+        type: "text";
+        text: string;
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input?: unknown;
+    } | {
+        type: "tool_result";
+        content: string;
+        tool_use_id: string;
+    })[];
+    role: "user" | "assistant";
+    timestamp: string;
+    cacheMark?: boolean | undefined;
+}, {
+    content: ({
+        type: "text";
+        text: string;
+    } | {
+        type: "tool_use";
+        id: string;
+        name: string;
+        input?: unknown;
+    } | {
+        type: "tool_result";
+        content: string;
+        tool_use_id: string;
+    })[];
+    role: "user" | "assistant";
+    timestamp: string;
+    cacheMark?: boolean | undefined;
+}>;
+export type ChatHistoryEntry = z.infer<typeof chatHistoryEntrySchema>;
+export interface SessionState {
+    key: SessionKey;
+    history: ChatHistoryEntry[];
+    lastActivityMs: number;
+    projectUuid: string;
+    packId: string;
+    modelAlias: string;
+    /** Set true while an agent turn is mid-flight; batches buffer until cleared. */
+    turnInFlight: boolean;
+}
+export interface ToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema for tool input. Serialized to Anthropic as-is. */
+    input_schema: Record<string, unknown>;
+    /**
+     * Optional runtime input guard. Called by the dispatcher BEFORE the
+     * handler. Implementations: `(input) => schema.parse(input)` for zod,
+     * or any function that throws on invalid input. Return value is
+     * forwarded to the handler (so tools can both validate AND narrow types
+     * in one step).
+     */
+    validate?: (input: unknown) => unknown;
+}
+export interface ToolContext {
+    sessionKey: SessionKey;
+    projectUuid: string;
+}
+export type ToolHandler = (input: unknown, ctx: ToolContext) => Promise<string>;
+export interface ToolDispatcher {
+    /** Snapshot of registered tool specs — passed to Anthropic.messages.create. */
+    list(): ToolSpec[];
+    /**
+     * Dispatch a single tool_use block from the model. Throws on unknown
+     * name (caller should treat as a hard error — the model invoked
+     * something not in `list()`) or on validation failure. The returned
+     * string is fed back to the model as `tool_result.content`.
+     */
+    call(name: string, input: unknown, ctx: ToolContext): Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/runtime/agent_bridge/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/runtime/agent_bridge/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,eAAe,6CAA2C,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAItD;AAqBD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYjC;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGH,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAUtE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;IAGlC,iFAAiF;;;;;;;;;;;;;;;;;;;;;EAGjF,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AA8CxE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAoBtE,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,UAAU,CAAC;IAChB,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,YAAY,EAAE,OAAO,CAAC;CACvB;AAyBD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACxC;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEhF,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,IAAI,IAAI,QAAQ,EAAE,CAAC;IACnB;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACvE"}

package/dist/runtime/agent_bridge/types.js

@@ -0,0 +1,157 @@
+/**
+ * agent_bridge — shared types (WAB.2, 0.5.94).
+ *
+ * Authoritative source: `docs/tasks/WAB.1-architecture.md` decisions (b) +
+ * (c), and `docs/tasks/T-warm-agent-chat-bridge.md` WAB.2 spec.
+ *
+ * Why one types module: all six WAB sub-modules (event_bus, transport_bridge,
+ * session_manager, agent_loop, batch, dispatcher) share the SessionKey +
+ * InboundChatEvent + OutboundChatReply contracts. Inlining them per-module
+ * would either duplicate the zod schemas (drift risk) or chain imports
+ * deeply (re-export thrash). One types module + barrel re-export keeps
+ * the public surface flat for consumers.
+ *
+ * Schema validation discipline: every type that crosses an external
+ * boundary (chokidar-watched JSONL file, MCP tool args, future RPC) has a
+ * zod schema declared next to its TS interface; the schema is the runtime
+ * gate and the TS type is `z.infer<typeof schema>`. This matches the
+ * pattern in `src/runtime/types.ts`.
+ *
+ * Imports from: zod.
+ * Imported by: event_bus.ts, transport_bridge.ts, (future) session_manager,
+ *   agent_loop, batch, dispatcher.
+ */
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// SessionKey — `(platform, chatId, threadId?)` triple.
+//
+// Mirrors Hermes `build_session_key` (`gateway/platforms/base.py:2762`) and
+// the inbox row's `thread_id` field (written by the chat daemon).
+// Telegram supergroup ids are negative integers; DM user ids are positive;
+// both stringify safely. Discord + Slack reserved for future adapters.
+// ---------------------------------------------------------------------------
+export const SessionPlatform = z.enum(['telegram', 'discord', 'slack']);
+export const sessionKeySchema = z.object({
+    platform: SessionPlatform,
+    chatId: z.string().min(1),
+    threadId: z.string().optional(),
+});
+/**
+ * Canonical slug form. `<platform>:<chatId>[:<threadId>]`.
+ *
+ * Used as the LRU cache key (WAB.3) and as the on-disk filename base for
+ * persisted session history. Hex-encoded by the persistence layer before
+ * touching the filesystem; this function is the pre-encoding form.
+ */
+export function sessionKeyString(k) {
+    return k.threadId !== undefined
+        ? `${k.platform}:${k.chatId}:${k.threadId}`
+        : `${k.platform}:${k.chatId}`;
+}
+// ---------------------------------------------------------------------------
+// InboundChatEvent — emitted by transport_bridge when a JSONL row lands.
+//
+// Field mapping from the inbox row (snake_case, written by the chat
+// daemon's inbox append) → modern camelCase. The mapping happens at the
+// bridge boundary so the rest
+// of the warm-agent code sees a clean Phase-1 shape.
+//
+// `projectUuid` is carried explicitly because the transport_bridge is
+// per-project (one instance per `~/.opensquid/projects/<uuid>/inbox/`),
+// and the downstream session manager + agent loop need it for tool calls
+// that resolve back to project-scoped resources (RAG scope, channel
+// routing, etc.).
+//
+// `raw` preserves the original JSONL payload for callers that want
+// platform-specific fields (mentions_bot, etc.) without expanding the
+// typed surface.
+// ---------------------------------------------------------------------------
+export const inboundChatEventSchema = z.object({
+    kind: z.literal('inbound_message'),
+    sessionKey: sessionKeySchema,
+    messageId: z.string().min(1),
+    sender: z.object({
+        id: z.string().min(1),
+        name: z.string().optional(),
+    }),
+    text: z.string(),
+    receivedAt: z.string().datetime({ offset: true }),
+    enqueuedAt: z.string().datetime({ offset: true }),
+    projectUuid: z.string().uuid(),
+    /**
+     * Owning umbrella id (T-CHAT-AS-TERMINAL CAT.5). Stamped by a
+     * umbrella-keyed transport bridge (one umbrella ↔ one chat session,
+     * invariants #2/#4). The dispatcher's T-DEL arbitration reads
+     * `umbrellaLiveSessionLease(umbrellaId)` to decide whether to answer. A
+     * project-keyed transport (legacy / general session) omits it, in which case
+     * the dispatcher falls back to the project lease (`liveSessionLease`).
+     */
+    umbrellaId: z.string().min(1).optional(),
+    raw: z.record(z.unknown()).optional(),
+});
+// ---------------------------------------------------------------------------
+// OutboundChatReply — agent's reply payload before it hits the legacy RPC.
+//
+// Used by future WAB.6 chat_send tool wrapper. Declared here to keep the
+// agent_bridge public surface in one place; transport_bridge does not emit
+// these (outbound goes via RPC, not file-watcher).
+// ---------------------------------------------------------------------------
+export const outboundChatReplySchema = z.object({
+    sessionKey: sessionKeySchema,
+    text: z.string().min(1),
+    /** Optional source message id to thread under (Telegram reply_to_message_id). */
+    replyTo: z.string().optional(),
+    projectUuid: z.string().uuid(),
+});
+// ---------------------------------------------------------------------------
+// ChatHistoryEntry — Anthropic-message-compatible turn fragment.
+//
+// Added WAB.3, 0.5.95. The agent loop (WAB.4) maps these directly into the
+// `messages` array of `Anthropic.messages.create`; the persistence layer
+// (WAB.3) round-trips them via JSONL. Keeping the shape Anthropic-native
+// avoids per-turn translation in the hot path.
+//
+// Content is an array of discriminated content blocks: text (plain prose),
+// tool_use (assistant invokes a tool — id + name + input), tool_result
+// (synthesized user message carrying tool output back to the model). This
+// mirrors Anthropic's documented message-content shape; see
+// https://docs.claude.com/en/api/messages content-block reference.
+//
+// `cacheMark` is an OPTIONAL transient hint set by the agent loop at
+// request-construction time; it is NOT persisted (cache breakpoints are
+// recomputed every turn from history positions per WAB.1 (c) — "marker
+// policy is system + last 2 user messages"). The field lives on the type
+// so the schema accepts persisted rows that might carry it from older
+// builds, but `appendEntries` strips it before writing.
+//
+// Validation: discriminated-union zod schema (`role` is the discriminator).
+// Strict on the content-block kinds so a typo in a producer surfaces at
+// the boundary, not deep inside `messages.create`.
+// ---------------------------------------------------------------------------
+const textBlockSchema = z.object({
+    type: z.literal('text'),
+    text: z.string(),
+});
+const toolUseBlockSchema = z.object({
+    type: z.literal('tool_use'),
+    id: z.string().min(1),
+    name: z.string().min(1),
+    input: z.unknown(),
+});
+const toolResultBlockSchema = z.object({
+    type: z.literal('tool_result'),
+    tool_use_id: z.string().min(1),
+    content: z.string(),
+});
+export const chatHistoryContentBlockSchema = z.discriminatedUnion('type', [
+    textBlockSchema,
+    toolUseBlockSchema,
+    toolResultBlockSchema,
+]);
+export const chatHistoryEntrySchema = z.object({
+    role: z.enum(['user', 'assistant']),
+    content: z.array(chatHistoryContentBlockSchema),
+    timestamp: z.string().datetime({ offset: true }),
+    cacheMark: z.boolean().optional(),
+});
+//# sourceMappingURL=types.js.map

package/dist/runtime/agent_bridge/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/runtime/agent_bridge/types.ts"],"names":[],"mappings":"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"}

package/dist/runtime/atomic_write.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Atomic file publish (FC.1) — write a temp sibling, then `rename` it over the
+ * target. `rename` is atomic on POSIX, so a concurrent reader always sees either
+ * the old file or the fully-written new one, never a torn/partial write. Closes
+ * the ACTRACE race for every session-/chain-state writer.
+ *
+ * The temp name is unique PER CALL (pid + a process-local counter), not just per
+ * pid — two overlapping writes in the SAME process must not share a temp path
+ * (they would clobber each other's temp and one `rename` would ENOENT).
+ *
+ * Imports from: node:fs/promises, node:path.
+ */
+/** Write `data` to `path` atomically (tmp + rename), creating parent dirs. */
+export declare function atomicWriteFile(path: string, data: string): Promise<void>;
+//# sourceMappingURL=atomic_write.d.ts.map

package/dist/runtime/atomic_write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic_write.d.ts","sourceRoot":"","sources":["../../src/runtime/atomic_write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,8EAA8E;AAC9E,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAK/E"}

package/dist/runtime/atomic_write.js

@@ -0,0 +1,23 @@
+/**
+ * Atomic file publish (FC.1) — write a temp sibling, then `rename` it over the
+ * target. `rename` is atomic on POSIX, so a concurrent reader always sees either
+ * the old file or the fully-written new one, never a torn/partial write. Closes
+ * the ACTRACE race for every session-/chain-state writer.
+ *
+ * The temp name is unique PER CALL (pid + a process-local counter), not just per
+ * pid — two overlapping writes in the SAME process must not share a temp path
+ * (they would clobber each other's temp and one `rename` would ENOENT).
+ *
+ * Imports from: node:fs/promises, node:path.
+ */
+import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+let counter = 0;
+/** Write `data` to `path` atomically (tmp + rename), creating parent dirs. */
+export async function atomicWriteFile(path, data) {
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp.${String(process.pid)}.${String(++counter)}`;
+    await writeFile(tmp, data, 'utf8');
+    await rename(tmp, path);
+}
+//# sourceMappingURL=atomic_write.js.map

package/dist/runtime/atomic_write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic_write.js","sourceRoot":"","sources":["../../src/runtime/atomic_write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,IAAI,OAAO,GAAG,CAAC,CAAC;AAEhB,8EAA8E;AAC9E,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAY,EAAE,IAAY;IAC9D,MAAM,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAChD,MAAM,GAAG,GAAG,GAAG,IAAI,QAAQ,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC;IACtE,MAAM,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACnC,MAAM,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAC1B,CAAC"}

package/dist/runtime/audit_adapters.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Audit producer → unified `AuditLog` adapters (Patch B).
+ *
+ * Each producer (AUTO.3 capability gate, SCHED.1 webhook server, DURABLE.4
+ * resumer, AUTO.6 inbound router) ships its own audit-sink interface in a
+ * producer-specific shape. The CLI.5 `AuditLog` is the single libsql-backed
+ * landing table. These adapters are the glue: each `adaptXxx(auditLog)`
+ * returns a sink that satisfies the producer's interface and translates
+ * each event variant into a unified `AuditEntry` via `auditLog.append`.
+ *
+ * Single-direction dependency: producers DO NOT import `AuditLog`. Only
+ * this module touches both sides. Wiring lives at the daemon construction
+ * site (separate commit) — this patch ships the adapter functions + tests
+ * only.
+ *
+ * `void auditLog.append(...)` is intentional fire-and-forget — the
+ * `AuditLog` class handles its own write errors (see `audit_log.ts` init +
+ * insert flow) and constraint C10 forbids audit-sink errors from
+ * influencing producer verdicts. The producer's `try/catch` around the
+ * sink (CapabilityGate.audit) already swallows any thrown exceptions; the
+ * `Promise` returned by `append` resolves independently.
+ *
+ * PII discipline: no producer event variant carries raw secrets / bearer
+ * tokens / signing keys. WebhookServer audit explicitly carries only
+ * `subscriptionId` (never `signingSecret`); InboundRouter carries
+ * `sender` (an externally-visible principal, not a credential); Resumer
+ * carries error messages already stringified at the producer boundary.
+ * No additional `hashDetailValue` wrapping is required at the adapter
+ * boundary — producers pre-hash any sensitive value before it reaches
+ * the sink.
+ */
+import type { AuditLog as CapabilityGateAuditSink } from './capability_gate.js';
+import type { AuditLog } from './audit_log.js';
+import type { AuditSink as ResumerAuditSink } from './durable/resumer.js';
+import type { WebhookAuditSink } from './webhook_server.js';
+import type { InboundRouterAuditSink } from '../channels/inbound_router.js';
+/** Injected clock — defaults to `Date.now`. Tests pass a fixed-tick fn. */
+export type NowFn = () => number;
+/**
+ * AUTO.3 capability gate → unified audit.
+ *
+ * Mapping:
+ *   - category = `'capability_gate'`
+ *   - decision = `verdict.allowed ? 'allowed' : 'denied'`
+ *   - packId   = `req.pack`
+ *   - detail   = `{ event_subtype: verdict.source, capability, target,
+ *                   method?, source, message? }`
+ *
+ * `source` is duplicated as both `event_subtype` (queryable subtype across
+ * all categories) and `source` (verbatim from verdict) so downstream
+ * dashboards can pivot either way.
+ */
+export declare function adaptCapabilityGate(auditLog: AuditLog, now?: NowFn): CapabilityGateAuditSink;
+/**
+ * SCHED.1 webhook server → unified audit.
+ *
+ * Mapping per event variant:
+ *   - `received | dispatched | idempotent | deliver_only` → `success`
+ *   - `rejected_method | rejected_unknown | rejected_hmac | rejected_rate_limit` → `denied`
+ *   - `error` → `error`
+ *
+ * `packId` is undefined — webhook auth is daemon-level. The
+ * `subscriptionId` (when present) lives in `detail` so per-subscription
+ * queries route via detail-JSON filter, not the indexed column.
+ */
+export declare function adaptWebhookServer(auditLog: AuditLog, now?: NowFn): WebhookAuditSink;
+/**
+ * DURABLE.4 resumer → unified audit.
+ *
+ * Mapping (per Patch B spec lock):
+ *   - `resume_run | resume_skipped | resume_summary` → `success`
+ *     (no current variant maps to `denied`; skips are normal control
+ *     flow — pack uninstalled / version diverged — not a security
+ *     verdict. `evaluator_error` skips ride along inside `resume_skipped`
+ *     and stay `success` at the audit-decision level; the `reason` field
+ *     in detail carries the discriminator.)
+ *
+ * `packId` is set when the variant carries one (`resume_run` has it;
+ * `resume_summary` and `resume_skipped` don't).
+ */
+export declare function adaptResumer(auditLog: AuditLog, now?: NowFn): ResumerAuditSink;
+/**
+ * AUTO.6 inbound router → unified audit.
+ *
+ * Mapping per event variant:
+ *   - `inbound_dispatched | inbound_subscribed` → `success`
+ *   - `inbound_sender_denied` → `denied`
+ *   - `inbound_unmapped | inbound_no_adapter | inbound_adapter_not_inboundable
+ *      | inbound_dispatch_error` → `error`
+ *
+ * Uses the new `'channel_inbound'` category (Patch B extends
+ * `AuditCategory`); outbound channel sends remain on `'channel_send'`.
+ * `packId` pulls from `entry.pack` (every variant carries it via
+ * `AuditCommon`).
+ */
+export declare function adaptInboundRouter(auditLog: AuditLog, now?: NowFn): InboundRouterAuditSink;
+//# sourceMappingURL=audit_adapters.d.ts.map

package/dist/runtime/audit_adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit_adapters.d.ts","sourceRoot":"","sources":["../../src/runtime/audit_adapters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EACV,QAAQ,IAAI,uBAAuB,EAGpC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAA6B,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,KAAK,EAEV,SAAS,IAAI,gBAAgB,EAC9B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAqB,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,KAAK,EAEV,sBAAsB,EACvB,MAAM,+BAA+B,CAAC;AAEvC,2EAA2E;AAC3E,MAAM,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC;AAEjC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,GAAG,GAAE,KAAgB,GACpB,uBAAuB,CAkBzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,GAAE,KAAgB,GAAG,gBAAgB,CAW9F;AA2BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,GAAE,KAAgB,GAAG,gBAAgB,CAaxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,QAAQ,EAClB,GAAG,GAAE,KAAgB,GACpB,sBAAsB,CAYxB"}