@opencode_weave/weave 0.6.1 → 0.6.3

package/README.md

@@ -9,6 +9,7 @@ Weave is a lean OpenCode plugin with multi-agent orchestration. It provides a co
 ## Table of Contents
 
 - [Overview](#overview)
+- [Documentation](#documentation)
 - [Agents](#agents)
   - [Agent Modes](#agent-modes)
   - [Agent Details](#agent-details)
@@ -47,6 +48,10 @@ Weave is a lean OpenCode plugin with multi-agent orchestration. It provides a co
 - **Tool permissions** enforced per-agent to ensure safety and prevent unauthorized file modifications.
 - **JSONC configuration** supporting comments and trailing commas with hierarchical user and project-level merging.
 
+## Documentation
+
+Visit [tryweave.io](https://tryweave.io) for more information, or head straight to the [documentation](https://tryweave.io/docs/) for detailed guides on setup, configuration, and usage.
+
 ## Agents
 
 | Agent | Role | Mode | Description |

package/dist/agents/agent-builder.d.ts

@@ -6,5 +6,19 @@ export type BuildAgentOptions = {
     categories?: CategoriesConfig;
     disabledSkills?: Set<string>;
     resolveSkills?: ResolveSkillsFn;
+    disabledAgents?: Set<string>;
 };
+/**
+ * Register name variants for a custom agent so that
+ * `stripDisabledAgentReferences` can strip its references from prompts.
+ * Does not override existing (builtin) entries.
+ */
+export declare function registerAgentNameVariants(name: string, variants?: string[]): void;
+/**
+ * Remove lines from a prompt that reference disabled agents.
+ * Only strips lines where an agent name appears as a standalone concept
+ * (e.g. "Use thread (codebase explorer)"), not incidental word matches.
+ * Uses word-boundary matching to avoid false positives.
+ */
+export declare function stripDisabledAgentReferences(prompt: string, disabled: Set<string>): string;
 export declare function buildAgent(source: AgentSource, model: string, options?: BuildAgentOptions): AgentConfig;

package/dist/agents/builtin-agents.d.ts

@@ -2,6 +2,8 @@ import type { AgentConfig } from "@opencode-ai/sdk";
 import type { AgentPromptMetadata, WeaveAgentName } from "./types";
 import type { CategoriesConfig, AgentOverrideConfig } from "../config/schema";
 import type { ResolveSkillsFn } from "./agent-builder";
+import type { ProjectFingerprint } from "../features/analytics/types";
+import type { AvailableAgent } from "./dynamic-prompt-builder";
 export interface CreateBuiltinAgentsOptions {
     disabledAgents?: string[];
     agentOverrides?: Record<string, AgentOverrideConfig>;
@@ -11,6 +13,20 @@ export interface CreateBuiltinAgentsOptions {
     availableModels?: Set<string>;
     disabledSkills?: Set<string>;
     resolveSkills?: ResolveSkillsFn;
+    /** Project fingerprint for injecting project context into agent prompts */
+    fingerprint?: ProjectFingerprint | null;
+    /** Custom agent metadata for Loom's dynamic delegation prompt */
+    customAgentMetadata?: AvailableAgent[];
 }
 export declare const AGENT_METADATA: Record<WeaveAgentName, AgentPromptMetadata>;
+/**
+ * Register metadata for a custom agent. Used by create-managers.ts
+ * to integrate custom agents into Loom's dynamic prompt builder.
+ */
+export declare function registerCustomAgentMetadata(name: string, metadata: AgentPromptMetadata): void;
+/**
+ * Get all agent metadata — builtins + registered custom agents.
+ * Returns a new merged record on each call.
+ */
+export declare function getAllAgentMetadata(): Record<string, AgentPromptMetadata>;
 export declare function createBuiltinAgents(options?: CreateBuiltinAgentsOptions): Record<string, AgentConfig>;

package/dist/agents/custom-agent-factory.d.ts

@@ -0,0 +1,24 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { CustomAgentConfig } from "../config/schema";
+import type { AgentPromptMetadata } from "./types";
+import type { ResolveSkillsFn } from "./agent-builder";
+export interface BuildCustomAgentOptions {
+    resolveSkills?: ResolveSkillsFn;
+    disabledSkills?: Set<string>;
+    availableModels?: Set<string>;
+    systemDefaultModel?: string;
+    uiSelectedModel?: string;
+    /** Base directory for resolving relative prompt_file paths */
+    configDir?: string;
+}
+/**
+ * Build an AgentConfig from a custom agent definition.
+ * Handles prompt resolution (inline, file, or skills), model resolution,
+ * and display name registration.
+ */
+export declare function buildCustomAgent(name: string, config: CustomAgentConfig, options?: BuildCustomAgentOptions): AgentConfig;
+/**
+ * Build AgentPromptMetadata for a custom agent from its config.
+ * Used to integrate custom agents into Loom's delegation table.
+ */
+export declare function buildCustomAgentMetadata(name: string, config: CustomAgentConfig): AgentPromptMetadata;

package/dist/agents/dynamic-prompt-builder.d.ts

@@ -1,4 +1,5 @@
 import type { AgentPromptMetadata } from "./types";
+import type { ProjectFingerprint } from "../features/analytics/types";
 export interface AvailableAgent {
     name: string;
     description: string;
@@ -27,3 +28,8 @@ export declare function buildWeftSection(agents: AvailableAgent[]): string;
 export declare function buildWarpSection(agents: AvailableAgent[]): string;
 export declare function buildDelegationTable(agents: AvailableAgent[]): string;
 export declare function buildCategorySkillsDelegationGuide(categories: AvailableCategory[], skills: AvailableSkill[]): string;
+/**
+ * Build a project context section from a codebase fingerprint.
+ * Returns an empty string if no fingerprint is available.
+ */
+export declare function buildProjectContextSection(fingerprint: ProjectFingerprint | null | undefined): string;

package/dist/agents/index.d.ts

@@ -1,8 +1,12 @@
-export { createBuiltinAgents, AGENT_METADATA } from "./builtin-agents";
+export { createBuiltinAgents, AGENT_METADATA, registerCustomAgentMetadata, getAllAgentMetadata } from "./builtin-agents";
 export type { CreateBuiltinAgentsOptions } from "./builtin-agents";
-export { buildAgent } from "./agent-builder";
+export { buildAgent, stripDisabledAgentReferences } from "./agent-builder";
 export type { BuildAgentOptions, ResolveSkillsFn } from "./agent-builder";
 export { resolveAgentModel, AGENT_MODEL_REQUIREMENTS } from "./model-resolution";
+export type { FallbackEntry, AgentModelRequirement, ResolveAgentModelOptions } from "./model-resolution";
+export { buildCustomAgent, buildCustomAgentMetadata } from "./custom-agent-factory";
+export type { BuildCustomAgentOptions } from "./custom-agent-factory";
+export { loadPromptFile } from "./prompt-loader";
 export * from "./dynamic-prompt-builder";
 export type { AgentMode, AgentFactory, AgentSource, AgentCategory, AgentCost, DelegationTrigger, AgentPromptMetadata, WeaveAgentName, } from "./types";
 export { isFactory, isGptModel } from "./types";

package/dist/agents/loom/index.d.ts

@@ -1,2 +1,11 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
 import type { AgentFactory } from "../types";
+import type { AvailableAgent } from "../dynamic-prompt-builder";
+import type { ProjectFingerprint } from "../../features/analytics/types";
+export { composeLoomPrompt } from "./prompt-composer";
+export type { LoomPromptOptions } from "./prompt-composer";
+/**
+ * Create a Loom agent config with optional disabled agents, fingerprint, and custom agents for prompt composition.
+ */
+export declare function createLoomAgentWithOptions(model: string, disabledAgents?: Set<string>, fingerprint?: ProjectFingerprint | null, customAgents?: AvailableAgent[]): AgentConfig;
 export declare const createLoomAgent: AgentFactory;

package/dist/agents/loom/prompt-composer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Loom prompt composer — assembles the Loom system prompt from sections,
+ * conditionally including/excluding content based on enabled agents.
+ *
+ * Default behavior (no disabled agents) produces identical output to the
+ * hardcoded LOOM_DEFAULTS.prompt string.
+ */
+import type { ProjectFingerprint } from "../../features/analytics/types";
+import type { AvailableAgent } from "../dynamic-prompt-builder";
+export interface LoomPromptOptions {
+    /** Set of disabled agent names (lowercase config keys) */
+    disabledAgents?: Set<string>;
+    /** Project fingerprint for injecting project context into the prompt */
+    fingerprint?: ProjectFingerprint | null;
+    /** Custom agent metadata for dynamic delegation sections */
+    customAgents?: AvailableAgent[];
+}
+export declare function buildRoleSection(): string;
+export declare function buildDisciplineSection(): string;
+export declare function buildSidebarTodosSection(): string;
+export declare function buildDelegationSection(disabled: Set<string>): string;
+export declare function buildDelegationNarrationSection(disabled?: Set<string>): string;
+export declare function buildPlanWorkflowSection(disabled: Set<string>): string;
+export declare function buildReviewWorkflowSection(disabled: Set<string>): string;
+export declare function buildStyleSection(): string;
+/**
+ * Build a delegation section for custom agents.
+ * Returns empty string if no enabled custom agents exist.
+ */
+export declare function buildCustomAgentDelegationSection(customAgents: AvailableAgent[], disabled: Set<string>): string;
+/**
+ * Compose the full Loom system prompt from sections.
+ * When no agents are disabled, produces identical output to LOOM_DEFAULTS.prompt.
+ */
+export declare function composeLoomPrompt(options?: LoomPromptOptions): string;

package/dist/agents/model-resolution.d.ts

@@ -15,5 +15,13 @@ export type ResolveAgentModelOptions = {
     categoryModel?: string;
     overrideModel?: string;
     systemDefaultModel?: string;
+    /** Custom fallback chain for agents not in AGENT_MODEL_REQUIREMENTS */
+    customFallbackChain?: FallbackEntry[];
 };
-export declare function resolveAgentModel(agentName: WeaveAgentName, options: ResolveAgentModelOptions): string;
+/**
+ * Resolve the model for an agent. Accepts any string agent name.
+ * Built-in agents use AGENT_MODEL_REQUIREMENTS for fallback chains.
+ * Custom agents use the customFallbackChain option, or fall through
+ * to system default / hardcoded fallback.
+ */
+export declare function resolveAgentModel(agentName: string, options: ResolveAgentModelOptions): string;

package/dist/agents/prompt-loader.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Load a prompt from a file path. Supports .md and .txt files.
+ * Paths are sandboxed to basePath (or cwd) — traversal outside is rejected.
+ *
+ * @param promptFilePath - Path to the prompt file (relative to basePath; absolute paths are rejected)
+ * @param basePath - Base directory for resolving relative paths (defaults to cwd)
+ * @returns The file contents as a string, or null if the file doesn't exist or path escapes the sandbox
+ */
+export declare function loadPromptFile(promptFilePath: string, basePath?: string): string | null;

package/dist/agents/prompt-utils.d.ts

@@ -0,0 +1,2 @@
+/** Check whether an agent is enabled (not in the disabled set). */
+export declare function isAgentEnabled(name: string, disabled: Set<string>): boolean;

package/dist/agents/tapestry/index.d.ts

@@ -1,2 +1,9 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
 import type { AgentFactory } from "../types";
+export { composeTapestryPrompt } from "./prompt-composer";
+export type { TapestryPromptOptions } from "./prompt-composer";
+/**
+ * Create a Tapestry agent config with optional disabled agents for prompt composition.
+ */
+export declare function createTapestryAgentWithOptions(model: string, disabledAgents?: Set<string>): AgentConfig;
 export declare const createTapestryAgent: AgentFactory;

package/dist/agents/tapestry/prompt-composer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tapestry prompt composer — assembles the Tapestry system prompt from sections,
+ * conditionally including/excluding content based on enabled agents.
+ *
+ * Default behavior (no disabled agents) produces identical output to the
+ * hardcoded TAPESTRY_DEFAULTS.prompt string.
+ */
+export interface TapestryPromptOptions {
+    /** Set of disabled agent names (lowercase config keys) */
+    disabledAgents?: Set<string>;
+}
+export declare function buildTapestryRoleSection(): string;
+export declare function buildTapestryDisciplineSection(): string;
+export declare function buildTapestrySidebarTodosSection(): string;
+export declare function buildTapestryPlanExecutionSection(disabled?: Set<string>): string;
+export declare function buildTapestryVerificationSection(): string;
+export declare function buildTapestryPostExecutionReviewSection(disabled: Set<string>): string;
+export declare function buildTapestryExecutionSection(): string;
+export declare function buildTapestryStyleSection(): string;
+/**
+ * Compose the full Tapestry system prompt from sections.
+ * When no agents are disabled, produces identical output to TAPESTRY_DEFAULTS.prompt.
+ */
+export declare function composeTapestryPrompt(options?: TapestryPromptOptions): string;

package/dist/config/schema.d.ts

@@ -83,6 +83,79 @@ export declare const ExperimentalConfigSchema: z.ZodObject<{
     context_window_warning_threshold: z.ZodOptional<z.ZodNumber>;
     context_window_critical_threshold: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+export declare const DelegationTriggerSchema: z.ZodObject<{
+    domain: z.ZodString;
+    trigger: z.ZodString;
+}, z.core.$strip>;
+export declare const CustomAgentConfigSchema: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    prompt_file: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    display_name: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        subagent: "subagent";
+        primary: "primary";
+        all: "all";
+    }>>;
+    fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        exploration: "exploration";
+        specialist: "specialist";
+        advisor: "advisor";
+        utility: "utility";
+    }>>;
+    cost: z.ZodOptional<z.ZodEnum<{
+        FREE: "FREE";
+        CHEAP: "CHEAP";
+        EXPENSIVE: "EXPENSIVE";
+    }>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        trigger: z.ZodString;
+    }, z.core.$strip>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CustomAgentsConfigSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    prompt_file: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    display_name: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        subagent: "subagent";
+        primary: "primary";
+        all: "all";
+    }>>;
+    fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        exploration: "exploration";
+        specialist: "specialist";
+        advisor: "advisor";
+        utility: "utility";
+    }>>;
+    cost: z.ZodOptional<z.ZodEnum<{
+        FREE: "FREE";
+        CHEAP: "CHEAP";
+        EXPENSIVE: "EXPENSIVE";
+    }>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        trigger: z.ZodString;
+    }, z.core.$strip>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const AnalyticsConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
 export declare const WeaveConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -104,6 +177,39 @@ export declare const WeaveConfigSchema: z.ZodObject<{
         }>>;
         maxTokens: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
+    custom_agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        prompt: z.ZodOptional<z.ZodString>;
+        prompt_file: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        display_name: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            subagent: "subagent";
+            primary: "primary";
+            all: "all";
+        }>>;
+        fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        category: z.ZodOptional<z.ZodEnum<{
+            exploration: "exploration";
+            specialist: "specialist";
+            advisor: "advisor";
+            utility: "utility";
+        }>>;
+        cost: z.ZodOptional<z.ZodEnum<{
+            FREE: "FREE";
+            CHEAP: "CHEAP";
+            EXPENSIVE: "EXPENSIVE";
+        }>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            trigger: z.ZodString;
+        }, z.core.$strip>>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
     categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
@@ -126,6 +232,9 @@ export declare const WeaveConfigSchema: z.ZodObject<{
         modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    analytics: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
     tmux: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         layout: z.ZodOptional<z.ZodEnum<{
@@ -145,9 +254,12 @@ export declare const WeaveConfigSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
 export type AgentOverrides = z.infer<typeof AgentOverridesSchema>;
+export type CustomAgentConfig = z.infer<typeof CustomAgentConfigSchema>;
+export type CustomAgentsConfig = z.infer<typeof CustomAgentsConfigSchema>;
 export type CategoryConfig = z.infer<typeof CategoryConfigSchema>;
 export type CategoriesConfig = z.infer<typeof CategoriesConfigSchema>;
 export type BackgroundConfig = z.infer<typeof BackgroundConfigSchema>;
+export type AnalyticsConfig = z.infer<typeof AnalyticsConfigSchema>;
 export type TmuxConfig = z.infer<typeof TmuxConfigSchema>;
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
 export type WeaveConfig = z.infer<typeof WeaveConfigSchema>;

package/dist/create-managers.d.ts

@@ -2,6 +2,7 @@ import type { PluginInput } from "@opencode-ai/plugin";
 import type { AgentConfig } from "@opencode-ai/sdk";
 import type { WeaveConfig } from "./config/schema";
 import type { ResolveSkillsFn } from "./agents/agent-builder";
+import type { ProjectFingerprint } from "./features/analytics/types";
 import { ConfigHandler } from "./managers/config-handler";
 import { BackgroundManager } from "./managers/background-manager";
 import { SkillMcpManager } from "./managers/skill-mcp-manager";
@@ -15,4 +16,6 @@ export declare function createManagers(options: {
     ctx: PluginInput;
     pluginConfig: WeaveConfig;
     resolveSkills?: ResolveSkillsFn;
+    fingerprint?: ProjectFingerprint | null;
+    configDir?: string;
 }): WeaveManagers;

package/dist/features/analytics/fingerprint.d.ts

@@ -0,0 +1,32 @@
+import type { ProjectFingerprint, DetectedStack } from "./types";
+/**
+ * Detect the technology stack of a project by scanning for marker files.
+ * This is a fast, synchronous scan — suitable for fire-and-forget use.
+ */
+export declare function detectStack(directory: string): DetectedStack[];
+/**
+ * Detect the package manager used by the project.
+ */
+export declare function detectPackageManager(directory: string): string | undefined;
+/**
+ * Detect whether the project is a monorepo.
+ */
+export declare function detectMonorepo(directory: string): boolean;
+/**
+ * Detect the primary language of the project.
+ */
+export declare function detectPrimaryLanguage(stack: DetectedStack[]): string | undefined;
+/**
+ * Generate a complete project fingerprint.
+ */
+export declare function generateFingerprint(directory: string): ProjectFingerprint;
+/**
+ * Generate and persist a project fingerprint.
+ * Fire-and-forget: errors are logged but never thrown.
+ */
+export declare function fingerprintProject(directory: string): ProjectFingerprint | null;
+/**
+ * Get the cached fingerprint, or generate a new one if missing.
+ * Fire-and-forget: errors are logged but never thrown.
+ */
+export declare function getOrCreateFingerprint(directory: string): ProjectFingerprint | null;

package/dist/features/analytics/index.d.ts

@@ -0,0 +1,22 @@
+export type { ToolUsageEntry, DelegationEntry, SessionSummary, DetectedStack, ProjectFingerprint, Suggestion, InFlightToolCall, TrackedSession, } from "./types";
+export { ANALYTICS_DIR, SESSION_SUMMARIES_FILE, FINGERPRINT_FILE } from "./types";
+export { ensureAnalyticsDir, appendSessionSummary, readSessionSummaries, writeFingerprint, readFingerprint, } from "./storage";
+export { detectStack, detectPackageManager, detectMonorepo, detectPrimaryLanguage, generateFingerprint, fingerprintProject, getOrCreateFingerprint, } from "./fingerprint";
+export { SessionTracker, createSessionTracker } from "./session-tracker";
+export { generateSuggestions, getSuggestionsForProject } from "./suggestions";
+import type { SessionTracker } from "./session-tracker";
+import type { ProjectFingerprint } from "./types";
+/** Return value of createAnalytics — bundles tracker + fingerprint */
+export interface Analytics {
+    /** Session tracker instance — wire into tool.execute.before/after */
+    tracker: SessionTracker;
+    /** Project fingerprint (may be null if detection fails) */
+    fingerprint: ProjectFingerprint | null;
+}
+/**
+ * Create all analytics services for a project.
+ * Instantiates the session tracker and optionally generates/loads the project fingerprint.
+ * If a fingerprint is provided, it is reused; otherwise one is generated.
+ * This is the single entry point called from the plugin's main init.
+ */
+export declare function createAnalytics(directory: string, fingerprint?: ProjectFingerprint | null): Analytics;

package/dist/features/analytics/session-tracker.d.ts

@@ -0,0 +1,48 @@
+import type { TrackedSession, SessionSummary } from "./types";
+/**
+ * SessionTracker tracks tool usage and delegations across sessions,
+ * producing SessionSummary records when sessions end.
+ *
+ * Usage:
+ * - Call `startSession()` when a session begins (or lazily on first tool call)
+ * - Call `trackToolStart()` / `trackToolEnd()` on tool.execute.before/after
+ * - Call `endSession()` when the session ends → writes summary to JSONL
+ */
+export declare class SessionTracker {
+    private sessions;
+    private directory;
+    constructor(directory: string);
+    /**
+     * Start tracking a session. Idempotent — if already tracking, returns existing.
+     */
+    startSession(sessionId: string): TrackedSession;
+    /**
+     * Track a tool execution start. Lazily starts the session if needed.
+     */
+    trackToolStart(sessionId: string, toolName: string, callId: string, agent?: string): void;
+    /**
+     * Track a tool execution end. Records delegation if it was a task tool.
+     */
+    trackToolEnd(sessionId: string, toolName: string, callId: string, agent?: string): void;
+    /**
+     * End a session and persist the summary. Removes the session from tracking.
+     * Returns the generated summary, or null if the session wasn't being tracked.
+     */
+    endSession(sessionId: string): SessionSummary | null;
+    /**
+     * Check if a session is currently being tracked.
+     */
+    isTracking(sessionId: string): boolean;
+    /**
+     * Get the current tracked session data (for inspection/testing).
+     */
+    getSession(sessionId: string): TrackedSession | undefined;
+    /**
+     * Get the number of sessions currently being tracked.
+     */
+    get activeSessionCount(): number;
+}
+/**
+ * Create a new SessionTracker instance.
+ */
+export declare function createSessionTracker(directory: string): SessionTracker;

package/dist/features/analytics/storage.d.ts

@@ -0,0 +1,28 @@
+import type { SessionSummary, ProjectFingerprint } from "./types";
+/** Maximum number of session summary entries to keep in the JSONL file */
+export declare const MAX_SESSION_ENTRIES = 1000;
+/**
+ * Ensure the analytics directory exists, creating it if needed.
+ * Returns the absolute path to the analytics directory.
+ */
+export declare function ensureAnalyticsDir(directory: string): string;
+/**
+ * Append a session summary to the JSONL file.
+ * Auto-creates the analytics directory if needed.
+ */
+export declare function appendSessionSummary(directory: string, summary: SessionSummary): boolean;
+/**
+ * Read all session summaries from the JSONL file.
+ * Returns an empty array if the file doesn't exist or is unparseable.
+ */
+export declare function readSessionSummaries(directory: string): SessionSummary[];
+/**
+ * Write a project fingerprint to the analytics directory.
+ * Auto-creates the analytics directory if needed.
+ */
+export declare function writeFingerprint(directory: string, fingerprint: ProjectFingerprint): boolean;
+/**
+ * Read the project fingerprint from the analytics directory.
+ * Returns null if the file doesn't exist or is unparseable.
+ */
+export declare function readFingerprint(directory: string): ProjectFingerprint | null;

package/dist/features/analytics/suggestions.d.ts

@@ -0,0 +1,10 @@
+import type { SessionSummary, Suggestion } from "./types";
+/**
+ * Generate suggestions based on session history.
+ * Analyzes tool usage patterns, delegation frequency, and workflow patterns.
+ */
+export declare function generateSuggestions(summaries: SessionSummary[]): Suggestion[];
+/**
+ * Generate suggestions from stored session summaries for a project.
+ */
+export declare function getSuggestionsForProject(directory: string): Suggestion[];

package/dist/features/analytics/types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Analytics types for session intelligence and learning.
+ * All analytics data is stored under `.weave/analytics/`.
+ */
+/** Directory where analytics data is stored (relative to project root) */
+export declare const ANALYTICS_DIR = ".weave/analytics";
+/** File name for session summaries (JSONL format) */
+export declare const SESSION_SUMMARIES_FILE = "session-summaries.jsonl";
+/** File name for project fingerprint */
+export declare const FINGERPRINT_FILE = "fingerprint.json";
+/** A single tool invocation recorded during a session */
+export interface ToolUsageEntry {
+    /** Tool name (e.g., "read", "write", "task") */
+    tool: string;
+    /** Number of times this tool was invoked */
+    count: number;
+}
+/** A delegation to a sub-agent recorded during a session */
+export interface DelegationEntry {
+    /** Sub-agent type (e.g., "thread", "pattern", "weft") */
+    agent: string;
+    /** Tool call ID that started this delegation */
+    toolCallId: string;
+    /** Duration in milliseconds (if completed) */
+    durationMs?: number;
+}
+/** Summary of a completed session, appended as a JSONL line */
+export interface SessionSummary {
+    /** Unique session identifier */
+    sessionId: string;
+    /** ISO timestamp when session started */
+    startedAt: string;
+    /** ISO timestamp when session ended */
+    endedAt: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Tools used during the session */
+    toolUsage: ToolUsageEntry[];
+    /** Delegations made during the session */
+    delegations: DelegationEntry[];
+    /** Total number of tool calls */
+    totalToolCalls: number;
+    /** Total number of delegations */
+    totalDelegations: number;
+}
+/** Detected language/framework in the project */
+export interface DetectedStack {
+    /** Language or framework name (e.g., "typescript", "react", "bun") */
+    name: string;
+    /** Detection confidence: "high" if found in lockfile/config, "medium" for deps */
+    confidence: "high" | "medium";
+    /** Evidence for detection (e.g., "tsconfig.json exists") */
+    evidence: string;
+}
+/** Project fingerprint — captures the tech stack and structure */
+export interface ProjectFingerprint {
+    /** ISO timestamp when fingerprint was generated */
+    generatedAt: string;
+    /** Detected technology stack entries */
+    stack: DetectedStack[];
+    /** Whether a monorepo structure was detected */
+    isMonorepo: boolean;
+    /** Package manager detected (e.g., "bun", "npm", "yarn", "pnpm") */
+    packageManager?: string;
+    /** Primary language detected */
+    primaryLanguage?: string;
+    /** Operating system (e.g., "darwin", "win32", "linux") */
+    os?: string;
+    /** CPU architecture (e.g., "arm64", "x64") */
+    arch?: string;
+}
+/** A suggestion generated from session analytics */
+export interface Suggestion {
+    /** Unique identifier for deduplication */
+    id: string;
+    /** Human-readable suggestion text */
+    text: string;
+    /** Category of suggestion */
+    category: "tool-usage" | "delegation" | "workflow";
+    /** Confidence level */
+    confidence: "high" | "medium" | "low";
+}
+/** Tracks in-flight tool calls for duration measurement */
+export interface InFlightToolCall {
+    /** Tool name */
+    tool: string;
+    /** Start timestamp (ms since epoch) */
+    startedAt: number;
+    /** Sub-agent type if this is a task delegation */
+    agent?: string;
+}
+/** Active session being tracked */
+export interface TrackedSession {
+    /** Session ID */
+    sessionId: string;
+    /** ISO timestamp when tracking started */
+    startedAt: string;
+    /** Tool usage counts keyed by tool name */
+    toolCounts: Record<string, number>;
+    /** Completed delegations */
+    delegations: DelegationEntry[];
+    /** In-flight tool calls keyed by callID */
+    inFlight: Record<string, InFlightToolCall>;
+}