patchwork-os 0.2.0-beta.9.canary.92 → 1.1.0-beta.1

package/dist/bridge.js

@@ -15,6 +15,7 @@ import { ClaudeOrchestrator } from "./claudeOrchestrator.js";
 import { CommitIssueLinkLog } from "./commitIssueLinkLog.js";
 import { DecisionTraceLog } from "./decisionTraceLog.js";
 import { createDriver } from "./drivers/index.js";
+import { getLocalEmbedFn } from "./embeddings/index.js";
 import { ExtensionClient } from "./extensionClient.js";
 import { lockKillSwitchEnv, watchFlags } from "./featureFlags.js";
 import { FileLock } from "./fileLock.js";
@@ -28,14 +29,16 @@ import { PluginWatcher } from "./pluginWatcher.js";
 import { isPreToolUseHookRegistered } from "./preToolUseHook.js";
 import { probeAll } from "./probe.js";
 import { RecipeOrchestration } from "./recipeOrchestration.js";
+import { collectEventTriggerPrograms, shouldAutoEnableAutomation, } from "./recipes/eventTriggerPrograms.js";
 import { haltSummaryToPrometheus, summariseHalts, } from "./recipes/haltCategory.js";
 import { judgeSummaryToPrometheus, summariseJudgments, } from "./recipes/judgeSummary.js";
 import { warnAboutLegacyPermissionsSidecars } from "./recipes/migrationWarnings.js";
 import { RecipeOrchestrator } from "./recipes/RecipeOrchestrator.js";
-import { classifyTool } from "./riskTier.js";
+import { evaluateInProcessGate } from "./riskSignals.js";
 import { RecipeRunLog } from "./runLog.js";
 import { Server } from "./server.js";
 import { SessionCheckpoint } from "./sessionCheckpoint.js";
+import { buildSessionDetail } from "./sessionDetail.js";
 import { StreamableHttpHandler } from "./streamableHttp.js";
 import { initTelemetry, shutdownTelemetry } from "./telemetry.js";
 import { TokenUsageTracker } from "./tokenUsageTracker.js";
@@ -48,8 +51,9 @@ import { resolveFilePath } from "./tools/utils.js";
 import { McpTransport } from "./transport.js";
 import { PACKAGE_VERSION } from "./version.js";
 import { wireHaltPushDispatch } from "./wireHaltPushDispatch.js";
+import { WorkerGateDecisionLog } from "./workerGateDecisionLog.js";
 const SHUTDOWN_TIMEOUT_MS = 5000;
-let globalHandlersRegistered = false;
+let activeSignalHandlers = null;
 /** Collect the union of openedFiles across all sessions in a checkpoint. */
 export function extractRestoredFiles(checkpoint, workspace) {
     const all = new Set();
@@ -126,6 +130,7 @@ export class Bridge {
     recipeOrchestrator = null;
     commitIssueLinkLog = null;
     decisionTraceLog = null;
+    workerGateDecisionLog = null;
     /** Pre-computed digest of recent decisions, refreshed on each session connect. */
     recentTracesDigest = [];
     httpMcpHandler = null;
@@ -149,6 +154,10 @@ export class Bridge {
         this.server = new Server(this.authToken, this.logger, config.corsOrigins, undefined, config.trustedProxies);
         this.server.bridgeConfigPath = config.configFilePath ?? undefined;
         this.server.webhookSecret = config.webhookSecret ?? null;
+        // Audit 2026-06-08 (server-3): workspace-relative routes (decision replay,
+        // CC permission attribution, approval routing) must use the configured
+        // workspace, not the bridge process's cwd.
+        this.server.workspace = config.workspace;
         if (config.issuerUrl) {
             this.oauthServer = new OAuthServerImpl(this.authToken, config.issuerUrl, {
                 configDir,
@@ -289,20 +298,24 @@ export class Bridge {
                 catch {
                     // Best-effort warning — never block startup on a hook check failure.
                 }
-                transport.setApprovalGate(async ({ toolName, params, sessionId }) => {
-                    const tier = classifyTool(toolName);
-                    if (this.server.approvalGate === "off")
-                        return "bypass";
-                    if (this.server.approvalGate !== "all" && tier !== "high")
+                transport.setApprovalGate(async ({ toolName, params, sessionId, onPending }) => {
+                    const gate = evaluateInProcessGate({
+                        toolName,
+                        params,
+                        gate: this.server.approvalGate,
+                        workspace: this.config.workspace,
+                    });
+                    if (gate.decision === "bypass")
                         return "bypass";
                     const queue = getApprovalQueue();
-                    const { promise } = queue.request({
+                    const { promise, callId } = queue.request({
                         toolName,
                         params,
-                        tier,
+                        tier: gate.tier,
                         sessionId: sessionId ?? undefined,
-                        riskSignals: [],
+                        riskSignals: gate.riskSignals,
                     });
+                    onPending?.(callId);
                     return promise;
                 });
             }
@@ -375,7 +388,7 @@ export class Bridge {
             }), (generatedAt) => {
                 this._lastContextCachedAt = generatedAt;
                 this._emitLiveState();
-            }, () => this.extensionDisconnectCount, this.commitIssueLinkLog ?? undefined, this.recipeRunLog ?? undefined, this.decisionTraceLog ?? undefined);
+            }, () => this.extensionDisconnectCount, this.commitIssueLinkLog ?? undefined, this.recipeRunLog ?? undefined, this.decisionTraceLog ?? undefined, this.workerGateDecisionLog ?? undefined);
             transport.attach(ws);
             this.sessions.set(sessionId, session);
             this.logger.info(`Claude Code connected (session ${sessionId.slice(0, 8)}) — ${this.sessions.size} active session${this.sessions.size === 1 ? "" : "s"}`);
@@ -558,7 +571,7 @@ export class Bridge {
                 errors += e;
                 warnings += w;
                 if (e > 0)
-                    errorFiles.push(file.split("/").pop() ?? file);
+                    errorFiles.push(path.basename(file) || file);
             }
             lines.push(`Diagnostics: ${errors} errors, ${warnings} warnings`);
             if (errorFiles.length > 0) {
@@ -735,6 +748,30 @@ export class Bridge {
     getAuthToken() {
         return this.authToken;
     }
+    /**
+     * Compile installed recipe triggers (file_watch / git_hook) and register them
+     * into the live AutomationHooks so they actually fire on the corresponding
+     * events. Without this, such recipes are parsed + installed but decorative
+     * (see docs/dogfood/recipe-dogfood-2026-05-01/C-triggers.md). Idempotent and
+     * fail-soft: safe to call at startup and on every recipe hot-reload; a no-op
+     * when automation is disabled.
+     */
+    registerRecipeTriggerPrograms() {
+        if (!this.automationHooks)
+            return;
+        try {
+            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
+            const collected = collectEventTriggerPrograms(recipesDir, {
+                logger: this.logger,
+            });
+            this.automationHooks.registerRecipePrograms(collected.programs);
+            const n = collected.programs.length;
+            this.logger.info(`[bridge] Recipe triggers registered · ${n} event-driven recipe${n === 1 ? "" : "s"}${collected.recipeNames.length ? ` (${collected.recipeNames.join(", ")})` : ""}`);
+        }
+        catch (err) {
+            this.logger.warn?.(`[bridge] recipe trigger registration failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     async start() {
         // 0. Initialize OpenTelemetry (no-op when OTEL_EXPORTER_OTLP_ENDPOINT is unset)
         initTelemetry();
@@ -772,6 +809,29 @@ export class Bridge {
         this.logger.info(`Probed tools: ${probeList()}`);
         this.logger.info(`Available linters: ${probeList(["tsc", "eslint", "pyright", "ruff", "cargo", "go", "biome"])}`);
         this.logger.info(`Available test runners: ${probeList(["vitest", "jest", "pytest", "cargo", "go"])}`);
+        // Initialize Patchwork enrichment + decision-trace logs.
+        //
+        // These back the ctx tools (ctxQueryTraces / ctxGetTaskContext /
+        // ctxSaveTrace / getCommitsForIssue) which are advertised as standard
+        // full-mode tools regardless of orchestration. They MUST be created even
+        // on the default `driver: "none"` bridge — otherwise the decision-trace
+        // WRITE path and the enrichment reverse-lookup silently disappear and
+        // ctxSaveTrace returns tool-not-found.
+        const patchworkDir = path.join(os.homedir(), ".patchwork");
+        this.commitIssueLinkLog = new CommitIssueLinkLog({
+            dir: patchworkDir,
+            logger: this.logger,
+        });
+        this.decisionTraceLog = new DecisionTraceLog({
+            dir: patchworkDir,
+            logger: this.logger,
+        });
+        // Decision Record store — every worker-gate decision + inputs (replayable
+        // audit trail). Always available so the gate's decisions are never discarded.
+        this.workerGateDecisionLog = new WorkerGateDecisionLog({
+            dir: patchworkDir,
+            logger: this.logger,
+        });
         // 2. Initialize Claude driver and orchestrator (if configured)
         if (this.config.driver !== "none") {
             const driver = createDriver(this.config.driver, {
@@ -788,16 +848,6 @@ export class Bridge {
                     }
                     : undefined,
             }, (msg) => this.logger.info(msg));
-            // Patchwork: enrichment link log is useful regardless of orchestrator.
-            const patchworkDir = path.join(os.homedir(), ".patchwork");
-            this.commitIssueLinkLog = new CommitIssueLinkLog({
-                dir: patchworkDir,
-                logger: this.logger,
-            });
-            this.decisionTraceLog = new DecisionTraceLog({
-                dir: patchworkDir,
-                logger: this.logger,
-            });
             if (driver) {
                 // Recipe run-history needs the orchestrator to produce anything.
                 this.recipeRunLog = new RecipeRunLog({
@@ -862,6 +912,7 @@ export class Bridge {
                     recipeOrchestrator: this.recipeOrchestrator,
                     recipeRunLog: this.recipeRunLog,
                     activityLog: this.activityLog,
+                    workerGateDecisionLog: this.workerGateDecisionLog,
                     workdir: this.config.workspace,
                     logger: this.logger,
                 });
@@ -891,6 +942,10 @@ export class Bridge {
                     catch (err) {
                         this.logger.warn?.(`[patchwork] scheduler restart failed: ${err instanceof Error ? err.message : String(err)}`);
                     }
+                    // Re-sync recipe-derived event triggers (file_watch / git_hook) on
+                    // every install / save / delete. registerRecipePrograms() replaces the
+                    // prior recipe set, so this is idempotent.
+                    this.registerRecipeTriggerPrograms();
                 };
             }
         }
@@ -902,8 +957,64 @@ export class Bridge {
                 throw new Error("--automation requires --automation-policy <path>");
             }
             const policy = loadPolicy(this.config.automationPolicyPath);
-            this.automationHooks = new AutomationHooks(policy, this.orchestrator, (msg) => this.logger.info(msg), this.extensionClient, this.config.workspace, this.config.automationAllowPrivateWebhooks);
+            this.automationHooks = new AutomationHooks(policy, this.orchestrator, (msg) => this.logger.info(msg), this.extensionClient, this.config.workspace, this.config.automationAllowPrivateWebhooks, this.recipeOrchestration
+                ? (opts) => 
+                // biome-ignore lint/style/noNonNullAssertion: guarded by outer ternary
+                this.recipeOrchestration.fireYamlRecipe({
+                    filePath: path.join(os.homedir(), ".patchwork", "recipes", `${opts.recipeName}.yaml`),
+                    name: opts.recipeName,
+                    taskIdPrefix: `automation-recipe-${opts.recipeName}`,
+                    triggerSourceSuffix: `automation:${opts.triggerSource}`,
+                    logLabel: `automation "${opts.recipeName}"`,
+                    seedContext: Object.fromEntries(Object.entries(opts.eventData)),
+                }).then((r) => {
+                    if (!r.ok)
+                        throw new Error(r.error ?? "recipe fire failed");
+                    return r.taskId ?? "";
+                })
+                : undefined);
             this.logger.info(`[bridge] Automation enabled (policy: ${this.config.automationPolicyPath})`);
+            // Wire installed recipe triggers (file_watch / git_hook) into the live
+            // interpreter — they compile to hooks the bridge already fires, but were
+            // never registered until now (decorative). See C-triggers.md.
+            this.registerRecipeTriggerPrograms();
+        }
+        else if (this.orchestrator) {
+            // Auto-enable (no --automation policy): when installed recipes declare
+            // event triggers AND a subprocess driver is active, stand up a policy-less
+            // AutomationHooks so those triggers actually fire. The `this.orchestrator`
+            // guard is the safety floor — we never spawn tasks unless the operator
+            // already enabled a driver. Pass --automation --automation-policy to add
+            // policy-file hooks on top of the recipe triggers.
+            const recipesDir = path.join(os.homedir(), ".patchwork", "recipes");
+            const collected = collectEventTriggerPrograms(recipesDir, {
+                logger: this.logger,
+            });
+            if (shouldAutoEnableAutomation({
+                automationEnabled: this.config.automationEnabled,
+                hasDriver: true,
+                eventProgramCount: collected.programs.length,
+            })) {
+                this.automationHooks = new AutomationHooks({}, this.orchestrator, (msg) => this.logger.info(msg), this.extensionClient, this.config.workspace, this.config.automationAllowPrivateWebhooks, this.recipeOrchestration
+                    ? (opts) => 
+                    // biome-ignore lint/style/noNonNullAssertion: guarded by outer ternary
+                    this.recipeOrchestration.fireYamlRecipe({
+                        filePath: path.join(os.homedir(), ".patchwork", "recipes", `${opts.recipeName}.yaml`),
+                        name: opts.recipeName,
+                        taskIdPrefix: `automation-recipe-${opts.recipeName}`,
+                        triggerSourceSuffix: `automation:${opts.triggerSource}`,
+                        logLabel: `automation "${opts.recipeName}"`,
+                        seedContext: Object.fromEntries(Object.entries(opts.eventData)),
+                    }).then((r) => {
+                        if (!r.ok)
+                            throw new Error(r.error ?? "recipe fire failed");
+                        return r.taskId ?? "";
+                    })
+                    : undefined);
+                this.automationHooks.registerRecipePrograms(collected.programs);
+                const n = collected.programs.length;
+                this.logger.info(`[bridge] Automation auto-enabled for ${n} event-driven recipe${n === 1 ? "" : "s"} (${collected.recipeNames.join(", ")}) — no --automation policy; pass --automation --automation-policy to add policy hooks`);
+            }
         }
         // 3. Wire up /health endpoint data and /metrics
         this.server.healthDataFn = () => {
@@ -1035,20 +1146,42 @@ export class Bridge {
                 nearby: nearby,
             };
         };
+        // Build the traces tool + embeddings provider ONCE at startup. The
+        // dashboard polls /traces every few seconds; re-constructing the tool and
+        // re-allocating the embeddings provider on every request was pure waste
+        // (audit sem-4). The log references and embed fn are stable for the
+        // bridge's lifetime.
+        const tracesTool = createCtxQueryTracesTool({
+            activityLog: this.activityLog,
+            commitIssueLinkLog: this.commitIssueLinkLog,
+            recipeRunLog: this.recipeRunLog,
+            decisionTraceLog: this.decisionTraceLog,
+            workerGateDecisionLog: this.workerGateDecisionLog,
+            embedFn: getLocalEmbedFn(),
+        });
+        // POST /traces/decision — HTTP twin of the ctxSaveTrace MCP tool, same
+        // DecisionTraceLog.record() writer/validation. null when the bridge has
+        // no decisionTraceLog configured (route responds 503 in that case).
+        this.server.saveDecisionTraceFn = this.decisionTraceLog
+            ? (input) => this.decisionTraceLog.record({
+                ref: input.ref,
+                problem: input.problem,
+                solution: input.solution,
+                workspace: input.workspace ?? this.config.workspace,
+                ...(input.tags && { tags: input.tags }),
+                ...(input.sessionId && { sessionId: input.sessionId }),
+                ...(input.source && { source: input.source }),
+            })
+            : null;
         this.server.tracesFn = async (query) => {
-            const tool = createCtxQueryTracesTool({
-                activityLog: this.activityLog,
-                commitIssueLinkLog: this.commitIssueLinkLog,
-                recipeRunLog: this.recipeRunLog,
-                decisionTraceLog: this.decisionTraceLog,
-            });
-            const result = await tool.handler({
+            const result = await tracesTool.handler({
                 ...(query.traceType && { traceType: query.traceType }),
                 ...(query.key && { key: query.key }),
                 ...(query.q && { q: query.q }),
                 ...(query.tag && { tag: query.tag }),
                 ...(query.since !== undefined && { since: query.since }),
                 ...(query.limit !== undefined && { limit: query.limit }),
+                ...(query.semantic && { semantic: true }),
             });
             const structured = result
                 .structuredContent;
@@ -1069,13 +1202,20 @@ export class Bridge {
         this.server.analyticsFn = async (windowHours) => {
             const wh = typeof windowHours === "number" && windowHours >= 1 ? windowHours : 24;
             const cutoff = Date.now() - wh * 3_600 * 1_000;
-            const statsMap = this.activityLog.stats();
+            // Respect the requested window for tool counts (was all-time `stats()`).
+            const statsMap = this.activityLog.windowedStats(wh * 3_600 * 1_000);
+            // Per-tool latency percentiles. `percentiles()` is computed over the
+            // bounded duration-sample buffer (not windowed) and omits any tool with
+            // <2 samples — default those to 0 so the dashboard ToolStat shape is
+            // always satisfied.
+            const pctMap = this.activityLog.percentiles();
             const topTools = Object.entries(statsMap)
                 .map(([tool, s]) => ({
                 tool,
                 calls: s.count,
                 errors: s.errors,
-                avgMs: s.avgDurationMs,
+                p50Ms: pctMap[tool]?.p50 ?? 0,
+                p95Ms: pctMap[tool]?.p95 ?? 0,
             }))
                 .sort((a, b) => b.calls - a.calls)
                 .slice(0, 10);
@@ -1104,6 +1244,8 @@ export class Bridge {
                         t.doneAt !== undefined && {
                         durationMs: t.doneAt - t.startedAt,
                     }),
+                    ...(t.startedAt !== undefined && { startedAt: t.startedAt }),
+                    ...(t.doneAt !== undefined && { completedAt: t.doneAt }),
                     createdAt: new Date(t.createdAt).toISOString(),
                     ...(t.output !== undefined && {
                         output: t.output.slice(0, 2000),
@@ -1170,6 +1312,13 @@ export class Bridge {
             }
             return out;
         };
+        // Wire `/sessions/:id` for the dashboard's session-detail page. Audit
+        // 2026-06-08 HIGH (server-1): sessionDetailFn was declared in server.ts but
+        // never assigned, so GET /sessions/:id returned 404 forever and the page
+        // was permanently blank. The dashboard navigates with the 8-char prefix
+        // sessionsFn emits (`s.id.slice(0,8)`), so resolve that (or a full id) to
+        // the active session, then slice the per-session activity from the log.
+        this.server.sessionDetailFn = (id) => buildSessionDetail(id, this.sessions.values(), this.activityLog, getApprovalQueue().list());
         this.server.restartCheckFn = () => {
             let totalSessions = 0;
             let totalInFlight = 0;
@@ -1290,6 +1439,12 @@ export class Bridge {
         this.server.statusFn = () => {
             let sessionsInGrace = 0;
             const sessionList = [];
+            // Rate-limit state isn't a single bridge-wide value (each session has
+            // its own token bucket, or a shared one for HTTP session cycling — see
+            // McpTransport.setSharedToolRateLimitBucket) but the dashboard vitals
+            // pane isn't session-scoped, so surface the most-constrained session's
+            // remaining budget as a single aggregate rather than an arbitrary one.
+            let toolRateLimit = null;
             for (const s of this.sessions.values()) {
                 if (s.graceTimer)
                     sessionsInGrace++;
@@ -1300,11 +1455,17 @@ export class Bridge {
                     openedFiles: s.openedFiles.size,
                     terminalPrefix: s.terminalPrefix,
                 });
+                const state = s.transport.getToolRateLimitState();
+                if (state &&
+                    (!toolRateLimit || state.remaining < toolRateLimit.remaining)) {
+                    toolRateLimit = state;
+                }
             }
             return {
                 claudeCode: this.sessions.size > 0,
                 activeSessions: this.sessions.size,
                 sessionsInGrace,
+                toolRateLimit,
                 gracePeriodMs: this.config.gracePeriodMs,
                 lastConnectAt: this.lastConnectAt,
                 lastDisconnectAt: this.lastDisconnectAt,
@@ -1449,6 +1610,9 @@ export class Bridge {
             ...(this.decisionTraceLog && {
                 decisionTraceLog: this.decisionTraceLog,
             }),
+            ...(this.workerGateDecisionLog && {
+                workerGateDecisionLog: this.workerGateDecisionLog,
+            }),
         });
         this.server.httpMcpHandler = (req, res) => this.httpMcpHandler?.handle(req, res) ?? Promise.resolve();
         // 3. Check for stale lock files
@@ -1535,9 +1699,6 @@ export class Bridge {
             await shutdownTelemetry();
             process.exit(exitCode);
         };
-        // All process-level signal handlers are guarded by globalHandlersRegistered so
-        // that repeated start() calls (e.g. in tests or --watch restarts) don't
-        // accumulate process.once listeners and trigger MaxListenersExceededWarning.
         // Wire server callbacks so /restart and /shutdown invoke the bridge's
         // shutdown sequence directly. This is the only path that works on
         // Windows, where `process.kill(pid, 'SIGTERM')` is TerminateProcess
@@ -1548,12 +1709,24 @@ export class Bridge {
         this.server.shutdownFn = () => {
             void shutdown("SIGTERM", 0);
         };
-        if (!globalHandlersRegistered) {
-            globalHandlersRegistered = true;
-            process.once("SIGINT", () => shutdown("SIGINT", 130));
-            process.once("SIGTERM", () => shutdown("SIGTERM", 143));
-            process.once("SIGHUP", () => shutdown("SIGHUP", 143));
-            process.on("unhandledRejection", (reason) => {
+        // core-infra-4: take ownership of the process signal handlers. Detach any
+        // previously-registered set (from an earlier bridge in this process) first
+        // so we never accumulate listeners (MaxListenersExceededWarning) AND the
+        // most-recently-started bridge — whose `shutdown` closure references this
+        // bridge's sessions/logger — is the one that actually runs on teardown.
+        if (activeSignalHandlers) {
+            const prev = activeSignalHandlers;
+            process.removeListener("SIGINT", prev.sigint);
+            process.removeListener("SIGTERM", prev.sigterm);
+            process.removeListener("SIGHUP", prev.sighup);
+            process.removeListener("unhandledRejection", prev.unhandledRejection);
+            process.removeListener("uncaughtException", prev.uncaughtException);
+        }
+        const handlers = {
+            sigint: () => void shutdown("SIGINT", 130),
+            sigterm: () => void shutdown("SIGTERM", 143),
+            sighup: () => void shutdown("SIGHUP", 143),
+            unhandledRejection: (reason) => {
                 for (const [sid, session] of this.sessions) {
                     const stats = session.transport.getStats();
                     if (stats.inFlightTools.length > 0) {
@@ -1561,8 +1734,8 @@ export class Bridge {
                     }
                 }
                 this.logger.error(`Unhandled rejection: ${reason instanceof Error ? (reason.stack ?? reason.message) : String(reason)}`);
-            });
-            process.once("uncaughtException", (err) => {
+            },
+            uncaughtException: (err) => {
                 for (const [sid, session] of this.sessions) {
                     const stats = session.transport.getStats();
                     if (stats.inFlightTools.length > 0) {
@@ -1570,9 +1743,15 @@ export class Bridge {
                     }
                 }
                 this.logger.error(`Uncaught exception: ${err.stack ?? err.message}`);
-                shutdown("uncaughtException", 1);
-            });
-        }
+                void shutdown("uncaughtException", 1);
+            },
+        };
+        process.on("SIGINT", handlers.sigint);
+        process.on("SIGTERM", handlers.sigterm);
+        process.on("SIGHUP", handlers.sighup);
+        process.on("unhandledRejection", handlers.unhandledRejection);
+        process.on("uncaughtException", handlers.uncaughtException);
+        activeSignalHandlers = handlers;
         // Startup banner to stderr (not stdout) to avoid capture by parent processes
         this.logger.info("claude-ide-bridge ready");
         this.logger.info(`  Port:       ${port}`);