fluffy-context 0.6.0 → 0.7.6

package/dist/src/compiler/identity.js

@@ -0,0 +1,36 @@
+import crypto from 'node:crypto';
+export function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).filter((key) => record[key] !== undefined).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+}
+export function contentHash(value) {
+    return crypto.createHash('sha256').update(canonicalJson(value)).digest('hex');
+}
+export function estimateTokens(value) {
+    return value.length === 0 ? 0 : Math.ceil(value.length / 4);
+}
+export function rebuildManifestHash(manifest) {
+    return contentHash({
+        schemaVersion: 1,
+        compilerVersion: '0.7.6',
+        rankingVersion: 'compiler-ranking-v2',
+        status: manifest.status,
+        projectRoot: manifest.projectRoot,
+        mode: manifest.mode,
+        anchor: manifest.anchor,
+        intent: manifest.intent,
+        selectedItemHashes: manifest.selected.map((item) => item.itemHash),
+        budget: { usedChars: manifest.budget.usedChars, maxChars: manifest.budget.requested.total },
+        truncation: manifest.truncation,
+    });
+}
+export function validateManifestIdentity(manifest) {
+    return manifest.identity.manifestHash === rebuildManifestHash(manifest)
+        && JSON.stringify(manifest.identity.selectedItemHashes) === JSON.stringify(manifest.selected.map((item) => item.itemHash))
+        && manifest.identity.tokenEstimate.input === estimateTokens(manifest.text)
+        && manifest.identity.tokenEstimate.output === estimateTokens(manifest.text);
+}

package/dist/src/compiler/sources.d.ts

@@ -0,0 +1,19 @@
+import type { BranchWorkspace, CognitionEvent } from '../cognition/types.js';
+import type { ContextOrientResult } from '../agent/types.js';
+import type { ContextAnchor, ContextProvenance, ContextSourceDescriptor, ContextSourceApplicability } from './types.js';
+import type { ContextCompileOptions } from './types.js';
+export interface CompilerSources {
+    orientation: ContextOrientResult;
+    anchor: ContextAnchor;
+    events: CognitionEvent[];
+    workspace: BranchWorkspace | null;
+    fallbackReason: string | null;
+}
+export declare function sourceApplicability(event: CognitionEvent | null, anchor: ContextAnchor): ContextSourceApplicability;
+export declare function provenanceFor(events: CognitionEvent[], entityId: string, anchor: ContextAnchor): ContextProvenance;
+export declare function sourceDescriptor(projectRoot: string, anchor: ContextAnchor, events: CognitionEvent[], kind: ContextSourceDescriptor['kind'], entityId: string, contextId: string | null, snapshotId: string | null, status: string | null, scope: string | null, paths: string[]): ContextSourceDescriptor;
+export declare function loadCompilerSources(startPath: string | undefined, options: ContextCompileOptions): Promise<CompilerSources>;
+export declare function latestHostIntent(events: CognitionEvent[], anchor: ContextAnchor): {
+    value: string;
+    eventId: string;
+} | null;

package/dist/src/compiler/sources.js

@@ -0,0 +1,126 @@
+import { readGitWorktreeState } from '../git/git-adapter.js';
+import { contextOrient } from '../agent/api.js';
+import { readJournal } from '../cognition/journal.js';
+import { projectEvents, workspaceKey } from '../cognition/projections.js';
+function anchorFromGit(git, projectRoot) {
+    return {
+        projectRoot,
+        worktreeId: git.worktreeId,
+        branch: git.branch,
+        ref: git.ref,
+        head: git.commit,
+    };
+}
+function payloadRecord(event) {
+    const payload = event.payload;
+    return payload.record && typeof payload.record === 'object' && !Array.isArray(payload.record)
+        ? payload.record
+        : null;
+}
+function matchesRecord(event, entityId) {
+    if (event.eventId === entityId)
+        return true;
+    const record = payloadRecord(event);
+    return record?.contextId === entityId
+        || record?.knowledgeId === entityId
+        || record?.deadendId === entityId
+        || record?.noteId === entityId
+        || record?.snapshotId === entityId;
+}
+export function sourceApplicability(event, anchor) {
+    if (!event || (event.git.branch === null && event.git.ref === null)) {
+        return { project: true, branchMode: 'global', branches: [], paths: [], worktreeId: null, ref: null };
+    }
+    return {
+        project: true,
+        branchMode: 'exact',
+        branches: [event.git.ref ?? event.git.branch ?? 'detached'],
+        paths: [],
+        worktreeId: event.git.worktreeId,
+        ref: event.git.ref,
+    };
+}
+export function provenanceFor(events, entityId, anchor) {
+    const event = [...events].reverse().find((item) => matchesRecord(item, entityId));
+    if (!event) {
+        return {
+            origin: 'v1-file',
+            eventId: null,
+            eventType: null,
+            occurredAt: null,
+            sourcePath: null,
+            sourceHash: null,
+            anchorProvenance: null,
+        };
+    }
+    const payload = event.payload;
+    return {
+        origin: 'v2-journal',
+        eventId: event.eventId,
+        eventType: event.type,
+        occurredAt: event.occurredAt,
+        sourcePath: typeof payload.sourcePath === 'string' ? payload.sourcePath : null,
+        sourceHash: typeof payload.sourceHash === 'string' ? payload.sourceHash : null,
+        anchorProvenance: payload.anchorProvenance === 'snapshot' || payload.anchorProvenance === 'live' || payload.anchorProvenance === 'global'
+            ? payload.anchorProvenance
+            : null,
+    };
+}
+export function sourceDescriptor(projectRoot, anchor, events, kind, entityId, contextId, snapshotId, status, scope, paths) {
+    const provenance = provenanceFor(events, entityId, anchor);
+    const event = provenance.eventId ? events.find((item) => item.eventId === provenance.eventId) ?? null : null;
+    return {
+        sourceId: `${kind}:${entityId}`,
+        kind,
+        entityId,
+        contextId,
+        snapshotId,
+        status,
+        scope,
+        paths: [...new Set(paths)].sort(),
+        anchor,
+        applicability: sourceApplicability(event, anchor),
+        privacy: { classification: provenance.origin === 'v2-journal' ? (event?.privacy.classification ?? 'metadata') : 'metadata', redactionCount: event?.privacy.redactionCount ?? 0 },
+        provenance,
+    };
+}
+export async function loadCompilerSources(startPath, options) {
+    const orientation = await contextOrient(startPath, {
+        contextId: options.contextId,
+        query: options.query,
+        scope: options.scope,
+        maxChars: Number.MAX_SAFE_INTEGER,
+        knowledgeLimit: options.knowledgeLimit ?? 10,
+        deadendLimit: options.deadendLimit ?? 10,
+        noteLimit: options.noteLimit ?? 20,
+    });
+    const projectRoot = orientation.projectRoot;
+    const git = await readGitWorktreeState(projectRoot);
+    let events = [];
+    let fallbackReason = null;
+    try {
+        events = await readJournal(projectRoot);
+    }
+    catch (error) {
+        fallbackReason = error instanceof Error ? error.message : 'journal-unavailable';
+    }
+    const anchor = anchorFromGit(git, projectRoot);
+    const projection = events.length > 0 ? projectEvents(events) : null;
+    const workspace = projection?.workspaces[workspaceKey(anchor)] ?? null;
+    return { orientation, anchor, events, workspace, fallbackReason };
+}
+export function latestHostIntent(events, anchor) {
+    const event = [...events].reverse().find((candidate) => {
+        if (candidate.type !== 'host.prompt.submitted')
+            return false;
+        if (candidate.git.worktreeId !== null && candidate.git.worktreeId !== anchor.worktreeId)
+            return false;
+        if (candidate.git.ref !== null && candidate.git.ref !== anchor.ref)
+            return false;
+        const payload = candidate.payload;
+        return typeof payload.intent === 'string' && payload.intent.trim().length > 0;
+    });
+    if (!event)
+        return null;
+    return { value: event.payload.intent, eventId: event.eventId };
+}

package/dist/src/compiler/types.d.ts

@@ -0,0 +1,233 @@
+import type { CognitionGitAnchor, WorkspacePathChange } from '../cognition/types.js';
+import type { ContextOrientResult } from '../agent/types.js';
+import type { Deadend, Knowledge, Note, ResumeSummary, StructuredContext } from '../runtime/types.js';
+export type ContextScenario = 'resume' | 'implementation' | 'debugging' | 'verification' | 'handoff' | 'exploration' | 'unknown';
+export type ContextLevel = 'signal' | 'summary' | 'structured' | 'evidence';
+export type ContextExpandLevel = 'structured' | 'evidence';
+export type ContextSourceKind = 'current-context' | 'checkpoint' | 'note' | 'journal' | 'knowledge' | 'deadend';
+export type ContextCandidateSection = 'summary' | 'pending' | 'decision' | 'risk' | 'note' | 'knowledge' | 'deadend' | 'activity';
+export type ContextSignalOrigin = 'explicit' | 'deterministic';
+export interface ContextAnchor {
+    projectRoot: string;
+    worktreeId: string | null;
+    branch: string | null;
+    ref: string | null;
+    head: string | null;
+}
+export interface ContextIntentSignal {
+    source: 'explicit-query' | 'explicit-scenario' | 'context-state' | 'host-prompt' | 'path' | 'git';
+    value: string;
+    origin: ContextSignalOrigin;
+    confidence: 'high' | 'medium' | 'low';
+}
+export interface ContextIntent {
+    schemaVersion: 1;
+    trigger: 'session-start' | 'prompt' | 'manual' | 'tool-call';
+    query: string | null;
+    normalizedTerms: string[];
+    scenario: ContextScenario;
+    scope: string | null;
+    paths: string[];
+    contextId: string | null;
+    anchor: ContextAnchor;
+    signals: ContextIntentSignal[];
+    requestedSections: ContextCandidateSection[];
+    budget: ContextBudget;
+    adapter: string;
+    sessionId: string | null;
+    eventId: string | null;
+}
+export interface ContextBudget {
+    unit: 'chars';
+    total: number;
+    reservedForRenderer: number;
+    sections?: Partial<Record<ContextCandidateSection, number>>;
+}
+export interface ContextTokenEstimate {
+    input: number;
+    output: number;
+    unit: 'estimated-tokens';
+    method: 'chars-div-four';
+}
+export interface ContextSourceApplicability {
+    project: true;
+    branchMode: 'global' | 'exact' | 'unsupported';
+    branches: string[];
+    paths: string[];
+    worktreeId: string | null;
+    ref: string | null;
+}
+export interface ContextProvenance {
+    origin: 'v1-file' | 'v2-journal' | 'mixed' | 'live';
+    eventId: string | null;
+    eventType: string | null;
+    occurredAt: string | null;
+    sourcePath: string | null;
+    sourceHash: string | null;
+    anchorProvenance: 'snapshot' | 'live' | 'global' | null;
+}
+export interface ContextSourceDescriptor {
+    sourceId: string;
+    kind: ContextSourceKind;
+    entityId: string;
+    contextId: string | null;
+    snapshotId: string | null;
+    status: string | null;
+    scope: string | null;
+    paths: string[];
+    anchor: ContextAnchor;
+    applicability: ContextSourceApplicability;
+    privacy: {
+        classification: 'metadata' | 'redacted-text' | 'unknown';
+        redactionCount: number;
+    };
+    provenance: ContextProvenance;
+}
+export interface ContextActivityRecord {
+    eventId: string;
+    occurredAt: string;
+    anchor: ContextAnchor;
+    paths: string[];
+    changes: WorkspacePathChange[];
+    pathCount: number;
+    coalesced: boolean;
+    truncated: boolean;
+    focusMatch: boolean;
+}
+export interface ContextCandidate<T = unknown> {
+    candidateId: string;
+    section: ContextCandidateSection;
+    source: ContextSourceDescriptor;
+    content: T;
+    text: string;
+    priority: number;
+    score: number;
+    matchedTerms: string[];
+    matchedFields: string[];
+    originalChars: number;
+    selectedChars: number;
+    selected: boolean;
+    truncated: boolean;
+    level: ContextLevel;
+    itemHash: string;
+    tokenEstimate: number;
+    expandable: boolean;
+}
+export type ContextExclusionReason = 'no_active_context' | 'context_mismatch' | 'status_not_verified' | 'not_open' | 'absorbed' | 'applicability_mismatch' | 'scope_mismatch' | 'path_mismatch' | 'query_no_match' | 'result_limit' | 'budget' | 'unsupported_applicability' | 'v2_unavailable';
+export interface ContextExclusion {
+    candidateId: string;
+    source: ContextSourceDescriptor | null;
+    reason: ContextExclusionReason;
+    detail?: string;
+}
+export interface ContextTruncation {
+    truncated: boolean;
+    summary: boolean;
+    pending: boolean;
+    decisions: boolean;
+    risks: boolean;
+    notes: boolean;
+    knowledge: boolean;
+    deadends: boolean;
+    activity: boolean;
+    candidatesOmittedByBudget: number;
+    candidatesPartiallyTruncated: number;
+}
+export interface ContextBudgetReport {
+    requested: ContextBudget;
+    usedChars: number;
+    remainingChars: number;
+    sections: Partial<Record<ContextCandidateSection, {
+        allocated: number;
+        consumed: number;
+        truncated: boolean;
+    }>>;
+}
+export interface ContextManifestProvenance {
+    journalRead: boolean;
+    journalEventCount: number;
+    selectedSourceIds: string[];
+    selectedEventIds: string[];
+    fallbackReason: string | null;
+}
+export interface ContextManifestIdentity {
+    manifestHash: string;
+    selectedItemHashes: string[];
+    tokenEstimate: ContextTokenEstimate;
+}
+export interface ContextCompileOptions {
+    contextId?: string;
+    query?: string;
+    scenario?: ContextScenario;
+    scope?: string;
+    paths?: string[];
+    maxChars?: number;
+    knowledgeLimit?: number;
+    deadendLimit?: number;
+    noteLimit?: number;
+    activityLimit?: number;
+    trigger?: ContextIntent['trigger'];
+    adapter?: string;
+    sessionId?: string;
+    eventId?: string;
+}
+export interface ContextExpandInput {
+    manifestHash: string;
+    candidateId?: string;
+    itemHash?: string;
+    level: ContextExpandLevel;
+    maxChars?: number;
+    compile: ContextCompileOptions;
+}
+export interface ContextExpandResult {
+    status: 'complete' | 'partial';
+    projectRoot: string;
+    manifestHash: string;
+    candidateId: string;
+    itemHash: string;
+    previousLevel: ContextLevel;
+    requestedLevel: ContextExpandLevel;
+    resolvedLevel: ContextExpandLevel;
+    source: ContextSourceDescriptor;
+    content: unknown | null;
+    text: string;
+    budget: {
+        requestedChars: number;
+        usedChars: number;
+        remainingChars: number;
+        truncated: boolean;
+    };
+    provenance: ContextManifestProvenance;
+}
+export interface ContextManifest {
+    schemaVersion: 1;
+    compilerVersion: '0.7.6';
+    rankingVersion: 'compiler-ranking-v2';
+    status: 'ready' | 'no_context';
+    projectRoot: string;
+    mode: 'v2' | 'v1-fallback';
+    anchor: ContextAnchor;
+    intent: ContextIntent;
+    context: ContextOrientResult['context'];
+    snapshot: ContextOrientResult['snapshot'];
+    resumeSummary: ResumeSummary | null;
+    sections: {
+        summary: ContextCandidate[];
+        pending: ContextCandidate[];
+        decision: ContextCandidate[];
+        risk: ContextCandidate[];
+        notes: ContextCandidate[];
+        knowledge: ContextCandidate[];
+        deadends: ContextCandidate[];
+        activity: ContextCandidate<ContextActivityRecord>[];
+    };
+    selected: ContextCandidate[];
+    excluded: ContextExclusion[];
+    identity: ContextManifestIdentity;
+    budget: ContextBudgetReport;
+    truncation: ContextTruncation;
+    provenance: ContextManifestProvenance;
+    text: string;
+}
+export type CompilerRecord = StructuredContext | Note | Knowledge | Deadend;
+export type CompilerGitAnchor = CognitionGitAnchor;

package/dist/src/compiler/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/claude-code.js

@@ -1,11 +1,10 @@
 import { contextOrient } from '../agent/api.js';
 import { appendEvent } from '../cognition/journal.js';
 import { v2Enabled } from '../cognition/orient.js';
-import { startRuntime } from '../cognition/runtime.js';
+import { ensureRuntimeForSession, touchRuntime } from '../cognition/runtime.js';
+import { loadRuntimePolicy } from '../cognition/policy.js';
 import { readGitWorktreeState } from '../git/git-adapter.js';
 import { resolveProjectRoot } from '../project/project-resolver.js';
-import { cognitionPolicyPath } from '../storage/layout.js';
-import { readJson } from '../storage/json-store.js';
 const HOOK_RESPONSE = '{}\n';
 function text(value) {
     return typeof value === 'string' ? value : undefined;
@@ -68,15 +67,12 @@ function redactIntent(value) {
         .replace(/\b(?:sk|ghp|gho|github_pat)_[A-Za-z0-9_-]+\b/g, () => { redactionCount += 1; return '[REDACTED]'; });
     return { intent, redactionCount };
 }
-async function within(task, milliseconds) {
-    return Promise.race([task, new Promise((_, reject) => setTimeout(() => reject(new Error('hook deadline exceeded')), milliseconds))]);
-}
 async function capture(event, input) {
     const cwd = text(input.cwd);
     const projectRoot = await resolveProjectRoot(cwd);
     if (!await v2Enabled(projectRoot))
         return;
-    const policy = await readJson(cognitionPolicyPath(projectRoot));
+    const policy = await loadRuntimePolicy(projectRoot);
     const sessionId = stableId(input, 'session');
     const eventId = stableId(input, 'event');
     if (!sessionId || !eventId)
@@ -94,12 +90,7 @@ async function capture(event, input) {
     });
 }
 async function maybeStartRuntime(input) {
-    const projectRoot = await resolveProjectRoot(text(input.cwd));
-    if (!await v2Enabled(projectRoot))
-        return;
-    const policy = await readJson(cognitionPolicyPath(projectRoot));
-    if (policy.allowHookStartup)
-        await within(startRuntime(projectRoot), 1_000);
+    await ensureRuntimeForSession(text(input.cwd), { source: 'claude-hook', timeoutMs: 1_000 });
 }
 async function parseInput(raw) {
     try {
@@ -115,9 +106,10 @@ export async function runClaudeCodeHook(event, raw) {
     if (!input)
         return HOOK_RESPONSE;
     try {
-        if (event === 'session-start')
-            await maybeStartRuntime(input).catch(() => undefined);
+        await maybeStartRuntime(input).catch(() => undefined);
+        await touchRuntime(text(input.cwd)).catch(() => false);
         await capture(event, input).catch(() => undefined);
+        await touchRuntime(text(input.cwd)).catch(() => false);
         const cwd = text(input.cwd);
         const result = event === 'session-start'
             ? await contextOrient(cwd, { maxChars: 1200, noteLimit: 8 })

package/dist/src/mcp/main.js

@@ -1,5 +1,7 @@
 import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { ensureRuntimeForSession } from '../cognition/runtime.js';
 import { createMcpServer } from './server.js';
+await ensureRuntimeForSession(process.cwd(), { source: 'mcp', timeoutMs: 1_000 }).catch(() => undefined);
 serveStdio(createMcpServer, {
     onerror: (error) => process.stderr.write(`MCP server error: ${error.message}\n`),
 });