@pcircle/footprint 1.5.0 → 1.6.0

package/dist/src/tools/reingest-session.js

@@ -0,0 +1,43 @@
+import * as z from "zod";
+import { reingestSessionHistory } from "../ingestion/index.js";
+import { formatSuccessResponse } from "../lib/tool-response.js";
+import { wrapToolHandler } from "../lib/tool-wrapper.js";
+import { sessionDetailUiMetadata } from "./session-ui-metadata.js";
+export const reingestSessionSchema = {
+    inputSchema: {
+        id: z.string().describe("ID of the recorded session to reingest"),
+    },
+    outputSchema: {
+        sessionId: z.string(),
+        artifactsCreated: z.number(),
+        narrativesCreated: z.number(),
+        decisionsCreated: z.number(),
+    },
+};
+export const reingestSessionMetadata = {
+    title: "Reingest Session",
+    description: "Regenerate deterministic artifacts, narratives, and decisions from preserved raw session history.",
+    ...sessionDetailUiMetadata,
+};
+export function createReingestSessionHandler(db) {
+    return wrapToolHandler("reingest-session", "Verify the session exists, is no longer running, and that raw session history is available.", async (params) => {
+        const session = db.findSessionById(params.id);
+        if (!session) {
+            throw new Error(`Session not found: ${params.id}`);
+        }
+        if (session.status === "running") {
+            throw new Error(`Session is still running and cannot be reingested yet: ${params.id}`);
+        }
+        const summary = reingestSessionHistory(db, params.id);
+        return formatSuccessResponse("Session reingested successfully", {
+            Session: params.id,
+            Artifacts: summary.artifactsCreated,
+            Narratives: summary.narrativesCreated,
+            Decisions: summary.decisionsCreated,
+        }, {
+            sessionId: params.id,
+            ...summary,
+        });
+    });
+}
+//# sourceMappingURL=reingest-session.js.map

package/dist/src/tools/reingest-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reingest-session.js","sourceRoot":"","sources":["../../../src/tools/reingest-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,WAAW,EAAE;QACX,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wCAAwC,CAAC;KAClE;IACD,YAAY,EAAE;QACZ,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;QACrB,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;QAC5B,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE;QAC7B,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE;KAC7B;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,KAAK,EAAE,kBAAkB;IACzB,WAAW,EACT,mGAAmG;IACrG,GAAG,uBAAuB;CAC3B,CAAC;AAEF,MAAM,UAAU,4BAA4B,CAAC,EAAoB;IAC/D,OAAO,eAAe,CACpB,kBAAkB,EAClB,6FAA6F,EAC7F,KAAK,EAAE,MAAsB,EAAE,EAAE;QAC/B,MAAM,OAAO,GAAG,EAAE,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAC9C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,sBAAsB,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,0DAA0D,MAAM,CAAC,EAAE,EAAE,CACtE,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,sBAAsB,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QACtD,OAAO,qBAAqB,CAC1B,iCAAiC,EACjC;YACE,OAAO,EAAE,MAAM,CAAC,EAAE;YAClB,SAAS,EAAE,OAAO,CAAC,gBAAgB;YACnC,UAAU,EAAE,OAAO,CAAC,iBAAiB;YACrC,SAAS,EAAE,OAAO,CAAC,gBAAgB;SACpC,EACD;YACE,SAAS,EAAE,MAAM,CAAC,EAAE;YACpB,GAAG,OAAO;SACX,CACF,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/src/tools/reject-context-link.d.ts

@@ -0,0 +1,58 @@
+import * as z from "zod";
+import type { EvidenceDatabase } from "../lib/storage/index.js";
+export declare const rejectContextLinkSchema: {
+    inputSchema: {
+        sessionId: z.ZodString;
+        contextId: z.ZodString;
+    };
+    outputSchema: {
+        action: z.ZodEnum<{
+            rejected: "rejected";
+            merged: "merged";
+            confirmed: "confirmed";
+            moved: "moved";
+            split: "split";
+            preferred: "preferred";
+        }>;
+        context: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            workspaceKey: z.ZodString;
+            latestSessionId: z.ZodString;
+            latestSessionLabel: z.ZodString;
+            latestStartedAt: z.ZodString;
+            latestEndedAt: z.ZodNullable<z.ZodString>;
+            sessionCount: z.ZodNumber;
+            hosts: z.ZodArray<z.ZodEnum<{
+                claude: "claude";
+                gemini: "gemini";
+                codex: "codex";
+            }>>;
+            statuses: z.ZodArray<z.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                interrupted: "interrupted";
+            }>>;
+            confidence: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            confidenceScore: z.ZodNumber;
+            signals: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        affectedSessionIds: z.ZodArray<z.ZodString>;
+        contextId: z.ZodNullable<z.ZodString>;
+        mergedFromContextId: z.ZodNullable<z.ZodString>;
+    };
+};
+export declare const rejectContextLinkMetadata: {
+    title: string;
+    description: string;
+};
+export declare function createRejectContextLinkHandler(db: EvidenceDatabase): (params: {
+    sessionId: string;
+    contextId: string;
+}) => Promise<import("../lib/tool-response.js").ToolResponse<import("../lib/context-memory.js").ContextLinkMutationResult>>;
+//# sourceMappingURL=reject-context-link.d.ts.map

package/dist/src/tools/reject-context-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject-context-link.d.ts","sourceRoot":"","sources":["../../../src/tools/reject-context-link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;CAIrC,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,gBAAgB;eAInC,MAAM;eAAa,MAAM;4HAiBxD"}

package/dist/src/tools/reject-context-link.js

@@ -0,0 +1,26 @@
+import * as z from "zod";
+import { rejectContextLink } from "../lib/context-memory.js";
+import { formatSuccessResponse } from "../lib/tool-response.js";
+import { wrapToolHandler } from "../lib/tool-wrapper.js";
+import { contextMutationSchema } from "./context-schemas.js";
+export const rejectContextLinkSchema = {
+    inputSchema: {
+        sessionId: z.string().min(1, "sessionId is required"),
+        contextId: z.string().min(1, "contextId is required"),
+    },
+    outputSchema: contextMutationSchema.shape,
+};
+export const rejectContextLinkMetadata = {
+    title: "Reject Context Link",
+    description: "Reject a suggested session/context pair so Footprint does not keep proposing the same incorrect link.",
+};
+export function createRejectContextLinkHandler(db) {
+    return wrapToolHandler("reject-context-link", "Persist a negative correction for a suggested session/context pair.", async (params) => {
+        const result = rejectContextLink(db, params.sessionId.trim(), params.contextId.trim());
+        return formatSuccessResponse("Context link rejected successfully", {
+            Session: result.affectedSessionIds[0] ?? "unknown",
+            Context: result.contextId ?? "unknown",
+        }, result);
+    });
+}
+//# sourceMappingURL=reject-context-link.js.map

package/dist/src/tools/reject-context-link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject-context-link.js","sourceRoot":"","sources":["../../../src/tools/reject-context-link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,WAAW,EAAE;QACX,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,uBAAuB,CAAC;QACrD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,uBAAuB,CAAC;KACtD;IACD,YAAY,EAAE,qBAAqB,CAAC,KAAK;CAC1C,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,KAAK,EAAE,qBAAqB;IAC5B,WAAW,EACT,uGAAuG;CAC1G,CAAC;AAEF,MAAM,UAAU,8BAA8B,CAAC,EAAoB;IACjE,OAAO,eAAe,CACpB,qBAAqB,EACrB,qEAAqE,EACrE,KAAK,EAAE,MAAgD,EAAE,EAAE;QACzD,MAAM,MAAM,GAAG,iBAAiB,CAC9B,EAAE,EACF,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,EACvB,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,CACxB,CAAC;QAEF,OAAO,qBAAqB,CAC1B,oCAAoC,EACpC;YACE,OAAO,EAAE,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,SAAS;YAClD,OAAO,EAAE,MAAM,CAAC,SAAS,IAAI,SAAS;SACvC,EACD,MAAM,CACP,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/src/tools/resolve-context.d.ts

@@ -0,0 +1,287 @@
+import * as z from "zod";
+import type { EvidenceDatabase, SessionHost } from "../lib/storage/index.js";
+export declare const resolveContextSchema: {
+    inputSchema: {
+        sessionId: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        host: z.ZodOptional<z.ZodEnum<{
+            claude: "claude";
+            gemini: "gemini";
+            codex: "codex";
+        }>>;
+    };
+    outputSchema: {
+        mode: z.ZodEnum<{
+            preferred: "preferred";
+            linked: "linked";
+            suggested: "suggested";
+            none: "none";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        cwd: z.ZodNullable<z.ZodString>;
+        confirmationRequired: z.ZodBoolean;
+        recommendedAction: z.ZodEnum<{
+            none: "none";
+            "use-linked": "use-linked";
+            "use-preferred": "use-preferred";
+            "confirm-existing": "confirm-existing";
+            "create-new-context": "create-new-context";
+            "choose-candidate": "choose-candidate";
+        }>;
+        linkedContextId: z.ZodNullable<z.ZodString>;
+        currentContext: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            workspaceKey: z.ZodString;
+            latestSessionId: z.ZodString;
+            latestSessionLabel: z.ZodString;
+            latestStartedAt: z.ZodString;
+            latestEndedAt: z.ZodNullable<z.ZodString>;
+            sessionCount: z.ZodNumber;
+            hosts: z.ZodArray<z.ZodEnum<{
+                claude: "claude";
+                gemini: "gemini";
+                codex: "codex";
+            }>>;
+            statuses: z.ZodArray<z.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                interrupted: "interrupted";
+            }>>;
+            confidence: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            confidenceScore: z.ZodNumber;
+            signals: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        briefing: z.ZodNullable<z.ZodObject<{
+            context: z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                workspaceKey: z.ZodString;
+                latestSessionId: z.ZodString;
+                latestSessionLabel: z.ZodString;
+                latestStartedAt: z.ZodString;
+                latestEndedAt: z.ZodNullable<z.ZodString>;
+                sessionCount: z.ZodNumber;
+                hosts: z.ZodArray<z.ZodEnum<{
+                    claude: "claude";
+                    gemini: "gemini";
+                    codex: "codex";
+                }>>;
+                statuses: z.ZodArray<z.ZodEnum<{
+                    running: "running";
+                    completed: "completed";
+                    failed: "failed";
+                    interrupted: "interrupted";
+                }>>;
+                confidence: z.ZodEnum<{
+                    high: "high";
+                    medium: "medium";
+                    low: "low";
+                }>;
+                confidenceScore: z.ZodNumber;
+                signals: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            currentTruth: z.ZodObject<{
+                summary: z.ZodString;
+                latestSessionId: z.ZodString;
+                latestSessionLabel: z.ZodString;
+                latestSummaryNarrative: z.ZodNullable<z.ZodString>;
+                latestHandoff: z.ZodNullable<z.ZodString>;
+                activeBlockers: z.ZodArray<z.ZodString>;
+                openQuestions: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            activeDecisions: z.ZodArray<z.ZodObject<{
+                decisionId: z.ZodString;
+                topic: z.ZodString;
+                sessionId: z.ZodString;
+                sessionLabel: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodString;
+                rationale: z.ZodNullable<z.ZodString>;
+                status: z.ZodEnum<{
+                    proposed: "proposed";
+                    accepted: "accepted";
+                    rejected: "rejected";
+                    open: "open";
+                }>;
+                createdAt: z.ZodString;
+            }, z.core.$strip>>;
+            supersededDecisions: z.ZodArray<z.ZodObject<{
+                decisionId: z.ZodString;
+                topic: z.ZodString;
+                sessionId: z.ZodString;
+                sessionLabel: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodString;
+                rationale: z.ZodNullable<z.ZodString>;
+                status: z.ZodEnum<{
+                    proposed: "proposed";
+                    accepted: "accepted";
+                    rejected: "rejected";
+                    open: "open";
+                }>;
+                createdAt: z.ZodString;
+                supersededByDecisionId: z.ZodNullable<z.ZodString>;
+                supersededByTitle: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            changeLog: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    "decision-updated": "decision-updated";
+                    "context-refreshed": "context-refreshed";
+                }>;
+                summary: z.ZodString;
+                sessionId: z.ZodNullable<z.ZodString>;
+                sessionLabel: z.ZodNullable<z.ZodString>;
+                createdAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            sessions: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                host: z.ZodEnum<{
+                    claude: "claude";
+                    gemini: "gemini";
+                    codex: "codex";
+                }>;
+                status: z.ZodEnum<{
+                    running: "running";
+                    completed: "completed";
+                    failed: "failed";
+                    interrupted: "interrupted";
+                }>;
+                startedAt: z.ZodString;
+                endedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            trends: z.ZodArray<z.ZodObject<{
+                groupBy: z.ZodEnum<{
+                    issue: "issue";
+                    family: "family";
+                }>;
+                issueKey: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodNullable<z.ZodString>;
+                relatedIssueKeys: z.ZodArray<z.ZodString>;
+                blockerCategory: z.ZodString;
+                blockerState: z.ZodEnum<{
+                    active: "active";
+                    resolved: "resolved";
+                }>;
+                remediationState: z.ZodEnum<{
+                    unresolved: "unresolved";
+                    recovered: "recovered";
+                    regressed: "regressed";
+                    stable: "stable";
+                }>;
+                remediationSummary: z.ZodString;
+                latestOutcome: z.ZodString;
+                latestFailureAt: z.ZodNullable<z.ZodString>;
+                latestSuccessAt: z.ZodNullable<z.ZodString>;
+                lastSeenAt: z.ZodString;
+                attemptCount: z.ZodNumber;
+                sessionCount: z.ZodNumber;
+                failedAttempts: z.ZodNumber;
+                succeededAttempts: z.ZodNumber;
+                otherAttempts: z.ZodNumber;
+                hosts: z.ZodArray<z.ZodEnum<{
+                    claude: "claude";
+                    gemini: "gemini";
+                    codex: "codex";
+                }>>;
+                statuses: z.ZodArray<z.ZodEnum<{
+                    running: "running";
+                    completed: "completed";
+                    failed: "failed";
+                    interrupted: "interrupted";
+                }>>;
+                sessions: z.ZodArray<z.ZodObject<{
+                    sessionId: z.ZodString;
+                    label: z.ZodString;
+                    host: z.ZodEnum<{
+                        claude: "claude";
+                        gemini: "gemini";
+                        codex: "codex";
+                    }>;
+                    status: z.ZodEnum<{
+                        running: "running";
+                        completed: "completed";
+                        failed: "failed";
+                        interrupted: "interrupted";
+                    }>;
+                    startedAt: z.ZodString;
+                    lastAttemptAt: z.ZodString;
+                    attempts: z.ZodNumber;
+                    latestOutcome: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            handoff: z.ZodObject<{
+                summary: z.ZodObject<{
+                    groupBy: z.ZodEnum<{
+                        issue: "issue";
+                        family: "family";
+                    }>;
+                    headline: z.ZodString;
+                    matchingSessions: z.ZodNumber;
+                    matchingHosts: z.ZodArray<z.ZodEnum<{
+                        claude: "claude";
+                        gemini: "gemini";
+                        codex: "codex";
+                    }>>;
+                    statuses: z.ZodArray<z.ZodEnum<{
+                        running: "running";
+                        completed: "completed";
+                        failed: "failed";
+                        interrupted: "interrupted";
+                    }>>;
+                    totalTrends: z.ZodNumber;
+                    blockingTrends: z.ZodNumber;
+                    recoveredTrends: z.ZodNumber;
+                    regressedTrends: z.ZodNumber;
+                    unresolvedQuestions: z.ZodNumber;
+                    latestSessionId: z.ZodNullable<z.ZodString>;
+                    latestSessionLabel: z.ZodNullable<z.ZodString>;
+                    latestStartedAt: z.ZodNullable<z.ZodString>;
+                }, z.core.$strip>;
+                followUps: z.ZodArray<z.ZodString>;
+                blockers: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            markdown: z.ZodString;
+        }, z.core.$strip>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                "existing-context": "existing-context";
+                "new-context": "new-context";
+            }>;
+            contextId: z.ZodNullable<z.ZodString>;
+            label: z.ZodString;
+            workspaceKey: z.ZodString;
+            confidence: z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>;
+            confidenceScore: z.ZodNumber;
+            reasons: z.ZodArray<z.ZodString>;
+            sessionIds: z.ZodArray<z.ZodString>;
+            latestSessionId: z.ZodNullable<z.ZodString>;
+            latestSessionLabel: z.ZodNullable<z.ZodString>;
+            preferred: z.ZodBoolean;
+            confirmationRequired: z.ZodBoolean;
+        }, z.core.$strip>>;
+    };
+};
+export declare const resolveContextMetadata: {
+    title: string;
+    description: string;
+};
+export declare function createResolveContextHandler(db: EvidenceDatabase): (params: {
+    sessionId?: string;
+    cwd?: string;
+    title?: string;
+    host?: SessionHost;
+}) => Promise<import("../lib/tool-response.js").ToolResponse<import("../lib/context-memory.js").ContextResolution>>;
+//# sourceMappingURL=resolve-context.d.ts.map

package/dist/src/tools/resolve-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-context.d.ts","sourceRoot":"","sources":["../../../src/tools/resolve-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG7E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQhC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;CAIlC,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,gBAAgB;gBAK9C,MAAM;UACZ,MAAM;YACJ,MAAM;WACP,WAAW;oHAqBvB"}

package/dist/src/tools/resolve-context.js

@@ -0,0 +1,35 @@
+import * as z from "zod";
+import { resolveContext } from "../lib/context-memory.js";
+import { formatSuccessResponse } from "../lib/tool-response.js";
+import { wrapToolHandler } from "../lib/tool-wrapper.js";
+import { contextResolutionSchema, sessionHostEnum } from "./context-schemas.js";
+export const resolveContextSchema = {
+    inputSchema: {
+        sessionId: z.string().optional(),
+        cwd: z.string().optional(),
+        title: z.string().optional(),
+        host: sessionHostEnum.optional(),
+    },
+    outputSchema: contextResolutionSchema.shape,
+};
+export const resolveContextMetadata = {
+    title: "Resolve Context",
+    description: "Resolve the most likely Footprint context for a session or workspace. Returns candidates and whether the client should ask the user to confirm.",
+};
+export function createResolveContextHandler(db) {
+    return wrapToolHandler("resolve-context", "Provide sessionId or cwd. If confirmationRequired is true, the client should ask the user instead of assuming the correct context.", async (params) => {
+        const result = resolveContext(db, {
+            sessionId: params.sessionId?.trim() || undefined,
+            cwd: params.cwd?.trim() || undefined,
+            title: params.title?.trim() || undefined,
+            host: params.host,
+        });
+        return formatSuccessResponse("Context resolution completed", {
+            Mode: result.mode,
+            ConfirmationRequired: result.confirmationRequired ? "yes" : "no",
+            RecommendedAction: result.recommendedAction,
+            Candidates: result.candidates.length,
+        }, result);
+    });
+}
+//# sourceMappingURL=resolve-context.js.map

package/dist/src/tools/resolve-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-context.js","sourceRoot":"","sources":["../../../src/tools/resolve-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEhF,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,WAAW,EAAE;QACX,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAChC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC1B,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC5B,IAAI,EAAE,eAAe,CAAC,QAAQ,EAAE;KACjC;IACD,YAAY,EAAE,uBAAuB,CAAC,KAAK;CAC5C,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,KAAK,EAAE,iBAAiB;IACxB,WAAW,EACT,iJAAiJ;CACpJ,CAAC;AAEF,MAAM,UAAU,2BAA2B,CAAC,EAAoB;IAC9D,OAAO,eAAe,CACpB,iBAAiB,EACjB,oIAAoI,EACpI,KAAK,EAAE,MAKN,EAAE,EAAE;QACH,MAAM,MAAM,GAAG,cAAc,CAAC,EAAE,EAAE;YAChC,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,SAAS;YAChD,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,SAAS;YACpC,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,SAAS;YACxC,IAAI,EAAE,MAAM,CAAC,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,qBAAqB,CAC1B,8BAA8B,EAC9B;YACE,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,oBAAoB,EAAE,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI;YAChE,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;YAC3C,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,MAAM;SACrC,EACD,MAAM,CACP,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/src/tools/search-history.d.ts

@@ -0,0 +1,86 @@
+import * as z from "zod";
+import type { EvidenceDatabase, SessionHost, SessionStatus } from "../lib/storage/index.js";
+export declare const searchHistorySchema: {
+    inputSchema: {
+        query: z.ZodString;
+        host: z.ZodOptional<z.ZodEnum<{
+            claude: "claude";
+            gemini: "gemini";
+            codex: "codex";
+        }>>;
+        status: z.ZodOptional<z.ZodEnum<{
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+    };
+    outputSchema: {
+        query: z.ZodString;
+        filters: z.ZodObject<{
+            host: z.ZodOptional<z.ZodEnum<{
+                claude: "claude";
+                gemini: "gemini";
+                codex: "codex";
+            }>>;
+            status: z.ZodOptional<z.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                interrupted: "interrupted";
+            }>>;
+        }, z.core.$strip>;
+        results: z.ZodArray<z.ZodObject<{
+            sessionId: z.ZodString;
+            host: z.ZodEnum<{
+                claude: "claude";
+                gemini: "gemini";
+                codex: "codex";
+            }>;
+            label: z.ZodString;
+            status: z.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                interrupted: "interrupted";
+            }>;
+            startedAt: z.ZodString;
+            snippets: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        total: z.ZodNumber;
+    };
+};
+export declare const searchHistoryMetadata: {
+    _meta: {
+        readonly ui: {
+            readonly resourceUri: "ui://footprint/session-dashboard.html";
+        };
+    };
+    title: string;
+    description: string;
+};
+export declare function createSearchHistoryHandler(db: EvidenceDatabase): (params: {
+    query: string;
+    host?: SessionHost;
+    status?: SessionStatus;
+    limit?: number;
+    offset?: number;
+}) => Promise<import("../lib/tool-response.js").ToolResponse<{
+    query: string;
+    filters: {
+        host: SessionHost | undefined;
+        status: SessionStatus | undefined;
+    };
+    results: {
+        sessionId: string;
+        host: SessionHost;
+        label: string;
+        status: SessionStatus;
+        startedAt: string;
+        snippets: string[];
+    }[];
+    total: number;
+}>>;
+//# sourceMappingURL=search-history.d.ts.map

package/dist/src/tools/search-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-history.d.ts","sourceRoot":"","sources":["../../../src/tools/search-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAKzB,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,aAAa,EACd,MAAM,yBAAyB,CAAC;AAcjC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC/B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;CAKjC,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,gBAAgB;WAKlD,MAAM;WACN,WAAW;aACT,aAAa;YACd,MAAM;aACL,MAAM;;;;;;;;;;;;;;;;IA0DpB"}

package/dist/src/tools/search-history.js

@@ -0,0 +1,103 @@
+import * as z from "zod";
+import { collectSessionSearchableText } from "../lib/session-filters.js";
+import { getSessionLabel } from "../lib/session-history.js";
+import { formatSuccessResponse } from "../lib/tool-response.js";
+import { wrapToolHandler } from "../lib/tool-wrapper.js";
+import { sessionDashboardUiMetadata } from "./session-ui-metadata.js";
+function collectSnippets(textNeedle, haystack, limit = 3) {
+    const loweredNeedle = textNeedle.toLowerCase();
+    return haystack
+        .filter((item) => item.toLowerCase().includes(loweredNeedle))
+        .slice(0, limit);
+}
+export const searchHistorySchema = {
+    inputSchema: {
+        query: z
+            .string()
+            .describe("Text to search across sessions, messages, narratives, and decisions"),
+        host: z
+            .enum(["claude", "gemini", "codex"])
+            .optional()
+            .describe("Optional host filter"),
+        status: z
+            .enum(["running", "completed", "failed", "interrupted"])
+            .optional()
+            .describe("Optional status filter"),
+        limit: z.number().int().positive().optional(),
+        offset: z.number().int().min(0).optional(),
+    },
+    outputSchema: {
+        query: z.string(),
+        filters: z.object({
+            host: z.enum(["claude", "gemini", "codex"]).optional(),
+            status: z
+                .enum(["running", "completed", "failed", "interrupted"])
+                .optional(),
+        }),
+        results: z.array(z.object({
+            sessionId: z.string(),
+            host: z.enum(["claude", "gemini", "codex"]),
+            label: z.string(),
+            status: z.enum(["running", "completed", "failed", "interrupted"]),
+            startedAt: z.string(),
+            snippets: z.array(z.string()),
+        })),
+        total: z.number(),
+    },
+};
+export const searchHistoryMetadata = {
+    title: "Search History",
+    description: "Search recorded session history across session metadata, transcript, artifacts, narratives, and decisions.",
+    ...sessionDashboardUiMetadata,
+};
+export function createSearchHistoryHandler(db) {
+    return wrapToolHandler("search-history", "Provide a non-empty query and optional host/status filters.", async (params) => {
+        const query = params.query.trim();
+        if (!query) {
+            throw new Error("Query must not be empty");
+        }
+        if (params.limit !== undefined && params.limit <= 0) {
+            throw new Error("Limit must be positive");
+        }
+        if (params.offset !== undefined && params.offset < 0) {
+            throw new Error("Offset cannot be negative");
+        }
+        const matchedSessions = db.querySessionsByHistory({
+            host: params.host,
+            status: params.status,
+            query,
+            limit: params.limit,
+            offset: params.offset,
+        });
+        const paginated = matchedSessions.sessions
+            .map((session) => {
+            const searchable = collectSessionSearchableText(db, session);
+            const snippets = collectSnippets(query, searchable);
+            return snippets.length > 0
+                ? {
+                    sessionId: session.id,
+                    host: session.host,
+                    label: getSessionLabel(session),
+                    status: session.status,
+                    startedAt: session.startedAt,
+                    snippets,
+                }
+                : null;
+        })
+            .filter((result) => Boolean(result));
+        return formatSuccessResponse("Session history search completed successfully", {
+            Matches: paginated.length,
+            Total: matchedSessions.total,
+            Query: query,
+        }, {
+            query,
+            filters: {
+                host: params.host,
+                status: params.status,
+            },
+            results: paginated,
+            total: matchedSessions.total,
+        });
+    });
+}
+//# sourceMappingURL=search-history.js.map