appduct 0.11.0 → 0.12.0

package/dist/cli/routes/tools.js

@@ -12,7 +12,7 @@ import { join as join3 } from "node:path";
 import { RPC_METHODS } from "@appduct/shared";
 
 // src/daemon/log-rotation.ts
-import { chmod, rename, stat } from "node:fs/promises";
+import { chmod as chmod2, rename, stat } from "node:fs/promises";
 
 // src/daemon/config.ts
 import { readFile } from "node:fs/promises";
@@ -25,6 +25,7 @@ var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "eventBufferSize",
   "auditRetentionDays",
   "daemonLogMaxBytes",
+  "eventsLogMaxBytes",
   "policy",
   "advertisedIp",
   "scheme",
@@ -84,6 +85,7 @@ var defaultConfig = (paths) => {
     eventBufferSize: 256,
     auditRetentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
     daemonLogMaxBytes: DEFAULT_DAEMON_LOG_MAX_BYTES,
+    eventsLogMaxBytes: 10 * 1024 * 1024,
     restartDaemonOnVersionMismatch: false,
     policy: {
       default: "allow",
@@ -146,6 +148,9 @@ var loadConfig = async (paths, options = {}) => {
   if (parsed.daemonLogMaxBytes !== void 0) {
     config.daemonLogMaxBytes = requirePositiveInteger(parsed.daemonLogMaxBytes, "daemonLogMaxBytes");
   }
+  if (parsed.eventsLogMaxBytes !== void 0) {
+    config.eventsLogMaxBytes = requirePositiveInteger(parsed.eventsLogMaxBytes, "eventsLogMaxBytes");
+  }
   if (parsed.restartDaemonOnVersionMismatch !== void 0) {
     config.restartDaemonOnVersionMismatch = requireBoolean(
       parsed.restartDaemonOnVersionMismatch,
@@ -239,18 +244,27 @@ var isSocketConnectable = (socketPath) => {
 
 // src/daemon/state-dir.ts
 import { join } from "node:path";
+import { mkdir, chmod } from "node:fs/promises";
 var getStateDirPaths = (stateDir) => {
   return {
     root: stateDir,
     socketPath: join(stateDir, "daemon.sock"),
     pidFilePath: join(stateDir, "daemon.pid"),
     logFilePath: join(stateDir, "daemon.log"),
+    eventsLogPath: join(stateDir, "events.log"),
     keyPath: join(stateDir, "key.pem"),
     configPath: join(stateDir, "config.json"),
     auditDir: join(stateDir, "audit"),
     spawnLockPath: join(stateDir, "daemon.spawn.lock")
   };
 };
+var ensureStateDir = async (stateDir) => {
+  const paths = getStateDirPaths(stateDir);
+  await mkdir(paths.auditDir, { recursive: true });
+  await chmod(paths.root, 448);
+  await chmod(paths.auditDir, 448);
+  return paths;
+};
 
 // src/daemon/log-rotation.ts
 var STATE_FILE_MODE = 384;
@@ -283,7 +297,7 @@ var rotateDaemonLogIfNeeded = async (options) => {
     const backupPath = daemonLogBackupPath(options.logFilePath);
     await rename(options.logFilePath, backupPath);
     try {
-      await chmod(backupPath, STATE_FILE_MODE);
+      await chmod2(backupPath, STATE_FILE_MODE);
     } catch (error) {
       warn(`appduct: rotated "${options.logFilePath}" but could not set 0600 on "${backupPath}": ${error.message}`);
     }
@@ -299,7 +313,7 @@ var rotateDaemonLogIfNeeded = async (options) => {
 var ensureDaemonLogMode = async (logFilePath, warn = (message) => process.stderr.write(`${message}
 `)) => {
   try {
-    await chmod(logFilePath, STATE_FILE_MODE);
+    await chmod2(logFilePath, STATE_FILE_MODE);
     return true;
   } catch (error) {
     warn(`appduct: could not set 0600 on "${logFilePath}": ${error.message}`);
@@ -640,6 +654,7 @@ var acquireSpawnLock = async (lockPath) => {
   return false;
 };
 var spawnDaemonAndWait = async (paths, spawn, waitTimeoutMs, pollIntervalMs, options = {}) => {
+  await ensureStateDir(paths.root);
   const acquiredLock = await acquireSpawnLock(paths.spawnLockPath);
   let lockWaitTimedOut = false;
   if (acquiredLock) {

package/dist/client/app-client.d.ts

@@ -7,7 +7,7 @@
  * `appduct_wait_for_event` MCP tool (`mcp/events-tool.ts`) — see that module's doc comment for
  * why the notification listener has to be registered before the `events.since` drain call is sent.
  */
-import { type ToolDescriptor } from "@appduct/shared";
+import { type ListedToolDescriptor } from "@appduct/shared";
 import type { DaemonStream } from "../rpc/client.js";
 /** A project's own tool map — declared once, e.g. `type Tools = { sum: { args: { a: number; b:
  * number }; result: { total: number } } }` — to get typed {@link AppClient.call} throughout a test
@@ -80,8 +80,9 @@ export type AppEvent<TPayload = unknown> = {
 };
 export type AppClient<TTools = ToolMap> = {
     readonly sessionId: string;
-    /** `tools.list` for this session. */
-    tools(): Promise<ToolDescriptor[]>;
+    /** `tools.list` for this session. An entry spells an ungrouped tool's `group` as `null`,
+     * where a registration omits it. */
+    tools(): Promise<ListedToolDescriptor[]>;
     /** `tools.call`; rejects with a {@link AppductError} whose `type` preserves the wire error
      * type verbatim (e.g. `"tool_timeout"`, `"policy_denied"`, `"session_suspended"`). */
     call<K extends keyof TTools & string>(name: K, args: ToolArgs<TTools, K>, options?: CallOptions): Promise<ToolResult<TTools, K>>;

package/dist/client/index.d.ts

@@ -15,4 +15,4 @@ export { connect, type ConnectOptions } from "./connect.js";
 export { link, waitForSession, type LinkOptions, type LinkResult, type WaitForSessionOptions } from "./bootstrap.js";
 export { AppductError, type AppductErrorType } from "./errors.js";
 export type { AppClient, AppEvent, CallOptions, EventsOptions, EventsResult, ToolMap, WaitForEventOptions, } from "./app-client.js";
-export type { AgentEndpoint, ErrorType, ToolDescriptor } from "@appduct/shared";
+export type { AgentEndpoint, ErrorType, ListedToolDescriptor, ToolDescriptor } from "@appduct/shared";

package/dist/client/index.js

@@ -4,6 +4,7 @@ import { RPC_METHODS as RPC_METHODS3 } from "@appduct/shared";
 // src/daemon/state-dir.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { mkdir, chmod } from "node:fs/promises";
 var resolveStateDir = (override) => {
   return override ?? process.env.APPDUCT_STATE_DIR ?? join(homedir(), ".appduct");
 };
@@ -13,12 +14,20 @@ var getStateDirPaths = (stateDir) => {
     socketPath: join(stateDir, "daemon.sock"),
     pidFilePath: join(stateDir, "daemon.pid"),
     logFilePath: join(stateDir, "daemon.log"),
+    eventsLogPath: join(stateDir, "events.log"),
     keyPath: join(stateDir, "key.pem"),
     configPath: join(stateDir, "config.json"),
     auditDir: join(stateDir, "audit"),
     spawnLockPath: join(stateDir, "daemon.spawn.lock")
   };
 };
+var ensureStateDir = async (stateDir) => {
+  const paths = getStateDirPaths(stateDir);
+  await mkdir(paths.auditDir, { recursive: true });
+  await chmod(paths.root, 448);
+  await chmod(paths.auditDir, 448);
+  return paths;
+};
 
 // src/rpc/client.ts
 import { connect as connect2 } from "node:net";
@@ -28,7 +37,7 @@ import { join as join3 } from "node:path";
 import { RPC_METHODS } from "@appduct/shared";
 
 // src/daemon/log-rotation.ts
-import { chmod, rename, stat } from "node:fs/promises";
+import { chmod as chmod2, rename, stat } from "node:fs/promises";
 
 // src/daemon/config.ts
 import { readFile } from "node:fs/promises";
@@ -41,6 +50,7 @@ var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "eventBufferSize",
   "auditRetentionDays",
   "daemonLogMaxBytes",
+  "eventsLogMaxBytes",
   "policy",
   "advertisedIp",
   "scheme",
@@ -100,6 +110,7 @@ var defaultConfig = (paths) => {
     eventBufferSize: 256,
     auditRetentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
     daemonLogMaxBytes: DEFAULT_DAEMON_LOG_MAX_BYTES,
+    eventsLogMaxBytes: 10 * 1024 * 1024,
     restartDaemonOnVersionMismatch: false,
     policy: {
       default: "allow",
@@ -162,6 +173,9 @@ var loadConfig = async (paths, options = {}) => {
   if (parsed.daemonLogMaxBytes !== void 0) {
     config.daemonLogMaxBytes = requirePositiveInteger(parsed.daemonLogMaxBytes, "daemonLogMaxBytes");
   }
+  if (parsed.eventsLogMaxBytes !== void 0) {
+    config.eventsLogMaxBytes = requirePositiveInteger(parsed.eventsLogMaxBytes, "eventsLogMaxBytes");
+  }
   if (parsed.restartDaemonOnVersionMismatch !== void 0) {
     config.restartDaemonOnVersionMismatch = requireBoolean(
       parsed.restartDaemonOnVersionMismatch,
@@ -284,7 +298,7 @@ var rotateDaemonLogIfNeeded = async (options) => {
     const backupPath = daemonLogBackupPath(options.logFilePath);
     await rename(options.logFilePath, backupPath);
     try {
-      await chmod(backupPath, STATE_FILE_MODE);
+      await chmod2(backupPath, STATE_FILE_MODE);
     } catch (error) {
       warn(`appduct: rotated "${options.logFilePath}" but could not set 0600 on "${backupPath}": ${error.message}`);
     }
@@ -300,7 +314,7 @@ var rotateDaemonLogIfNeeded = async (options) => {
 var ensureDaemonLogMode = async (logFilePath, warn = (message) => process.stderr.write(`${message}
 `)) => {
   try {
-    await chmod(logFilePath, STATE_FILE_MODE);
+    await chmod2(logFilePath, STATE_FILE_MODE);
     return true;
   } catch (error) {
     warn(`appduct: could not set 0600 on "${logFilePath}": ${error.message}`);
@@ -641,6 +655,7 @@ var acquireSpawnLock = async (lockPath) => {
   return false;
 };
 var spawnDaemonAndWait = async (paths, spawn, waitTimeoutMs, pollIntervalMs, options = {}) => {
+  await ensureStateDir(paths.root);
   const acquiredLock = await acquireSpawnLock(paths.spawnLockPath);
   let lockWaitTimedOut = false;
   if (acquiredLock) {
@@ -1096,7 +1111,8 @@ var makeAppClient = (stream, sessionId) => {
         const result = await stream.call(RPC_METHODS2.toolsList, {
           selector: sessionId
         });
-        return Array.isArray(result) ? result : result.tools;
+        const entries = Array.isArray(result) ? result : result.tools;
+        return entries.map((entry) => ({ ...entry, group: entry.group ?? null }));
       } catch (error) {
         throw toAppductError(error);
       }
@@ -1124,8 +1140,7 @@ var makeAppClient = (stream, sessionId) => {
         const result = await stream.call(RPC_METHODS2.eventsSince, {
           selector: sessionId,
           since: options.since,
-          limit: options.limit,
-          kinds: ["app_event"]
+          limit: options.limit
         });
         return {
           events: result.events.map((event) => appEventFrom(event, sessionId)).filter((event) => event !== void 0),
@@ -1184,8 +1199,7 @@ var makeAppClient = (stream, sessionId) => {
           await stream.call(RPC_METHODS2.eventsSubscribe, { sessionSelector: sessionId, kinds: ["app_event"] });
           const sinceResult = await stream.call(RPC_METHODS2.eventsSince, {
             selector: sessionId,
-            since: options.since,
-            kinds: ["app_event"]
+            since: options.since
           });
           const seenSeqs = /* @__PURE__ */ new Set();
           const backlog = [];

package/dist/commands/events.d.ts

@@ -1,6 +1,7 @@
 /**
- * `appduct events` (ARCHITECTURE.md §10): subscribes to `events.subscribe` over a persistent
- * connection and streams notifications until interrupted (Ctrl-C) or the connection drops. This is
+ * `appduct events` (ARCHITECTURE.md §10): subscribes to `events.subscribe` for `app_event` only
+ * over a persistent connection and streams the app's own events until interrupted (Ctrl-C) or the
+ * connection drops. Appduct's lifecycle and tool-call kinds are not printed (issue #98). This is
  * the one command whose output isn't a single rendered `CliResult` — each event is written as it
  * arrives (NDJSON under `--json`, a human line otherwise) — so it plugs into `executeHostedCommand`
  * with a live reporter that suppresses the default one-shot bootstrap render (`cli/runner.ts`).

package/dist/daemon/config.d.ts

@@ -34,7 +34,7 @@ export type AppductConfig = {
     graceSeconds: number;
     linkTtlSeconds: number;
     keepaliveIntervalSeconds: number;
-    /** Max retained `app_event`/etc. events per session (ARCHITECTURE.md §5's `events.since`
+    /** Max retained `app_event`s per session (ARCHITECTURE.md §5's `events.since`
      * retention buffer); default 256. */
     eventBufferSize: number;
     /** Days of `audit/<YYYY-MM-DD>.jsonl` history to keep; files older than this are pruned on
@@ -43,6 +43,9 @@ export type AppductConfig = {
     /** Size at which `daemon.log` is rotated to `daemon.log.1` before a daemon is spawned
      * (ARCHITECTURE.md §3/§4). Default 10 MiB. */
     daemonLogMaxBytes: number;
+    /** Size past which the daemon rotates `events.log` to `events.log.1` (ARCHITECTURE.md §3).
+     * Default 10 MiB. */
+    eventsLogMaxBytes: number;
     policy: AppductPolicyConfig;
     /**
      * When the CLI/MCP client finds the running daemon on a different Appduct version, restart it

package/dist/daemon/daemon.d.ts

@@ -14,6 +14,7 @@ import { type DaemonListener } from "./listener.js";
 import { type RpcServer } from "./rpc-server.js";
 import { type StateDirPaths } from "./state-dir.js";
 import { type TimerFns } from "./timers.js";
+import { type TlsManager } from "./tls.js";
 /** How often audit retention runs after the startup prune (ARCHITECTURE.md §3: "once a day"). */
 export declare const AUDIT_PRUNE_INTERVAL_MS: number;
 export type DaemonOptions = {
@@ -33,6 +34,8 @@ export type RunningDaemon = {
     startedAt: Date;
     server: RpcServer;
     listener: DaemonListener;
+    /** The host certificate the listener serves, so an in-process client can trust it. */
+    tls: TlsManager;
     eventBus: EventBus;
     /** Resolves once graceful teardown (sockets closed, RPC/listener closed, pidfile released) completes. */
     exited: Promise<void>;

package/dist/daemon/event-bus.d.ts

@@ -4,9 +4,10 @@
  * per-session retention ring buffer, and must never let a throwing subscriber take down the daemon
  * or another subscriber.
  *
- * Retention (issue #6): every session-scoped event (`sessionId` set), except the high-frequency
- * kinds in `EXCLUDED_FROM_RETENTION`, is appended to a per-session ring buffer with a
- * monotonically increasing `seq`, capped at `bufferSize` entries (oldest dropped first). A
+ * Retention (issue #6, #98): every session-scoped event gets a monotonically increasing per-session
+ * `seq`, but only `app_event` is appended to the per-session ring buffer, capped at `bufferSize`
+ * entries (oldest dropped first). Appduct's own kinds (lifecycle, tool calls) are fanned out live
+ * and never retained, so no number of tool calls can evict an app event. A
  * session's buffer is discarded the moment it emits a terminal event (`session_expired` /
  * `session_revoked`) — "terminal states free the alias" (sessions.ts) applies to retained events
  * too, matching "no persisted history" (ARCHITECTURE.md §3/§13) — or via an explicit `drop()` for
@@ -22,7 +23,6 @@ export type EventBusEmitInput = Omit<EventNotification, "ts" | "seq"> & {
 export type EventBusListener = (event: EventNotification) => void;
 export type EventsSinceQuery = {
     since?: number;
-    kinds?: EventKind[];
     limit?: number;
 };
 export type EventsSinceQueryResult = {

package/dist/daemon/events-log.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The daemon's own event log, `<stateDir>/events.log` (ARCHITECTURE.md §3): one JSON line per
+ * event, for debugging Appduct itself. The daemon decides which events to record; this module only
+ * writes them and keeps the file bounded.
+ *
+ * Writes are serialized on a promise queue, so {@link EventsLog.record} returns at once and never
+ * blocks the emitter. After each append the file is rotated to a single backup once it is over
+ * `maxBytes`, so the current file is never above the cap once a write has settled. A failed write
+ * or rotation is warned, never thrown, and never stops later writes.
+ */
+import type { EventNotification } from "@appduct/shared";
+/** A file that only ever grows by whole lines, with one backup slot. */
+export type AppendOnlyFile = {
+    /** Appends `line` plus a newline, creating the file at mode `0600` if it is missing. */
+    append(line: string): Promise<void>;
+    /** Current size in bytes; `0` when the file does not exist. */
+    size(): Promise<number>;
+    /** Moves the file to the backup slot, replacing any previous backup. */
+    rotate(): Promise<void>;
+};
+export type EventsLog = {
+    /** Queues `event` as one JSON line; returns immediately. */
+    record(event: EventNotification): void;
+    /** Resolves once every write queued so far has settled. */
+    flush(): Promise<void>;
+};
+export declare const createEventsLog: (options: {
+    file: AppendOnlyFile;
+    maxBytes: number;
+    warn: (message: string) => void;
+}) => EventsLog;

package/dist/daemon/memory-append-only-file.d.ts

@@ -0,0 +1,17 @@
+/** In-memory {@link AppendOnlyFile} for tests: inspect the lines written and the backup, or make
+ * appends fail. */
+import type { AppendOnlyFile } from "./events-log.js";
+export declare class MemoryAppendOnlyFile implements AppendOnlyFile {
+    private current;
+    private backup;
+    private appendError;
+    append(line: string): Promise<void>;
+    size(): Promise<number>;
+    rotate(): Promise<void>;
+    /** Lines in the current file, without their newlines. */
+    lines(): string[];
+    /** Lines in the backup, without their newlines. */
+    backupLines(): string[];
+    /** Makes every append throw `error` until called again with `undefined`. */
+    failAppendsWith(error: Error | undefined): void;
+}

package/dist/daemon/node-append-only-file.d.ts

@@ -0,0 +1,9 @@
+/** {@link AppendOnlyFile} on the real filesystem; the backup is `<path>.1`. */
+import type { AppendOnlyFile } from "./events-log.js";
+export declare class NodeAppendOnlyFile implements AppendOnlyFile {
+    private readonly path;
+    constructor(path: string);
+    append(line: string): Promise<void>;
+    size(): Promise<number>;
+    rotate(): Promise<void>;
+}

package/dist/daemon/state-dir.d.ts

@@ -11,6 +11,8 @@ export type StateDirPaths = {
     socketPath: string;
     pidFilePath: string;
     logFilePath: string;
+    /** The daemon's own event log; rotated to `<eventsLogPath>.1`. */
+    eventsLogPath: string;
     keyPath: string;
     configPath: string;
     auditDir: string;

package/dist/index.js

@@ -140,7 +140,7 @@ var createCli = () => {
     "--timeout <ms>",
     "Call timeout in milliseconds. Shortens the deadline; it cannot extend one past the app's own timer, which is the tool's declared timeoutMs (else 10000)."
   );
-  cli.command("events [selector]", "Stream session/tool events until interrupted.").option("--follow", "Accepted for script readability; the default behavior already follows.").option("--since <cursor>", "One-shot: print events retained since this cursor instead of streaming live.");
+  cli.command("events [selector]", "Stream the events the app posts until interrupted.").option("--follow", "Accepted for script readability; the default behavior already follows.").option("--since <cursor>", "One-shot: print the app events retained since this cursor instead of streaming live.");
   cli.command("revoke [selector]", "Revoke a session.");
   cli.command("mcp", "Start a stdio MCP server that gives MCP clients access to connected apps' tools.").option(
     "--scheme <scheme>",
@@ -164,6 +164,7 @@ var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "eventBufferSize",
   "auditRetentionDays",
   "daemonLogMaxBytes",
+  "eventsLogMaxBytes",
   "policy",
   "advertisedIp",
   "scheme",
@@ -223,6 +224,7 @@ var defaultConfig = (paths) => {
     eventBufferSize: 256,
     auditRetentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
     daemonLogMaxBytes: DEFAULT_DAEMON_LOG_MAX_BYTES,
+    eventsLogMaxBytes: 10 * 1024 * 1024,
     restartDaemonOnVersionMismatch: false,
     policy: {
       default: "allow",
@@ -285,6 +287,9 @@ var loadConfig = async (paths, options = {}) => {
   if (parsed.daemonLogMaxBytes !== void 0) {
     config.daemonLogMaxBytes = requirePositiveInteger(parsed.daemonLogMaxBytes, "daemonLogMaxBytes");
   }
+  if (parsed.eventsLogMaxBytes !== void 0) {
+    config.eventsLogMaxBytes = requirePositiveInteger(parsed.eventsLogMaxBytes, "eventsLogMaxBytes");
+  }
   if (parsed.restartDaemonOnVersionMismatch !== void 0) {
     config.restartDaemonOnVersionMismatch = requireBoolean(
       parsed.restartDaemonOnVersionMismatch,
@@ -333,6 +338,7 @@ var getStateDirPaths = (stateDir) => {
     socketPath: join3(stateDir, "daemon.sock"),
     pidFilePath: join3(stateDir, "daemon.pid"),
     logFilePath: join3(stateDir, "daemon.log"),
+    eventsLogPath: join3(stateDir, "events.log"),
     keyPath: join3(stateDir, "key.pem"),
     configPath: join3(stateDir, "config.json"),
     auditDir: join3(stateDir, "audit"),

package/dist/mcp/app-tools.d.ts

@@ -9,7 +9,7 @@
  * Every lookup goes to the daemon live, with no caching: the session and its registry can change
  * between any two calls, and the daemon is the single source of truth for both.
  */
-import { type EffectivePolicyDecision, type ToolDescriptor } from "@appduct/shared";
+import { type EffectivePolicyDecision, type ListedToolDescriptor } from "@appduct/shared";
 import type { DaemonCall } from "./daemon-tools.js";
 export declare const LIST_TOOLS_TOOL_NAME = "appduct_list_tools";
 export declare const DESCRIBE_TOOL_TOOL_NAME = "appduct_describe_tool";
@@ -103,7 +103,7 @@ export declare const CALL_TOOL_TOOL_DESCRIPTOR: {
 export type ResolvedAppTool = {
     sessionId: string;
     alias: string;
-    descriptor: ToolDescriptor;
+    descriptor: ListedToolDescriptor;
     policy: EffectivePolicyDecision;
 };
 export type CallToolArgs = {
@@ -132,11 +132,11 @@ export declare const handleListToolsTool: (rawArgs: unknown, call: DaemonCall) =
 export declare const handleDescribeToolTool: (rawArgs: unknown, call: DaemonCall) => Promise<{
     name: string;
     description: string;
-    input_schema?: import("@appduct/shared").ToolSchemaDescriptor;
-    output_schema?: import("@appduct/shared").ToolSchemaDescriptor;
-    annotations?: import("@appduct/shared").ToolAnnotations;
-    timeout_ms?: number;
-    group?: string | null;
+    input_schema?: import("@appduct/shared").ToolSchemaDescriptor | undefined;
+    output_schema?: import("@appduct/shared").ToolSchemaDescriptor | undefined;
+    annotations?: import("@appduct/shared").ToolAnnotations | undefined;
+    timeout_ms?: number | undefined;
+    group: string | null;
     session: string;
     signature: string;
     policy: EffectivePolicyDecision;

package/dist/mcp/events-tool.d.ts

@@ -38,13 +38,6 @@ export declare const EVENTS_TOOL_DESCRIPTOR: {
                 readonly type: "integer";
                 readonly minimum: 0;
             };
-            readonly kinds: {
-                readonly type: "array";
-                readonly items: {
-                    readonly type: "string";
-                    readonly enum: readonly ["daemon_started", "link_created", "link_expired", "session_claimed", "session_suspended", "session_resumed", "session_revoked", "session_expired", "tools_changed", "app_event", "tool_call_started", "tool_call_progress", "tool_call_finished"];
-                };
-            };
             readonly limit: {
                 readonly type: "integer";
                 readonly exclusiveMinimum: 0;

package/dist/rpc/client.d.ts

@@ -1,7 +1,8 @@
 /**
  * The auto-spawning RPC client library (ARCHITECTURE.md §4, §5) used by the CLI, MCP server, and
- * tests to talk to `daemon.sock`. On `ENOENT`/`ECONNREFUSED` it takes an exclusive spawn-lock,
- * spawns `daemon run` detached, polls the socket until ready, then retries the request once.
+ * tests to talk to `daemon.sock`. On `ENOENT`/`ECONNREFUSED` it creates the state dir if it is
+ * missing, takes an exclusive spawn-lock, spawns `daemon run` detached, polls the socket until
+ * ready, then retries the request once.
  */
 import { type RpcErrorData } from "@appduct/shared";
 export type SpawnContext = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appduct",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Driving React Native tools without in-app debug UI.",
   "type": "module",
   "main": "./dist/index.js",
@@ -45,12 +45,13 @@
     "reflect-metadata": "^0.2.2",
     "toqr": "^0.1.1",
     "ws": "^8.18.3",
-    "@appduct/shared": "0.11.0"
+    "@appduct/shared": "0.12.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",
     "@types/ws": "^8.18.1",
     "esbuild": "^0.25.12",
+    "eslint": "^10",
     "typescript": "~5.9.2"
   },
   "files": [
@@ -60,6 +61,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node scripts/bundle.mjs",
     "clean": "rm -rf dist",
+    "lint": "eslint src",
     "test": "vitest run --config ../../vitest.config.ts src/__tests__",
     "typecheck": "tsc -p tsconfig.json"
   }