bikky 0.3.1 → 0.3.3

package/dist/daemon/episode-summary.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"episode-summary.test.d.ts","sourceRoot":"","sources":["../../src/daemon/episode-summary.test.ts"],"names":[],"mappings":""}

package/dist/daemon/episode-summary.test.js

@@ -0,0 +1,101 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildEpisodeSummaryFilter, buildEpisodeSummaryMessages, buildEpisodeSummaryPayload, parseEpisodeSummaryDraft, segmentTranscriptIntoEpisodes, } from "./episode-summary.js";
+const defaultScope = {
+    workspaceId: "default",
+    includeLegacy: true,
+};
+describe("daemon/episode-summary", () => {
+    it("segments two unrelated user tasks in one session into two episodes", () => {
+        const transcript = `[USER] Implement ontology v2 in src/mcp/taxonomy.ts and add tests.
+
+[ASSISTANT] Updated src/mcp/taxonomy.ts with software_engineering domains and memory_subtype validation. Ran npm test for taxonomy.
+
+[USER] Now fix the UI smoke tests in packages/ui/tests/smoke.spec.ts.
+
+[ASSISTANT] Updated packages/ui/tests/smoke.spec.ts to cover browse filters and ran npm run test:e2e.`;
+        const segments = segmentTranscriptIntoEpisodes({
+            sessionId: "uuid:test-session",
+            transcript,
+            eventCount: 14,
+        });
+        assert.equal(segments.length, 2);
+        assert.match(segments[0].episode_id, /^uuid:test-session:episode:/);
+        assert.match(segments[0].transcript, /ontology v2/);
+        assert.match(segments[1].transcript, /UI smoke tests/);
+    });
+    it("does not create episodes for small irrelevant batches", () => {
+        const segments = segmentTranscriptIntoEpisodes({
+            sessionId: "uuid:test-session",
+            transcript: "[USER] ok\n\n[ASSISTANT] done",
+            eventCount: 2,
+        });
+        assert.deepEqual(segments, []);
+    });
+    it("builds episode summary prompts", () => {
+        const messages = buildEpisodeSummaryMessages({
+            transcript: "[USER] update src/daemon/extraction.ts",
+        });
+        assert.match(messages[0].content, /one coherent work episode/);
+        assert.match(messages[1].content, /workstream_key/);
+    });
+    it("parses episode summary drafts", () => {
+        const draft = parseEpisodeSummaryDraft(`\`\`\`json
+{
+  "content": "Implemented ontology v2 extraction for src/daemon/extraction.ts.",
+  "tasks_completed": ["ontology extraction"],
+  "decisions_made": ["Use memory_subtype on daemon facts"],
+  "open_questions": ["wire workstream summaries"],
+  "entities": ["Bikky", "src/daemon/extraction.ts"],
+  "workstream_key": "243-bikky-data-capture-policy",
+  "importance": 0.9
+}
+\`\`\``);
+        assert.equal(draft.content, "Implemented ontology v2 extraction for src/daemon/extraction.ts.");
+        assert.deepEqual(draft.entities, ["bikky", "src/daemon/extraction.ts"]);
+        assert.equal(draft.workstream_key, "243-bikky-data-capture-policy");
+    });
+    it("builds episode filters scoped to workspace and subtype", () => {
+        const filter = buildEpisodeSummaryFilter("episode-1", defaultScope);
+        assert.ok(filter.must.some((condition) => JSON.stringify(condition) === JSON.stringify({ key: "memory_subtype", match: { value: "episode" } })));
+        assert.deepEqual(filter.should, [
+            { key: "workspace_id", match: { value: "default" } },
+            { is_empty: { key: "workspace_id" } },
+        ]);
+    });
+    it("omits workspace filters when no workspace is supplied", () => {
+        const filter = buildEpisodeSummaryFilter("episode-1", {});
+        assert.equal(filter.should, undefined);
+        assert.equal(filter.must.some((condition) => JSON.stringify(condition).includes("workspace_id")), false);
+    });
+    it("builds ontology-v2 episode payloads", () => {
+        const { payload } = buildEpisodeSummaryPayload({
+            draft: {
+                content: "Implemented daemon episode summaries for src/daemon/episode-summary.ts.",
+                tasks_completed: ["episode summaries"],
+                decisions_made: ["Use episode summaries instead of one evolving session summary"],
+                open_questions: ["workstream updater"],
+                entities: ["bikky", "src/daemon/episode-summary.ts"],
+                workstream_key: "243-bikky-data-capture-policy",
+                importance: 0.85,
+            },
+            segment: {
+                episode_id: "episode-1",
+                ordinal: 0,
+                transcript: "[USER] implement episodes",
+                event_count: 8,
+            },
+            sessionId: "uuid:test-session",
+            scope: { workspaceId: "team-a", actorId: "agent-1", includeLegacy: false },
+            now: "2026-04-25T12:00:00.000Z",
+            redactionOptions: { enabled: true, redactPii: true },
+        });
+        assert.equal(payload.kind, "summary");
+        assert.equal(payload.memory_subtype, "episode");
+        assert.equal(payload.domain, "software_engineering");
+        assert.equal(payload.episode_id, "episode-1");
+        assert.equal(payload.workstream_key, "243-bikky-data-capture-policy");
+        assert.equal(payload.metadata.summary_subtype, "episode");
+    });
+});
+//# sourceMappingURL=episode-summary.test.js.map

package/dist/daemon/episode-summary.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"episode-summary.test.js","sourceRoot":"","sources":["../../src/daemon/episode-summary.test.ts"],"names":[],"mappings":"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"}

package/dist/daemon/extraction.d.ts

@@ -8,6 +8,31 @@
 import type { BikkyConfig } from "../config.js";
 import type { LogFn } from "./qdrant.js";
 export declare const setLogger: (fn: LogFn) => void;
+export declare const DEFAULT_EXTRACTION_PROMPT = "You are Bikky's memory extraction agent for open-source coding agents. Extract durable, reusable facts that help a future agent continue work without rereading the whole transcript.\n\n## Core rule\nExtract fewer, sharper memories. A candidate fact must be independently useful after the session is gone.\n\n## Quality gate\nEvery fact must pass at least one gate:\n1. GREPPABLE: names a file path, package, symbol, config key, CLI flag, issue/PR, service, or API a future agent can search for.\n2. RUNNABLE: contains a command, URL, setting, port, or procedure that can be executed or checked.\n3. NAVIGABLE: tells a future agent where to look and what that location means.\n4. DECISIVE: records a durable decision, rationale, constraint, convention, preference, or ownership rule.\n5. DIAGNOSTIC: captures a repeatable failure mode, root cause, or troubleshooting gotcha.\n\n## Ontology\n- domain is the activity profile. For coding-agent captures use \"software_engineering\".\n- category is subject matter: codebase | infrastructure | operations | decisions | product_domain | projects | people | preferences | observations.\n- kind is object shape. For this prompt, emit only kind=\"fact\".\n- memory_subtype must be one of:\n  codebase_map | architecture_decision | infra_topology | access_pattern | deployment_procedure | operational_procedure | domain_rule | troubleshooting_gotcha | preference | ownership.\n\n## Examples\nGOOD:\n- \"The UI smoke tests live in packages/ui/tests/smoke.spec.ts and run through npm run test:e2e with mocked /api/memory/* responses.\"\n- \"Use workspace_id as the tenancy/access boundary; domain is reserved for activity profile such as software_engineering.\"\n- \"If Qdrant order_by fails with a missing index error, create a datetime payload index for the sorted field before retrying.\"\n- \"Prefer Node's built-in test runner for root tests; do not add Jest just for daemon unit tests.\"\n\nBAD:\n- \"The tests were fixed.\" (status only)\n- \"We reviewed the code.\" (session narration)\n- \"The deployment succeeded.\" (transient and not reusable)\n- \"The agent used npm.\" (tool narration)\n- \"There was an error.\" (no root cause or reusable detail)\n\n## Output format\nReturn strict JSON:\n{\"facts\":[\n  {\n    \"content\":\"One self-contained durable fact.\",\n    \"category\":\"codebase\",\n    \"memory_subtype\":\"codebase_map\",\n    \"entities\":[\"repo-or-tool\",\"specific-module\"],\n    \"confidence\":0.9,\n    \"importance\":0.7,\n    \"quality_score\":0.8,\n    \"confidence_reason\":\"Explicitly stated in the transcript.\",\n    \"repo\":\"optional/repo-or-package\",\n    \"branch\":\"optional-branch\",\n    \"task_key\":\"optional issue/PR/task key\",\n    \"workstream_key\":\"optional stable workstream key\"\n  }\n]}\n\nScoring:\n- confidence: 0.9 explicit, 0.7 strong inference, 0.55 weak but useful inference.\n- importance: 0.8+ for decisions, infra, procedures, access, recurring failures; 0.6+ for useful codebase maps/preferences.\n- quality_score: 0.8+ passes multiple gates, 0.6+ passes one strong gate, below 0.6 should usually be omitted.\n\nIf nothing passes the quality gate, return {\"facts\":[]}.";
+export interface ExtractedFact {
+    content: string;
+    category: string;
+    memory_subtype?: string | null;
+    entities: string[];
+    confidence: number;
+    importance: number;
+    quality_score?: number | null;
+    confidence_reason?: string | null;
+    repo?: string | null;
+    branch?: string | null;
+    task_key?: string | null;
+    workstream_key?: string | null;
+}
+export interface FactQualitySignals {
+    wordCount: number;
+    hasDurableAnchor: boolean;
+    isStatusOnly: boolean;
+    isShortUseful: boolean;
+    computedQualityScore: number;
+}
+export declare const factQualitySignals: (fact: ExtractedFact) => FactQualitySignals;
+export declare const normalizeExtractedFact: (raw: Record<string, unknown>) => ExtractedFact | null;
+export declare const isHighQualityExtractedFact: (fact: ExtractedFact) => boolean;
 /**
  * Periodic extraction tick — called from the daemon tick loop.
  * For each active Copilot session with events.jsonl, reads new events

package/dist/daemon/extraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extraction.d.ts","sourceRoot":"","sources":["../../src/daemon/extraction.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAIhD,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,aAAa,CAAC;AAOpD,eAAO,MAAM,SAAS,GAAI,IAAI,KAAK,KAAG,IAErC,CAAC;AAsdF;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAU,QAAQ,WAAW,KAAG,OAAO,CAAC,IAAI,CA8B5D,CAAC"}
+{"version":3,"file":"extraction.d.ts","sourceRoot":"","sources":["../../src/daemon/extraction.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAIhD,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,aAAa,CAAC;AA2BpD,eAAO,MAAM,SAAS,GAAI,IAAI,KAAK,KAAG,IAErC,CAAC;AAUF,eAAO,MAAM,yBAAyB,unGA0DmB,CAAC;AAgO1D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AA2BD,eAAO,MAAM,kBAAkB,GAAI,MAAM,aAAa,KAAG,kBA2BxD,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,aAAa,GAAG,IAuCrF,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,MAAM,aAAa,KAAG,OAkBhE,CAAC;AAkLF;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAU,QAAQ,WAAW,KAAG,OAAO,CAAC,IAAI,CA8B5D,CAAC"}

package/dist/daemon/extraction.js

@@ -14,6 +14,10 @@ import { loadConfig, STATE_DIR } from "../config.js";
 import * as qdrant from "./qdrant.js";
 import { chatCompletion } from "../llm/index.js";
 import { detectContradiction } from "./consolidation.js";
+import { normalizeCategory, normalizeEntities, normalizeMemorySubtype, validateMemorySubtype, } from "../mcp/taxonomy.js";
+import { extractionPrompt, EXTRACTION_PROMPT_DESCRIPTOR, safeParseJson, } from "../prompts/index.js";
+import { CAPTURE_POLICY_VERSION, CAPTURE_TRIGGERS, DEFAULT_CAPTURE_CONTEXT, QUALITY_THRESHOLDS, promptVersionForSubtype, subtypeForCategory, } from "./capture-policy.js";
+import { shouldSummarizeEvents, updateSessionSummary } from "./session-summary.js";
 // ── Module state ─────────────────────────────────────────────────────────────
 let logFn = (() => { });
 let lastTickAt = 0;
@@ -26,78 +30,65 @@ const EXTRACTABLE_TYPES = new Set([
     "assistant.message",
     "session.compaction_complete",
 ]);
-const DEFAULT_EXTRACTION_PROMPT = `You are a knowledge extraction agent for software engineers. Extract ENGINEERING REFERENCES — durable facts that help an engineer navigate codebases, understand infrastructure, run operations, and make decisions.
+export const DEFAULT_EXTRACTION_PROMPT = `You are Bikky's memory extraction agent for open-source coding agents. Extract durable, reusable facts that help a future agent continue work without rereading the whole transcript.
 
-## Quality Gate (apply to EVERY candidate fact)
-A fact must pass AT LEAST ONE of these tests or it is noise — skip it:
-1. GREPPABLE — contains a file path, service name, config key, CLI flag, or symbol an engineer could search for
-2. RUNNABLE — contains a command, URL, port, or procedure that could be executed
-3. NAVIGABLE — tells you where to look for something specific (which repo, which module, which config)
-4. DECISIVE — records a choice with enough rationale that a future engineer won't re-debate it
+## Core rule
+Extract fewer, sharper memories. A candidate fact must be independently useful after the session is gone.
 
-## 7 Reference Types (extract ONLY these)
+## Quality gate
+Every fact must pass at least one gate:
+1. GREPPABLE: names a file path, package, symbol, config key, CLI flag, issue/PR, service, or API a future agent can search for.
+2. RUNNABLE: contains a command, URL, setting, port, or procedure that can be executed or checked.
+3. NAVIGABLE: tells a future agent where to look and what that location means.
+4. DECISIVE: records a durable decision, rationale, constraint, convention, preference, or ownership rule.
+5. DIAGNOSTIC: captures a repeatable failure mode, root cause, or troubleshooting gotcha.
 
-### 1. Codebase Map — "where does X live?"
-File paths, entry points, module ownership, call chains.
-GOOD: "Alert extraction logic is in src/enrichers/bank-account-enricher.ts, called by the DM pipeline handler (src/pipeline/dm-handler.ts), not the group handler"
-BAD: "The code was updated to fix extraction" (no path, no specifics)
+## Ontology
+- domain is the activity profile. For coding-agent captures use "software_engineering".
+- category is subject matter: codebase | infrastructure | operations | decisions | product_domain | projects | people | preferences | observations.
+- kind is object shape. For this prompt, emit only kind="fact".
+- memory_subtype must be one of:
+  codebase_map | architecture_decision | infra_topology | access_pattern | deployment_procedure | operational_procedure | domain_rule | troubleshooting_gotcha | preference | ownership.
 
-### 2. Architecture Decision — "why was X chosen?"
-Choice + alternatives considered + rationale + constraints.
-GOOD: "Chose Portkey over direct Bedrock calls for LLM routing — gives per-model fallback chains and spend tracking without vendor lock-in. Decided in PR #847"
-BAD: "We use Portkey for LLM" (no rationale, no context)
+## Examples
+GOOD:
+- "The UI smoke tests live in packages/ui/tests/smoke.spec.ts and run through npm run test:e2e with mocked /api/memory/* responses."
+- "Use workspace_id as the tenancy/access boundary; domain is reserved for activity profile such as software_engineering."
+- "If Qdrant order_by fails with a missing index error, create a datetime payload index for the sorted field before retrying."
+- "Prefer Node's built-in test runner for root tests; do not add Jest just for daemon unit tests."
 
-### 3. Infrastructure Topology — "what connects to what?"
-Endpoints, ports, resource IDs, service connections, cluster names, regions.
-GOOD: "ClickHouse in lloyds cluster accessed via port-forward: kubectl port-forward svc/clickhouse 9000:9000 --context arn:aws:eks:eu-west-2:871829501674:cluster/lloyds"
-BAD: "ClickHouse is running" (no actionable detail)
-
-### 4. Access & Credentials — "how do I authenticate?"
-Where secrets live, IAM roles, auth patterns, permission gotchas.
-GOOD: "saber IAM user blocked by EnforceMFA for ECR/S3 — use --profile mfa. EC2 instance role agent00-cortex-ec2 has ECR pull+push scoped to arn:aws:ecr:ap-southeast-2:871829501674:repository/agent00-cortex"
-BAD: "AWS credentials are configured" (useless)
-
-### 5. Deployment & Shipping — "how do I release X?"
-Build, release, CI/CD pipelines, verification steps.
-GOOD: "EC2 cortex deploys via SSM: download repo tarball from GitHub API (needs saber-zrelli-private token) → build on EC2 (native amd64) → push to ECR → docker compose pull && up -d. SSM executionTimeout must be ≥600s"
-BAD: "The deployment was successful" (not reusable)
-
-### 6. Operational Procedure — "how do I do X on a live system?"
-kubectl recipes, patching commands, rollout procedures, scaling ops, cleanup, troubleshooting.
-GOOD: "To roll TG bot images across lloyds fleet: kubectl get deploy -l app=tg-bot --context lloyds-ctx, then patch each with image update. Wait 30s between batches to avoid message loss"
-BAD: "Bot images were updated" (no procedure)
-
-### 7. Business Logic Rule — "what are the domain rules?"
-Data flow semantics, edge cases that affect code, domain-specific constraints.
-GOOD: "SA bank accounts (Capitec branch 470010, TymeBank 678910, FNB 250655) are frequently misclassified as AU BSBs because branch codes are 6 digits. Recovery script stage 1b re-extracts with ZA country tagging"
-BAD: "Bank accounts are extracted" (no specifics)
-
-## What to ALWAYS SKIP
-- Session narration: "the user asked to fix X, then we looked at Y" — that's a log, not a reference
-- Meta-observations about tools: "bikky handles extraction" / "the agent used kubectl" — obvious from context
-- Debugging state: "test 67 fails" / "got a 404" — transient unless it reveals a PERMANENT quirk
-- Vague summaries: "WhatsApp bot was updated" — which bot? which update? which PR?
-- Opinions without rationale: "Nova Lite is good" — good for what? compared to what?
-- Anything you can't add specifics to: if you can't name a file, service, command, or decision — skip it
+BAD:
+- "The tests were fixed." (status only)
+- "We reviewed the code." (session narration)
+- "The deployment succeeded." (transient and not reusable)
+- "The agent used npm." (tool narration)
+- "There was an error." (no root cause or reusable detail)
 
 ## Output format
-{"facts": [
+Return strict JSON:
+{"facts":[
   {
-    "content": "EC2 cortex has no git installed — deploys download repo tarball via GitHub API (curl -sL -H 'Authorization: token $TOKEN' https://api.github.com/repos/OWNER/REPO/tarball/main) then build locally on EC2",
-    "category": "infrastructure",
-    "entities": ["ec2", "ecr", "github-api"],
-    "confidence": 0.9,
-    "importance": 0.8
+    "content":"One self-contained durable fact.",
+    "category":"codebase",
+    "memory_subtype":"codebase_map",
+    "entities":["repo-or-tool","specific-module"],
+    "confidence":0.9,
+    "importance":0.7,
+    "quality_score":0.8,
+    "confidence_reason":"Explicitly stated in the transcript.",
+    "repo":"optional/repo-or-package",
+    "branch":"optional-branch",
+    "task_key":"optional issue/PR/task key",
+    "workstream_key":"optional stable workstream key"
   }
 ]}
 
-- Category: infrastructure | decisions | observation | preferences | projects | team
-- Entities: lowercase identifiers (service names, tools, repos — things you'd grep for)
-- Confidence 0.0-1.0: 0.9 for explicit statements, 0.6 for inferences
-- Importance 0.0-1.0: 0.7+ for architecture/infra/access/ops, 0.5-0.7 for decisions/business rules
+Scoring:
+- confidence: 0.9 explicit, 0.7 strong inference, 0.55 weak but useful inference.
+- importance: 0.8+ for decisions, infra, procedures, access, recurring failures; 0.6+ for useful codebase maps/preferences.
+- quality_score: 0.8+ passes multiple gates, 0.6+ passes one strong gate, below 0.6 should usually be omitted.
 
-Prefer fewer, higher-quality facts over many weak ones. 3 good references beat 10 vague observations.
-If nothing passes the quality gate, return: {"facts": []}`;
+If nothing passes the quality gate, return {"facts":[]}.`;
 // ── JSON-file state persistence ──────────────────────────────────────────────
 const EXTRACTION_STATE_PATH = join(STATE_DIR, "extraction-state.json");
 const loadExtractionStates = () => {
@@ -272,75 +263,164 @@ const buildTranscript = (events) => {
     }
     return lines.join("\n\n");
 };
+const clamp01 = (value) => Math.max(0, Math.min(1, value));
+const textWordCount = (text) => text.trim().split(/\s+/).filter(Boolean).length;
+const hasDurableAnchor = (content, entities) => {
+    const text = content.trim();
+    return Boolean(/(?:^|\s)(?:[\w.-]+\/)+[\w./-]+/.test(text) ||
+        /`[^`]+`/.test(text) ||
+        /\b(?:npm|pnpm|yarn|node|git|gh|docker|kubectl|make|go|python|pip|cargo|terraform|aws|curl)\b/.test(text) ||
+        /https?:\/\/\S+/.test(text) ||
+        /\b[A-Z][A-Z0-9_]{2,}\b/.test(text) ||
+        /\b[\w.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|rb|php|json|ya?ml|toml|md|sql|sh)\b/.test(text) ||
+        /\b(?:issue|pr|pull request)\s*#?\d+\b/i.test(text) ||
+        entities.length >= 2);
+};
+const isStatusOnlyContent = (content, entities) => {
+    const lower = content.trim().toLowerCase();
+    if (hasDurableAnchor(content, entities))
+        return false;
+    if (textWordCount(content) > 16)
+        return false;
+    return /\b(done|fixed|updated|implemented|reviewed|tested|works|passed|failed|succeeded|completed|started|looked|changed|deployed)\b/.test(lower);
+};
+export const factQualitySignals = (fact) => {
+    const content = fact.content.trim();
+    const entities = normalizeEntities(fact.entities ?? []);
+    const subtype = normalizeMemorySubtype("fact", fact.memory_subtype) ?? subtypeForCategory(normalizeCategory(fact.category));
+    const wordCount = textWordCount(content);
+    const durableAnchor = hasDurableAnchor(content, entities);
+    const statusOnly = isStatusOnlyContent(content, entities);
+    const isPreferenceLike = subtype === "preference" || subtype === "ownership" || subtype === "domain_rule";
+    const isDecisionLike = subtype === "architecture_decision" || subtype === "troubleshooting_gotcha";
+    const shortUseful = wordCount >= 7 && wordCount <= 22 && (isPreferenceLike || isDecisionLike) && (entities.length > 0 || durableAnchor);
+    let score = 0.25;
+    if (wordCount >= 8)
+        score += 0.1;
+    if (wordCount >= 14)
+        score += 0.1;
+    if (durableAnchor)
+        score += 0.25;
+    if (isPreferenceLike || isDecisionLike)
+        score += 0.15;
+    if ((fact.confidence ?? 0) >= 0.75)
+        score += 0.1;
+    if ((fact.importance ?? 0) >= 0.7)
+        score += 0.1;
+    if (statusOnly)
+        score -= 0.4;
+    return {
+        wordCount,
+        hasDurableAnchor: durableAnchor,
+        isStatusOnly: statusOnly,
+        isShortUseful: shortUseful,
+        computedQualityScore: Math.round(clamp01(score) * 100) / 100,
+    };
+};
+export const normalizeExtractedFact = (raw) => {
+    if (!raw.content || typeof raw.content !== "string")
+        return null;
+    const category = normalizeCategory(typeof raw.category === "string" ? raw.category : "observations");
+    const requestedSubtype = typeof raw.memory_subtype === "string" ? raw.memory_subtype : null;
+    let memorySubtype = requestedSubtype ? normalizeMemorySubtype("fact", requestedSubtype) : null;
+    if (!memorySubtype) {
+        memorySubtype = subtypeForCategory(category);
+    }
+    try {
+        validateMemorySubtype("fact", memorySubtype);
+    }
+    catch {
+        memorySubtype = subtypeForCategory(category);
+    }
+    const confidence = typeof raw.confidence === "number" ? clamp01(raw.confidence) : 0.7;
+    const importance = typeof raw.importance === "number" ? clamp01(raw.importance) : 0.5;
+    const qualityScore = typeof raw.quality_score === "number" ? clamp01(raw.quality_score) : null;
+    const entities = Array.isArray(raw.entities)
+        ? normalizeEntities(raw.entities.map((entity) => String(entity)))
+        : [];
+    const fact = {
+        content: raw.content.trim(),
+        category,
+        memory_subtype: memorySubtype,
+        entities,
+        confidence,
+        importance,
+        quality_score: qualityScore,
+        confidence_reason: typeof raw.confidence_reason === "string" ? raw.confidence_reason.trim() : null,
+        repo: typeof raw.repo === "string" ? raw.repo.trim() : null,
+        branch: typeof raw.branch === "string" ? raw.branch.trim() : null,
+        task_key: typeof raw.task_key === "string" ? raw.task_key.trim() : null,
+        workstream_key: typeof raw.workstream_key === "string" ? raw.workstream_key.trim() : null,
+    };
+    return isHighQualityExtractedFact(fact) ? fact : null;
+};
+export const isHighQualityExtractedFact = (fact) => {
+    const content = fact.content.trim();
+    if (content.length < 30)
+        return false;
+    const signals = factQualitySignals(fact);
+    if (QUALITY_THRESHOLDS.rejectStatusOnlyFacts && signals.isStatusOnly)
+        return false;
+    const confidence = fact.confidence ?? 0.7;
+    const importance = fact.importance ?? 0.5;
+    if (confidence < QUALITY_THRESHOLDS.minFactConfidence && importance < QUALITY_THRESHOLDS.minImportanceForLowConfidenceFact) {
+        return false;
+    }
+    const qualityScore = fact.quality_score ?? signals.computedQualityScore;
+    if (qualityScore < QUALITY_THRESHOLDS.minFactQualityScore && !signals.isShortUseful)
+        return false;
+    if (!signals.hasDurableAnchor && !signals.isShortUseful)
+        return false;
+    return true;
+};
 /**
  * Call the LLM to extract facts from a conversation transcript.
  */
 const extractFacts = async (transcript, config) => {
     if (!transcript.trim())
         return [];
-    const prompt = config?.daemon.extraction_prompt || DEFAULT_EXTRACTION_PROMPT;
-    const result = await chatCompletion({
-        messages: [
-            { role: "system", content: prompt },
-            { role: "user", content: transcript },
-        ],
-        temperature: 0.1,
-        max_tokens: 4000,
-        response_format: { type: "json_object" },
+    const rendered = extractionPrompt({
+        transcript,
+        systemOverride: config?.daemon.extraction_prompt ?? null,
     });
+    const result = await chatCompletion(rendered);
     if (!result) {
         logFn("WARN", "Extraction LLM call returned null");
         return [];
     }
-    try {
-        // Strip markdown code fences (```json ... ```) that some models wrap around JSON
-        let cleaned = result.trim();
-        if (cleaned.startsWith("```")) {
-            cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
+    // Parse — handle {facts: [...]}, raw array, or single-fact object
+    let parsed = safeParseJson(result);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const obj = parsed;
+        const unwrapped = obj.facts || obj.results || obj.items;
+        if (Array.isArray(unwrapped)) {
+            parsed = unwrapped;
         }
-        // Parse — handle {facts: [...]}, raw array, or single-fact object
-        let parsed = JSON.parse(cleaned);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            const obj = parsed;
-            const unwrapped = obj.facts || obj.results || obj.items;
-            if (Array.isArray(unwrapped)) {
-                parsed = unwrapped;
-            }
-            else if (obj.content && typeof obj.content === "string") {
-                // Single fact object — wrap in array
-                parsed = [obj];
-            }
-            else {
-                // Try first array value from the object
-                const firstVal = Object.values(obj).find(v => Array.isArray(v));
-                parsed = firstVal || [obj];
-            }
+        else if (obj.content && typeof obj.content === "string") {
+            // Single fact object — wrap in array
+            parsed = [obj];
         }
-        if (!Array.isArray(parsed)) {
-            logFn("WARN", `Extraction LLM returned non-array: ${result.slice(0, 300)}`);
-            return [];
+        else {
+            // Try first array value from the object
+            const firstVal = Object.values(obj).find(v => Array.isArray(v));
+            parsed = firstVal || [obj];
         }
-        return parsed
-            .filter(f => f.content && typeof f.content === "string" && f.category)
-            .map(f => ({
-            content: f.content,
-            category: f.category,
-            entities: Array.isArray(f.entities) ? f.entities.map(e => String(e).toLowerCase()) : [],
-            confidence: typeof f.confidence === "number" ? f.confidence : 0.7,
-            importance: typeof f.importance === "number" ? f.importance : 0.5,
-        }))
-            .filter(f => {
-            if (f.importance < 0.5) {
-                logFn("DEBUG", `Extraction: dropping low-importance fact (${f.importance}): "${f.content.slice(0, 80)}…"`);
-                return false;
-            }
-            return true;
-        });
     }
-    catch (e) {
-        logFn("WARN", `Extraction LLM parse error: ${e.message} — raw: ${result.slice(0, 200)}`);
+    if (!Array.isArray(parsed)) {
+        logFn("WARN", `Extraction LLM returned non-array: ${result.slice(0, 300)}`);
         return [];
     }
+    return parsed
+        .map((raw) => {
+        const fact = normalizeExtractedFact(raw);
+        if (!fact) {
+            const content = typeof raw.content === "string" ? raw.content : JSON.stringify(raw).slice(0, 120);
+            logFn("DEBUG", `Extraction: dropping low-quality fact candidate: "${content.slice(0, 80)}…"`);
+            return null;
+        }
+        return fact;
+    })
+        .filter((fact) => fact !== null);
 };
 // ── Fact storage ─────────────────────────────────────────────────────────────
 const contentHash = (text) => createHash("sha256").update(text).digest("hex");
@@ -353,12 +433,20 @@ const storeFacts = async (facts, sessionId, config) => {
         logFn("WARN", "Extraction: Qdrant not ready, skipping store");
         return 0;
     }
-    const baseMeta = { extracted_from_session: sessionId };
+    const baseMeta = {
+        extracted_from_session: sessionId,
+        capture_policy_version: CAPTURE_POLICY_VERSION,
+        extracted_by_prompt: `${EXTRACTION_PROMPT_DESCRIPTOR.id}@${EXTRACTION_PROMPT_DESCRIPTOR.version}`,
+    };
     let stored = 0;
     for (const fact of facts) {
         const hash = contentHash(fact.content);
+        const sanitizedFact = {
+            ...fact,
+            entities: fact.entities.map((entity) => entity.toLowerCase()),
+        };
         try {
-            const dedup = await qdrant.dedupCheck(fact.content, hash);
+            const dedup = await qdrant.dedupCheck(sanitizedFact.content, hash);
             if (dedup.action === "skip") {
                 // Reinforce existing fact
                 if (dedup.existingId) {
@@ -369,7 +457,7 @@ const storeFacts = async (facts, sessionId, config) => {
             // Run contradiction detection for non-trivial facts
             if (config && (fact.confidence ?? 0.5) >= 0.5) {
                 try {
-                    const contradiction = await detectContradiction(fact, config);
+                    const contradiction = await detectContradiction(sanitizedFact, config);
                     if (contradiction.contradiction && contradiction.existingId) {
                         logFn("INFO", `Extraction: contradiction detected for "${fact.content.slice(0, 60)}..." vs ${contradiction.existingId}: ${contradiction.reason}`);
                         // Log contradiction instead of writing to inbox
@@ -379,15 +467,29 @@ const storeFacts = async (facts, sessionId, config) => {
                     logFn("WARN", `Extraction: contradiction check failed: ${e.message}`);
                 }
             }
+            const subtype = validateMemorySubtype("fact", sanitizedFact.memory_subtype)
+                ?? subtypeForCategory(normalizeCategory(sanitizedFact.category));
             const storePayload = {
-                content: fact.content,
-                category: fact.category,
-                entities: fact.entities,
+                content: sanitizedFact.content,
+                category: sanitizedFact.category,
+                domain: DEFAULT_CAPTURE_CONTEXT.domain,
+                memory_subtype: subtype,
+                entities: sanitizedFact.entities,
                 source: "daemon",
                 kind: "fact",
                 confidence: fact.confidence,
                 importance: fact.importance,
                 content_hash: hash,
+                prompt_version: promptVersionForSubtype(subtype),
+                capture_policy_version: CAPTURE_POLICY_VERSION,
+                quality_score: fact.quality_score ?? factQualitySignals(fact).computedQualityScore,
+                confidence_reason: fact.confidence_reason,
+                review_status: DEFAULT_CAPTURE_CONTEXT.reviewStatus,
+                volatility: DEFAULT_CAPTURE_CONTEXT.volatility,
+                repo: fact.repo,
+                branch: fact.branch,
+                task_key: fact.task_key,
+                workstream_key: fact.workstream_key,
                 metadata: baseMeta,
             };
             if (dedup.action === "supersede" && dedup.existingId) {
@@ -406,6 +508,20 @@ const storeFacts = async (facts, sessionId, config) => {
     }
     return stored;
 };
+const updateSummaryForTranscript = async (sessionId, transcript, eventCount, config) => {
+    try {
+        const result = await updateSessionSummary({ sessionId, transcript, eventCount, config });
+        if (result.action === "stored" || result.action === "updated") {
+            logFn("INFO", `Summary: ${result.action} session summary ${result.factId} for ${sessionId}`);
+        }
+        else {
+            logFn("DEBUG", `Summary: skipped for ${sessionId} (${result.reason})`);
+        }
+    }
+    catch (e) {
+        logFn("WARN", `Summary: failed for ${sessionId}: ${e.message}`);
+    }
+};
 // ── Tick entry point ─────────────────────────────────────────────────────────
 // Max transcript size per LLM call (~60K chars ≈ 15K tokens)
 const MAX_TRANSCRIPT_CHARS = 60_000;
@@ -429,7 +545,7 @@ export const tick = async (config) => {
     if (now - lastTickAt < intervalMs)
         return;
     lastTickAt = now;
-    const minEvents = config.daemon.extract_min_events || 5;
+    const minEvents = config.daemon.extract_min_events || CAPTURE_TRIGGERS.factExtraction.minEvents;
     try {
         // Extract from ALL active Copilot sessions with events.jsonl
         const lockMappings = await resolveLockFiles();
@@ -465,7 +581,8 @@ const extractForUuid = async (mapping, minEvents, config) => {
     }
     // Read new events
     const { events, newOffset, totalLines } = await readNewEvents(eventsPath, state.byte_offset);
-    if (events.length < minEvents) {
+    const shouldSummarize = shouldSummarizeEvents(events, minEvents);
+    if (events.length < minEvents && !shouldSummarize) {
         // Still update offset to avoid re-scanning non-extractable events
         if (newOffset > state.byte_offset) {
             state.byte_offset = newOffset;
@@ -480,11 +597,14 @@ const extractForUuid = async (mapping, minEvents, config) => {
     for (let i = 0; i < chunks.length; i++) {
         const transcript = buildTranscript(chunks[i]);
         logFn("DEBUG", `Extraction: UUID ${uuid.slice(0, 8)} — chunk ${i + 1}/${chunks.length}, ${chunks[i].length} events, ${transcript.length} chars`);
-        const facts = await extractFacts(transcript, config);
-        if (facts.length > 0) {
-            const stored = await storeFacts(facts, stateKey, config);
-            totalFacts += stored;
+        if (events.length >= minEvents) {
+            const facts = await extractFacts(transcript, config);
+            if (facts.length > 0) {
+                const stored = await storeFacts(facts, stateKey, config);
+                totalFacts += stored;
+            }
         }
+        await updateSummaryForTranscript(stateKey, transcript, chunks[i].length, config);
     }
     if (totalFacts > 0) {
         logFn("INFO", `Extraction: UUID ${uuid.slice(0, 8)} — ${totalFacts} facts stored (${events.length} events, ${chunks.length} chunk(s))`);