@akira-tl/forgerelay 0.5.2 → 0.5.4

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.5.4] - 2026-08-15
+
+### Fixed
+
+- Closed all Activity query SQLite handles before temporary-state cleanup so the backend acceptance suite also passes on Windows, where open database files cannot be unlinked.
+
+## [0.5.3] - 2026-08-15
+
+### Added
+
+- Added durable Host Turn records and a stable Activity query projection backed by ForgeRelay's local SQLite audit history, with revision-based lightweight snapshots that remain queryable after ForgeRelay restarts.
+- Added the production backend query contract for future MCP App UI: model-visible `activity_panel` establishes a Host Turn, while app-only `activity_snapshot`, `activity_detail`, and `activity_output` data sources expose summaries, selected lazy detail, and complete Bash output separately.
+
+### Changed
+
+- Activity snapshots now use an explicit summary whitelist: read bodies, write/edit patches, full Bash commands/output, and capability-heavy payloads stay out of normal snapshots; rename/delete include complete path targets and are summary-complete without detail requests.
+- Late Bash completion records use the current Host Turn for delivery while preserving the original Bash Activity's immutable returned history and Workspace audit snapshot.
+
 ## [0.5.2] - 2026-08-15
 
 ### Added

package/dist/activity/audit-store.js

@@ -47,6 +47,24 @@ export class ActivityAuditStore {
     listEvents(activityId) {
         return this.readRows(activityId).map(rowToEvent);
     }
+    listActivitiesByTurn(turnId) {
+        const rows = this.database.sqlite.prepare(`select activity_id from activity_audit_events
+       where event_type = 'started' and turn_id = ?
+       order by rowid asc`).all(turnId);
+        return rows.flatMap(({ activity_id }) => {
+            const activity = this.getActivity(activity_id);
+            return activity ? [activity] : [];
+        });
+    }
+    turnRevision(turnId) {
+        const row = this.database.sqlite.prepare(`select count(*) as revision
+       from activity_audit_events
+       where activity_id in (
+         select activity_id from activity_audit_events
+         where event_type = 'started' and turn_id = ?
+       )`).get(turnId);
+        return row.revision;
+    }
     getActivity(activityId) {
         const events = this.listEvents(activityId);
         const started = events[0];

package/dist/activity/host-turn-store.js

@@ -0,0 +1,46 @@
+import { randomUUID } from "node:crypto";
+import { openDatabase } from "../db/client.js";
+export class HostTurnStore {
+    database;
+    now;
+    nextTurnId;
+    constructor(stateDir, options = {}) {
+        this.database = openDatabase(stateDir);
+        this.now = options.now ?? (() => new Date());
+        this.nextTurnId = options.turnId ?? (() => `turn_${randomUUID().replaceAll("-", "")}`);
+    }
+    begin(conversationScopeId) {
+        const turnId = this.nextTurnId();
+        const createdAt = this.now().toISOString();
+        this.database.sqlite.prepare(`insert into activity_host_turns (turn_id, conversation_scope_id, created_at)
+       values (?, ?, ?)`).run(turnId, conversationScopeId ?? null, createdAt);
+        return {
+            turnId,
+            ...(conversationScopeId ? { conversationScopeId } : {}),
+            createdAt,
+        };
+    }
+    get(turnId) {
+        const row = this.database.sqlite.prepare("select * from activity_host_turns where turn_id = ?").get(turnId);
+        return row ? rowToTurn(row) : undefined;
+    }
+    current(conversationScopeId) {
+        if (!conversationScopeId)
+            return undefined;
+        const row = this.database.sqlite.prepare(`select * from activity_host_turns
+       where conversation_scope_id = ?
+       order by rowid desc
+       limit 1`).get(conversationScopeId);
+        return row ? rowToTurn(row) : undefined;
+    }
+    close() {
+        this.database.close();
+    }
+}
+function rowToTurn(row) {
+    return {
+        turnId: row.turn_id,
+        ...(row.conversation_scope_id ? { conversationScopeId: row.conversation_scope_id } : {}),
+        createdAt: row.created_at,
+    };
+}

package/dist/activity/lifecycle.js

@@ -4,10 +4,12 @@ export class ActivityLifecycle {
     auditStore;
     activityId;
     turnId;
+    turnIdForConversation;
     constructor(auditStore, options = {}) {
         this.auditStore = auditStore;
         this.activityId = options.activityId ?? newActivityId;
         this.turnId = options.turnId ?? newTurnId;
+        this.turnIdForConversation = options.turnIdForConversation;
     }
     record(options) {
         const context = this.start(options);
@@ -43,7 +45,9 @@ export class ActivityLifecycle {
     }
     start(options) {
         const activityId = options.activityId ?? this.activityId();
-        const turnId = options.turnId ?? this.turnId();
+        const turnId = options.turnId
+            ?? this.turnIdForConversation?.(options.conversationScopeId)
+            ?? this.turnId();
         const request = normalizeAuditValue(options.request);
         this.auditStore.append({
             type: "started",

package/dist/activity/mcp-query-tools.js

@@ -0,0 +1,129 @@
+import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
+import * as z from "zod/v4";
+import { openAiConversationScopeId } from "../request-meta.js";
+const READ_ONLY_ANNOTATIONS = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+const activitySummarySchema = z.object({
+    activityId: z.string(),
+    tool: z.string(),
+    kind: z.string(),
+    status: z.enum(["working", "done", "error"]),
+    state: z.enum(["executing", "returned", "done", "failed", "blocked"]),
+    title: z.string(),
+    target: z.string(),
+    detailAvailable: z.boolean(),
+    workspaceId: z.string().optional(),
+    processId: z.number().int().positive().optional(),
+    outputId: z.string().optional(),
+    commandLength: z.number().int().nonnegative().optional(),
+    bashPhase: z.enum(["executing", "returned", "done", "error"]).optional(),
+    startedAt: z.string(),
+    finishedAt: z.string().optional(),
+    durationMs: z.number().nonnegative().optional(),
+});
+const snapshotOutputSchema = {
+    turnId: z.string(),
+    revision: z.number().int().nonnegative(),
+    changed: z.boolean(),
+    state: z.enum(["working", "done", "error"]),
+    activities: z.array(activitySummarySchema),
+};
+export function registerActivityQueryTools(server, queries) {
+    registerAppTool(server, "activity_panel", {
+        title: "Begin Activity Panel",
+        description: "Begin one ForgeRelay Host Turn lifecycle for subsequent project work. This orchestration call does not read or modify project files. Call it once before the first ForgeRelay work operation in a Host Turn that performs project work.",
+        inputSchema: {},
+        outputSchema: snapshotOutputSchema,
+        _meta: { ui: { visibility: ["model", "app"] } },
+        annotations: {
+            ...READ_ONLY_ANNOTATIONS,
+            idempotentHint: false,
+        },
+    }, async (_input, extra) => {
+        const snapshot = queries.beginTurn(openAiConversationScopeId(extra._meta));
+        return {
+            content: [{
+                    type: "text",
+                    text: `Started ForgeRelay Activity Panel Host Turn ${snapshot.turnId}.`,
+                }],
+            structuredContent: { ...snapshot },
+        };
+    });
+    registerAppTool(server, "activity_snapshot", {
+        title: "Read Activity snapshot",
+        description: "App-only data source for lightweight Activity summaries in one durable Host Turn.",
+        inputSchema: {
+            turnId: z.string(),
+            knownRevision: z.number().int().nonnegative().optional(),
+        },
+        outputSchema: snapshotOutputSchema,
+        _meta: { ui: { visibility: ["app"] } },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ turnId, knownRevision }) => {
+        const snapshot = queries.snapshot(turnId, knownRevision);
+        return {
+            content: [{
+                    type: "text",
+                    text: snapshot.changed
+                        ? `Activity snapshot ${turnId} revision ${snapshot.revision}.`
+                        : `Activity snapshot ${turnId} unchanged at revision ${snapshot.revision}.`,
+                }],
+            structuredContent: { ...snapshot },
+        };
+    });
+    registerAppTool(server, "activity_detail", {
+        title: "Read Activity detail",
+        description: "App-only lazy data source for one selected expandable Activity.",
+        inputSchema: {
+            turnId: z.string(),
+            activityId: z.string(),
+        },
+        outputSchema: {
+            activity: activitySummarySchema,
+            request: z.unknown().optional(),
+            result: z.unknown().optional(),
+            error: z.string().optional(),
+        },
+        _meta: { ui: { visibility: ["app"] } },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ turnId, activityId }) => {
+        const detail = queries.detail(turnId, activityId);
+        return {
+            content: [{ type: "text", text: `Activity detail ${activityId}.` }],
+            structuredContent: { ...detail },
+        };
+    });
+    registerAppTool(server, "activity_output", {
+        title: "Read Bash output",
+        description: "App-only lazy data source for complete durable Bash command/output by stable outputId.",
+        inputSchema: {
+            turnId: z.string(),
+            outputId: z.string(),
+        },
+        outputSchema: {
+            outputId: z.string(),
+            activityId: z.string(),
+            processId: z.number().int().positive(),
+            command: z.string(),
+            output: z.string(),
+            status: z.enum(["running", "done", "failed"]),
+            exitCode: z.number().int().optional(),
+            signal: z.string().optional(),
+            timedOut: z.boolean(),
+            startedAt: z.string(),
+            finishedAt: z.string().optional(),
+        },
+        _meta: { ui: { visibility: ["app"] } },
+        annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ turnId, outputId }) => {
+        const output = queries.bashOutput(turnId, outputId);
+        return {
+            content: [{ type: "text", text: `Bash output ${outputId}.` }],
+            structuredContent: { ...output },
+        };
+    });
+}

package/dist/activity/query-service.js

@@ -0,0 +1,247 @@
+export class ActivityQueryService {
+    turns;
+    audit;
+    outputs;
+    constructor(turns, audit, outputs) {
+        this.turns = turns;
+        this.audit = audit;
+        this.outputs = outputs;
+    }
+    beginTurn(conversationScopeId) {
+        const turn = this.turns.begin(conversationScopeId);
+        return this.snapshot(turn.turnId);
+    }
+    currentTurnId(conversationScopeId) {
+        return this.turns.current(conversationScopeId)?.turnId;
+    }
+    snapshot(turnId, knownRevision) {
+        this.requireTurn(turnId);
+        const revision = this.audit.turnRevision(turnId);
+        const activities = this.audit.listActivitiesByTurn(turnId).map(toSummary);
+        const state = aggregateState(activities);
+        const changed = knownRevision === undefined || knownRevision !== revision;
+        return {
+            turnId,
+            revision,
+            changed,
+            state,
+            activities: changed ? activities : [],
+        };
+    }
+    detail(turnId, activityId) {
+        this.requireTurn(turnId);
+        const record = this.audit.getActivity(activityId);
+        if (!record || record.turnId !== turnId) {
+            throw new Error(`Unknown Activity ${activityId} in Host Turn ${turnId}.`);
+        }
+        const activity = toSummary(record);
+        if (!activity.detailAvailable) {
+            throw new Error(`Activity ${activityId} is summary-complete and has no lazy detail.`);
+        }
+        return {
+            activity,
+            ...(record.request !== undefined ? { request: record.request } : {}),
+            ...(record.result !== undefined ? { result: record.result } : {}),
+            ...(record.error !== undefined ? { error: record.error } : {}),
+        };
+    }
+    bashOutput(turnId, outputId) {
+        this.requireTurn(turnId);
+        const output = this.outputs.read(outputId);
+        if (!output)
+            throw new Error(`Unknown Bash output: ${outputId}.`);
+        const activities = this.audit.listActivitiesByTurn(turnId);
+        const visible = activities.some((activity) => activity.activityId === output.activityId || activityOutputId(activity) === outputId);
+        if (!visible) {
+            throw new Error(`Bash output ${outputId} is not part of Host Turn ${turnId}.`);
+        }
+        return {
+            outputId: output.outputId,
+            activityId: output.activityId,
+            processId: output.processId,
+            command: output.command,
+            output: output.output,
+            status: output.status,
+            ...(output.exitCode !== undefined ? { exitCode: output.exitCode } : {}),
+            ...(output.signal !== undefined ? { signal: output.signal } : {}),
+            timedOut: output.timedOut,
+            startedAt: output.startedAt,
+            ...(output.finishedAt !== undefined ? { finishedAt: output.finishedAt } : {}),
+        };
+    }
+    requireTurn(turnId) {
+        if (!this.turns.get(turnId))
+            throw new Error(`Unknown Host Turn: ${turnId}.`);
+    }
+}
+function toSummary(record) {
+    const request = asRecord(record.request);
+    const result = asRecord(record.result);
+    const structured = asRecord(result?.structuredContent);
+    const directProcessId = numberField(result, "processId") ?? numberField(request, "processId");
+    const processId = numberField(structured, "processId") ?? directProcessId;
+    const outputId = stringField(structured, "outputId")
+        ?? stringField(result, "outputId")
+        ?? stringField(request, "outputId");
+    const command = stringField(request, "command") ?? stringField(request, "cmd");
+    const durationMs = numberField(structured, "wallTimeMs")
+        ?? numberField(result, "wallTimeMs")
+        ?? elapsedMs(record.startedAt, record.updatedAt, record.state);
+    const bashLike = record.tool === "bash" || record.tool === "exec_command" || record.tool === "bash_result";
+    return {
+        activityId: record.activityId,
+        tool: record.tool,
+        kind: activityKind(record.tool),
+        status: activityStatus(record.state),
+        state: record.state,
+        title: activityTitle(record.tool),
+        target: activityTarget(record, request, result, structured),
+        detailAvailable: record.tool !== "rename" && record.tool !== "delete",
+        ...(record.workspace.id ? { workspaceId: record.workspace.id } : {}),
+        ...(processId !== undefined ? { processId } : {}),
+        ...(outputId !== undefined ? { outputId } : {}),
+        ...(bashLike && command !== undefined ? { commandLength: command.length } : {}),
+        ...(bashLike ? { bashPhase: bashPhase(record.state) } : {}),
+        startedAt: record.startedAt,
+        ...(record.state !== "executing" ? { finishedAt: record.updatedAt } : {}),
+        ...(durationMs !== undefined ? { durationMs } : {}),
+    };
+}
+function activityKind(tool) {
+    if (tool === "read")
+        return "read";
+    if (tool === "write")
+        return "write";
+    if (tool === "edit" || tool === "apply_patch")
+        return "edit";
+    if (tool === "rename")
+        return "rename";
+    if (tool === "delete")
+        return "delete";
+    if (tool === "bash_result")
+        return "shell-result";
+    if (tool === "bash" || tool === "exec_command")
+        return "shell";
+    if (tool === "capability")
+        return "capability";
+    return "tool";
+}
+function activityTitle(tool) {
+    const titles = {
+        read: "Read",
+        write: "Write",
+        edit: "Edit",
+        apply_patch: "Edit",
+        rename: "Rename",
+        delete: "Delete",
+        bash: "Bash",
+        exec_command: "Command",
+        bash_result: "Bash result",
+        capability: "Capability",
+    };
+    return titles[tool] ?? tool;
+}
+function activityTarget(record, request, result, structured) {
+    if (record.tool === "bash" || record.tool === "exec_command")
+        return "Shell command";
+    if (record.tool === "bash_result") {
+        const processId = numberField(result, "processId") ?? numberField(request, "processId");
+        const exitCode = numberField(result, "exitCode");
+        const signal = stringField(result, "signal");
+        const timedOut = booleanField(result, "timedOut");
+        const outcome = timedOut
+            ? "timed out"
+            : signal
+                ? `signal ${signal}`
+                : exitCode !== undefined
+                    ? `exit ${exitCode}`
+                    : record.state === "failed"
+                        ? "failed"
+                        : "completed";
+        return `Process ${processId ?? "?"} · ${outcome}`;
+    }
+    if (record.tool === "capability") {
+        const name = stringField(request, "name") ?? "capability";
+        const action = stringField(request, "action") ?? "run";
+        return `${name} · ${action}`;
+    }
+    if (record.tool === "rename") {
+        const from = stringField(request, "path")
+            ?? stringField(request, "from")
+            ?? stringField(request, "source");
+        const to = stringField(request, "newPath")
+            ?? stringField(request, "to")
+            ?? stringField(request, "destination");
+        return [from, to].filter((value) => Boolean(value)).join(" → ") || "path";
+    }
+    const path = stringField(request, "path");
+    if (path)
+        return path;
+    if (record.tool === "apply_patch") {
+        const files = arrayField(structured, "files");
+        const first = asRecord(files?.[0]);
+        const firstPath = stringField(first, "path");
+        if (firstPath)
+            return files && files.length > 1 ? `${firstPath} +${files.length - 1}` : firstPath;
+    }
+    return record.tool;
+}
+function activityStatus(state) {
+    if (state === "executing")
+        return "working";
+    if (state === "failed" || state === "blocked")
+        return "error";
+    return "done";
+}
+function bashPhase(state) {
+    if (state === "executing")
+        return "executing";
+    if (state === "returned")
+        return "returned";
+    if (state === "failed" || state === "blocked")
+        return "error";
+    return "done";
+}
+function aggregateState(activities) {
+    if (activities.length === 0)
+        return "working";
+    if (activities.some((activity) => activity.status === "working"))
+        return "working";
+    if (activities.some((activity) => activity.status === "error"))
+        return "error";
+    return "done";
+}
+function activityOutputId(activity) {
+    const request = asRecord(activity.request);
+    const result = asRecord(activity.result);
+    const structured = asRecord(result?.structuredContent);
+    return stringField(request, "outputId")
+        ?? stringField(result, "outputId")
+        ?? stringField(structured, "outputId");
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringField(record, key) {
+    return typeof record?.[key] === "string" ? record[key] : undefined;
+}
+function numberField(record, key) {
+    return typeof record?.[key] === "number" ? record[key] : undefined;
+}
+function booleanField(record, key) {
+    return typeof record?.[key] === "boolean" ? record[key] : undefined;
+}
+function arrayField(record, key) {
+    return Array.isArray(record?.[key]) ? record[key] : undefined;
+}
+function elapsedMs(startedAt, updatedAt, state) {
+    if (state === "executing")
+        return undefined;
+    const start = Date.parse(startedAt);
+    const end = Date.parse(updatedAt);
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return undefined;
+    return Math.max(0, end - start);
+}

package/dist/db/migrations.js

@@ -44,6 +44,11 @@ const migrations = [
         name: "bash-output-audit",
         up: migrateBashOutputAudit,
     },
+    {
+        version: 10,
+        name: "activity-host-turns",
+        up: migrateActivityHostTurns,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -296,6 +301,21 @@ function migrateBashOutputAudit(sqlite) {
       on bash_output_chunks(output_id, sequence);
   `);
 }
+function migrateActivityHostTurns(sqlite) {
+    sqlite.exec(`
+    create table if not exists activity_host_turns (
+      turn_id text primary key,
+      conversation_scope_id text,
+      created_at text not null
+    );
+
+    create index if not exists activity_host_turns_conversation_idx
+      on activity_host_turns(conversation_scope_id, created_at desc);
+
+    create index if not exists activity_host_turns_created_idx
+      on activity_host_turns(created_at desc);
+  `);
+}
 function addColumnIfMissing(sqlite, table, column, definition) {
     const columns = sqlite.prepare(`pragma table_info(${table})`).all();
     if (columns.some((existingColumn) => existingColumn.name === column))

package/dist/db/schema.js

@@ -97,6 +97,14 @@ export const activityAuditEvents = sqliteTable("activity_audit_events", {
     index("activity_audit_events_turn_idx").on(table.turnId, table.createdAt),
     index("activity_audit_events_created_idx").on(table.createdAt),
 ]);
+export const activityHostTurns = sqliteTable("activity_host_turns", {
+    turnId: text("turn_id").primaryKey(),
+    conversationScopeId: text("conversation_scope_id"),
+    createdAt: text("created_at").notNull(),
+}, (table) => [
+    index("activity_host_turns_conversation_idx").on(table.conversationScopeId, table.createdAt),
+    index("activity_host_turns_created_idx").on(table.createdAt),
+]);
 export const bashOutputStreams = sqliteTable("bash_output_streams", {
     id: text("id").primaryKey(),
     activityId: text("activity_id").notNull(),

package/dist/lsp/test-support/server-fixture.js

@@ -6,7 +6,9 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { ActivityAuditStore } from "../../activity/audit-store.js";
 import { BashOutputStore } from "../../activity/bash-output-store.js";
+import { HostTurnStore } from "../../activity/host-turn-store.js";
 import { ActivityLifecycle } from "../../activity/lifecycle.js";
+import { ActivityQueryService } from "../../activity/query-service.js";
 import { loadConfig } from "../../config.js";
 import { createReviewCheckpointManager } from "../../review-checkpoints.js";
 import { ProcessManager } from "../../process-sessions.js";
@@ -37,10 +39,14 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
     const workspaces = new WorkspaceRegistry(config, store);
     const auditStore = new ActivityAuditStore(stateDir);
     const bashOutputStore = new BashOutputStore(stateDir);
+    const hostTurnStore = new HostTurnStore(stateDir);
+    const activityQueries = new ActivityQueryService(hostTurnStore, auditStore, bashOutputStore);
     const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
-    const activityLifecycle = new ActivityLifecycle(auditStore);
+    const activityLifecycle = new ActivityLifecycle(auditStore, {
+        turnIdForConversation: (conversationScopeId) => activityQueries.currentTurnId(conversationScopeId),
+    });
     const codeIntelligence = new CodeIntelligenceManager(config, options.codeIntelligenceOptions);
-    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore);
+    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
     const client = new Client({ name: "forgerelay-code-intelligence-test-client", version: "1.0.0" });
     await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
@@ -53,6 +59,7 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         await server.close();
         await codeIntelligence.shutdown();
         processSessions.shutdown();
+        hostTurnStore.close();
         bashOutputStore.close();
         auditStore.close();
         store.close();

package/dist/server.js

@@ -17,7 +17,10 @@ import * as z from "zod/v4";
 import { applyPatch } from "./apply-patch.js";
 import { ActivityAuditStore } from "./activity/audit-store.js";
 import { BashOutputStore } from "./activity/bash-output-store.js";
+import { HostTurnStore } from "./activity/host-turn-store.js";
+import { registerActivityQueryTools } from "./activity/mcp-query-tools.js";
 import { ActivityLifecycle, } from "./activity/lifecycle.js";
+import { ActivityQueryService } from "./activity/query-service.js";
 import { buildCapabilityFingerprint } from "./capabilities.js";
 import { CapabilityError, createCapabilityRegistry, } from "./capability-registry.js";
 import { deletePath, renamePath } from "./file-mutations.js";
@@ -992,7 +995,7 @@ function registerProcessTools(server, config, workspaces, processSessions, hooks
         });
     });
 }
-export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore) {
+export function createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries) {
     const toolDescriptions = buildToolDescriptions(config);
     const hooks = new HookRunner(config.hooks, config.logging, process.env, (workspaceId, result) => attachCompletedProcessNotices(processSessions, workspaceId, result, (snapshot) => recordBashCompletion(activityLifecycle, bashOutputStore, snapshot.outputId)));
     const incomingArtifactRegistry = new IncomingArtifactAdapterRegistry(incomingArtifactAdapters);
@@ -1465,6 +1468,7 @@ export function createMcpServer(config, workspaces, reviewCheckpoints, processSe
             },
         }, hookReports));
     });
+    registerActivityQueryTools(server, activityQueries);
     registerAppTool(server, toolNames.capability, {
         title: "Use optional capability",
         description: "Describe or run one optional ForgeRelay capability advertised by open_workspace. Use describe when the capability contract is unfamiliar, then read its advertised guide if needed. Run dispatches only explicitly registered capabilities; it cannot invoke arbitrary shell commands, URLs, or methods.",
@@ -2453,8 +2457,12 @@ export function createServer(config = loadConfig(), options = {}) {
     const workspaceStore = createWorkspaceStore(config.stateDir);
     const workspaces = new WorkspaceRegistry(config, workspaceStore);
     const activityAuditStore = new ActivityAuditStore(config.stateDir);
-    const activityLifecycle = new ActivityLifecycle(activityAuditStore);
     const bashOutputStore = new BashOutputStore(config.stateDir);
+    const hostTurnStore = new HostTurnStore(config.stateDir);
+    const activityQueries = new ActivityQueryService(hostTurnStore, activityAuditStore, bashOutputStore);
+    const activityLifecycle = new ActivityLifecycle(activityAuditStore, {
+        turnIdForConversation: (conversationScopeId) => activityQueries.currentTurnId(conversationScopeId),
+    });
     const reviewCheckpoints = createReviewCheckpointManager();
     const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
     const codeIntelligence = new CodeIntelligenceManager(config);
@@ -2641,7 +2649,7 @@ export function createServer(config = loadConfig(), options = {}) {
                         });
                     }
                 };
-                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore);
+                const server = createMcpServer(config, workspaces, reviewCheckpoints, processSessions, localAgentProviders, incomingArtifactAdapters, codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
                 await server.connect(transport);
             }
             else {
@@ -2673,6 +2681,7 @@ export function createServer(config = loadConfig(), options = {}) {
                 processSessions.shutdown();
                 await codeIntelligence.shutdown();
                 oauthProvider.close();
+                hostTurnStore.close();
                 bashOutputStore.close();
                 activityAuditStore.close();
                 workspaceStore.close?.();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akira-tl/forgerelay",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Local development control plane for MCP coding agents.",
   "type": "module",
   "homepage": "https://github.com/Akira-TL/forgerelay#readme",
@@ -44,7 +44,7 @@
     "release:parity": "node scripts/release-parity.mjs",
     "postinstall": "node scripts/fix-node-pty-permissions.mjs",
     "start": "node dist/cli.js serve",
-    "test": "node --test scripts/release-proof.test.mjs && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/bash-output-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
+    "test": "node --test scripts/release-proof.test.mjs && tsx src/config.test.ts && tsx src/lsp/language-server-config.test.ts && tsx src/lsp/normalization/hover.test.ts && tsx src/lsp/references.server.test.ts && tsx src/lsp/operations/document-symbols.server.test.ts && tsx src/lsp/operations/workspace-symbols.server.test.ts && tsx src/lsp/operations/diagnostics-push.server.test.ts && tsx src/lsp/operations/diagnostics-pull.server.test.ts && tsx src/lsp/operations/request-hardening.server.test.ts && tsx src/lsp/operations/recovery.server.test.ts && tsx src/lsp/operations/lifecycle.server.test.ts && tsx src/lsp/runtime/semantic-requests.test.ts && tsx src/logger.test.ts && tsx src/proxy-trust.test.ts && tsx src/mcp-app-template.test.ts && tsx src/hooks.test.ts && tsx src/capability-registry.test.ts && tsx src/mcp/server-instructions.test.ts && tsx src/request-meta.test.ts && tsx src/incoming-artifacts.test.ts && tsx src/artifact-download.test.ts && tsx src/ui/card-types.test.ts && tsx src/ui/patch-display.test.ts && tsx src/ui/tool-display.test.ts && tsx src/apply-patch.test.ts && tsx src/process-platform.test.ts && tsx src/process-sessions.test.ts && tsx src/mcp-sessions.test.ts && tsx src/server-shutdown.test.ts && tsx src/local-agent-runtime.test.ts && tsx src/local-agent-adapters.test.ts && tsx src/local-agent-availability.test.ts && tsx src/local-agent-profiles.test.ts && tsx src/local-agent-targets.test.ts && tsx src/local-agent-store.test.ts && tsx src/roots.test.ts && tsx src/file-mutations.test.ts && tsx src/skills.test.ts && tsx src/workspace-store.test.ts && tsx src/activity/audit-store.test.ts && tsx src/activity/bash-output-store.test.ts && tsx src/activity/lifecycle.test.ts && tsx src/activity/query-service.test.ts && tsx src/workspaces.test.ts && tsx src/workspace-conversation.test.ts && tsx src/review-checkpoints.test.ts && tsx src/lsp/code-intelligence.server.test.ts && tsx src/server.test.ts && tsx src/oauth-store.test.ts && tsx src/cli.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "release:check": "node scripts/release-version.mjs check",
     "release:tag-check": "node scripts/release-version.mjs tag",