fluffy-context 0.7.7 → 1.0.0-beta.1

package/dist/src/cognition/evidence-graph.js

@@ -0,0 +1,187 @@
+import crypto from 'node:crypto';
+export const EVIDENCE_GRAPH_DERIVATION_VERSION = 'evidence-graph-v1';
+function hash(value) {
+    return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function record(event) {
+    const value = event.payload.record;
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function normalizePath(value) {
+    const normalized = value.replaceAll('\\', '/');
+    return normalized.length > 0 && !normalized.startsWith('/') && !normalized.includes('\0') && !normalized.split('/').includes('..') ? normalized : null;
+}
+function entityKind(entity) {
+    if (entity === 'compiler-recipe')
+        return 'recipe';
+    if (entity === 'knowledge' || entity === 'deadend' || entity === 'skill' || entity === 'experience' || entity === 'proposal')
+        return entity;
+    return null;
+}
+function entityNodeId(entity, entityId) {
+    const kind = entityKind(entity);
+    return kind && entityId.trim().length > 0 ? `${kind}:${entityId}` : null;
+}
+export function workspaceNodeId(anchor) {
+    return `branch-worktree:${hash({ worktreeId: anchor.worktreeId, branch: anchor.branch, ref: anchor.ref }).slice(0, 16)}`;
+}
+function addNode(nodes, nodeId, kind) {
+    nodes.set(nodeId, { nodeId, kind });
+}
+function addEntityNode(nodes, entity, entityId) {
+    const nodeId = entityNodeId(entity, entityId);
+    const kind = entityKind(entity);
+    if (nodeId && kind)
+        addNode(nodes, nodeId, kind);
+    return nodeId;
+}
+function addEdge(edges, input) {
+    const sourceEventIds = [...new Set(input.sourceEventIds)].sort();
+    const basis = { from: input.from, to: input.to, type: input.type, sourceEventIds, occurredAt: input.occurredAt, confidence: input.confidence };
+    const edgeId = `edge:${hash(basis).slice(0, 24)}`;
+    edges.set(edgeId, { ...input, edgeId, sourceEventIds, derivationVersion: EVIDENCE_GRAPH_DERIVATION_VERSION });
+}
+function anchorNodes(event, nodes) {
+    const workspace = workspaceNodeId(event.git);
+    addNode(nodes, workspace, 'branch-worktree');
+    if (event.git.head)
+        addNode(nodes, `commit:${event.git.head}`, 'commit');
+    return workspace;
+}
+function lineageEdge(edges, nodes, from, lineage, event) {
+    const target = addEntityNode(nodes, lineage.entity, lineage.entityId);
+    if (!target)
+        return;
+    addEdge(edges, { from, to: target, type: lineage.relation, sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+}
+function sourceLinks(edges, nodes, from, contextIds, snapshotIds, event) {
+    if (Array.isArray(contextIds))
+        for (const contextId of contextIds)
+            if (typeof contextId === 'string' && contextId.trim()) {
+                const target = `context:${contextId}`;
+                addNode(nodes, target, 'context');
+                addEdge(edges, { from, to: target, type: 'derived_from', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+            }
+    if (Array.isArray(snapshotIds))
+        for (const snapshotId of snapshotIds)
+            if (typeof snapshotId === 'string' && snapshotId.trim()) {
+                const target = `snapshot:${snapshotId}`;
+                addNode(nodes, target, 'snapshot');
+                addEdge(edges, { from, to: target, type: 'derived_from', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+            }
+}
+export function buildEvidenceGraph(events) {
+    const nodes = new Map();
+    const edges = new Map();
+    for (const event of events) {
+        const workspace = anchorNodes(event, nodes);
+        if (event.git.head)
+            addEdge(edges, { from: workspace, to: `commit:${event.git.head}`, type: 'changed_in', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+        const value = record(event);
+        if (event.type === 'context.checkpoint.imported' || event.type === 'context.state.recorded') {
+            const snapshot = value?.snapshot;
+            if (snapshot && typeof snapshot.contextId === 'string' && typeof snapshot.snapshotId === 'string') {
+                const context = `context:${snapshot.contextId}`;
+                const snap = `snapshot:${snapshot.snapshotId}`;
+                addNode(nodes, context, 'context');
+                addNode(nodes, snap, 'snapshot');
+                addEdge(edges, { from: context, to: snap, type: 'derived_from', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+            }
+        }
+        if (event.type === 'experience.recorded' && typeof value?.experienceId === 'string') {
+            const id = addEntityNode(nodes, 'experience', value.experienceId);
+            sourceLinks(edges, nodes, id, value.sourceContextIds, value.sourceSnapshotIds, event);
+            if (Array.isArray(value.paths))
+                for (const item of value.paths)
+                    if (typeof item === 'string') {
+                        const path = normalizePath(item);
+                        if (!path)
+                            continue;
+                        const target = `path:${path}`;
+                        addNode(nodes, target, 'path');
+                        addEdge(edges, { from: id, to: target, type: 'observed_in', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+                    }
+        }
+        if (event.type === 'evolution.proposed' && typeof value?.proposalId === 'string') {
+            const id = addEntityNode(nodes, 'proposal', value.proposalId);
+            if (Array.isArray(value.sourceExperienceIds))
+                for (const source of value.sourceExperienceIds)
+                    if (typeof source === 'string') {
+                        const target = addEntityNode(nodes, 'experience', source);
+                        if (target)
+                            addEdge(edges, { from: id, to: target, type: 'derived_from', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+                    }
+            if (Array.isArray(value.lineage))
+                for (const item of value.lineage)
+                    if (item && typeof item === 'object')
+                        lineageEdge(edges, nodes, id, item, event);
+        }
+        if (['knowledge.proposed', 'knowledge.verified', 'knowledge.deprecated', 'knowledge.rejected'].includes(event.type) && typeof value?.knowledgeId === 'string') {
+            const id = addEntityNode(nodes, 'knowledge', value.knowledgeId);
+            sourceLinks(edges, nodes, id, value.sourceContextIds, value.sourceSnapshotIds, event);
+        }
+        if (['deadend.proposed', 'deadend.verified', 'deadend.obsoleted', 'deadend.rejected'].includes(event.type) && typeof value?.deadendId === 'string') {
+            const id = addEntityNode(nodes, 'deadend', value.deadendId);
+            sourceLinks(edges, nodes, id, value.sourceContextId === null ? [] : [value.sourceContextId], value.sourceSnapshotId === null ? [] : [value.sourceSnapshotId], event);
+        }
+        if (event.type === 'skill.materialized' && typeof value?.skillId === 'string') {
+            const id = addEntityNode(nodes, 'skill', value.skillId);
+            const proposal = typeof value.proposalId === 'string' ? addEntityNode(nodes, 'proposal', value.proposalId) : null;
+            if (proposal)
+                addEdge(edges, { from: id, to: proposal, type: 'derived_from', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+            if (Array.isArray(value.lineage))
+                for (const item of value.lineage)
+                    if (item && typeof item === 'object')
+                        lineageEdge(edges, nodes, id, item, event);
+        }
+        if (event.type === 'recipe.materialized' && typeof value?.recipeId === 'string') {
+            const id = addEntityNode(nodes, 'compiler-recipe', value.recipeId);
+            const proposal = typeof value.proposalId === 'string' ? addEntityNode(nodes, 'proposal', value.proposalId) : null;
+            if (proposal)
+                addEdge(edges, { from: id, to: proposal, type: 'derived_from', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+            if (Array.isArray(value.lineage))
+                for (const item of value.lineage)
+                    if (item && typeof item === 'object')
+                        lineageEdge(edges, nodes, id, item, event);
+        }
+        if (event.type === 'evolution.superseded') {
+            const transition = event.payload.transition;
+            if (transition && typeof transition === 'object' && !Array.isArray(transition)) {
+                const value = transition;
+                const from = typeof value.entity === 'string' && typeof value.entityId === 'string' ? addEntityNode(nodes, value.entity, value.entityId) : null;
+                const supersedes = value.supersedes;
+                if (from && supersedes && typeof supersedes === 'object' && !Array.isArray(supersedes)) {
+                    const reference = supersedes;
+                    lineageEdge(edges, nodes, from, reference, event);
+                }
+            }
+        }
+        if (event.type === 'workspace.paths.changed') {
+            const payload = event.payload;
+            if (Array.isArray(payload.paths))
+                for (const item of payload.paths)
+                    if (typeof item === 'string') {
+                        const path = normalizePath(item);
+                        if (!path)
+                            continue;
+                        const target = `path:${path}`;
+                        addNode(nodes, target, 'path');
+                        addEdge(edges, { from: workspace, to: target, type: 'observed_in', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+                    }
+        }
+        if (event.type === 'record.used') {
+            const used = event.payload;
+            if (typeof used.entity === 'string' && typeof used.entityId === 'string') {
+                const from = addEntityNode(nodes, used.entity, used.entityId);
+                if (from)
+                    addEdge(edges, { from, to: workspace, type: 'used_for', sourceEventIds: [event.eventId], occurredAt: event.occurredAt });
+            }
+        }
+    }
+    return {
+        schemaVersion: 1,
+        derivationVersion: EVIDENCE_GRAPH_DERIVATION_VERSION,
+        nodes: [...nodes.values()].sort((a, b) => a.nodeId.localeCompare(b.nodeId)),
+        edges: [...edges.values()].sort((a, b) => a.edgeId.localeCompare(b.edgeId)),
+    };
+}

package/dist/src/cognition/evolution.d.ts

@@ -0,0 +1,36 @@
+import type { EvolutionArtifactKind, EvolutionArtifactStatus, EvolutionLineageReference, EvolutionProposalState } from './types.js';
+type ProposalTargetKind = Extract<EvolutionArtifactKind, 'skill' | 'compiler-recipe'>;
+export interface ProposeEvolutionInput {
+    eventIds?: string[];
+    recentLimit?: number;
+    targetKind?: ProposalTargetKind;
+}
+export interface ProposeEvolutionResult {
+    experienceId: string;
+    experienceEventId: string;
+    proposalId: string | null;
+    proposalEventId: string | null;
+    recorded: boolean;
+}
+export interface AcceptEvolutionCandidateInput {
+    proposalId: string;
+    rationale: string;
+}
+export interface TransitionEvolutionProposalInput {
+    proposalId: string;
+    to: Extract<EvolutionArtifactStatus, 'verified' | 'rejected' | 'deprecated' | 'superseded'>;
+    rationale: string;
+    supersedes?: EvolutionLineageReference;
+}
+export declare function proposeEvolution(startPath: string | undefined, input?: ProposeEvolutionInput): Promise<ProposeEvolutionResult>;
+export declare function listEvolutionProposals(startPath?: string): Promise<EvolutionProposalState[]>;
+export declare function inspectEvolutionProposal(startPath: string | undefined, proposalId: string): Promise<EvolutionProposalState>;
+export declare function acceptEvolutionCandidate(startPath: string | undefined, input: AcceptEvolutionCandidateInput): Promise<{
+    accepted: boolean;
+    eventId: string;
+}>;
+export declare function transitionEvolutionProposal(startPath: string | undefined, input: TransitionEvolutionProposalInput): Promise<{
+    transitioned: boolean;
+    eventId: string;
+}>;
+export {};

package/dist/src/cognition/evolution.js

@@ -0,0 +1,221 @@
+import crypto from 'node:crypto';
+import { readGitWorktreeState } from '../git/git-adapter.js';
+import { resolveProjectRoot } from '../project/project-resolver.js';
+import { appendEvent, readJournal } from './journal.js';
+import { v2Enabled } from './orient.js';
+import { projectEvents, rebuildProjections } from './projections.js';
+const extractor = { id: 'deterministic-maintainer', version: '1' };
+const maxEvidenceEvents = 32;
+const allowedEvidenceTypes = new Set([
+    'host.prompt.submitted',
+    'context.checkpoint.imported', 'context.state.recorded',
+    'note.recorded', 'note.resolved', 'note.absorbed',
+    'git.state.observed', 'git.branch.changed', 'git.head.changed',
+    'workspace.paths.changed', 'record.used', 'usage.operation.completed',
+]);
+function canonical(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(',')}}`;
+}
+function hash(value) {
+    return crypto.createHash('sha256').update(canonical(value)).digest('hex');
+}
+function anchor(event) {
+    return { worktreeId: event.git.worktreeId, branch: event.git.branch, ref: event.git.ref, head: event.git.head };
+}
+function currentAnchor(state) {
+    return { worktreeId: state.worktreeId, branch: state.branch, ref: state.ref, head: state.commit };
+}
+function requireReason(reason) {
+    const value = reason.trim();
+    if (!value)
+        throw new Error('evolution rationale must not be empty');
+    return value;
+}
+function selectEvidence(events, input) {
+    const selected = input.eventIds
+        ? input.eventIds.map((eventId) => {
+            if (!eventId.trim())
+                throw new Error('evidence event ID must not be empty');
+            return eventId;
+        })
+        : events.filter((event) => allowedEvidenceTypes.has(event.type)).slice(-(input.recentLimit ?? maxEvidenceEvents)).map((event) => event.eventId);
+    if (selected.length === 0)
+        throw new Error('evolution extraction requires evidence events');
+    if (selected.length > maxEvidenceEvents)
+        throw new Error(`evolution extraction supports at most ${maxEvidenceEvents} evidence events`);
+    if (new Set(selected).size !== selected.length)
+        throw new Error('evolution evidence event IDs must be unique');
+    const byId = new Map(events.map((event) => [event.eventId, event]));
+    const evidence = selected.map((eventId) => byId.get(eventId));
+    if (evidence.some((event) => !event))
+        throw new Error('evolution evidence event was not found');
+    if (evidence.some((event) => !allowedEvidenceTypes.has(event.type)))
+        throw new Error('evolution evidence event type is not allowed');
+    return evidence;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
+}
+function sourceReferences(events) {
+    const contextIds = new Set();
+    const snapshotIds = new Set();
+    const paths = new Set();
+    for (const event of events) {
+        const payload = event.payload;
+        const record = payload.record;
+        if (record && typeof record === 'object' && !Array.isArray(record)) {
+            const item = record;
+            const snapshot = item.snapshot;
+            if (snapshot && typeof snapshot === 'object' && !Array.isArray(snapshot)) {
+                const value = snapshot;
+                if (typeof value.contextId === 'string')
+                    contextIds.add(value.contextId);
+                if (typeof value.snapshotId === 'string')
+                    snapshotIds.add(value.snapshotId);
+            }
+            if (typeof item.contextId === 'string')
+                contextIds.add(item.contextId);
+            if (typeof item.snapshotId === 'string')
+                snapshotIds.add(item.snapshotId);
+        }
+        for (const value of stringArray(payload.paths))
+            paths.add(value.replaceAll('\\', '/'));
+    }
+    return { contextIds: [...contextIds].sort(), snapshotIds: [...snapshotIds].sort(), paths: [...paths].sort() };
+}
+function privacy(events) {
+    const redactionCount = events.reduce((total, event) => total + event.privacy.redactionCount, 0);
+    return { classification: events.some((event) => event.privacy.classification === 'redacted-text') ? 'redacted-text' : 'metadata', redactionCount };
+}
+function applicability(event) {
+    if (event.git.ref === null && event.git.branch === null)
+        return { project: true, branchMode: 'global' };
+    return { project: true, branchMode: 'exact', branches: [event.git.ref ?? event.git.branch ?? 'detached'], sourceCommit: event.git.head };
+}
+function candidateEligible(events) {
+    const hasContext = events.some((event) => event.type === 'context.checkpoint.imported' || event.type === 'context.state.recorded');
+    const hasActivity = events.some((event) => event.type.startsWith('git.') || event.type === 'workspace.paths.changed');
+    const hasUse = events.some((event) => event.type === 'record.used');
+    return hasContext && hasActivity && hasUse;
+}
+async function enabledProject(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    if (!await v2Enabled(projectRoot))
+        throw new Error('evolution requires an enabled v2 runtime');
+    return projectRoot;
+}
+export async function proposeEvolution(startPath, input = {}) {
+    const projectRoot = await enabledProject(startPath);
+    const events = await readJournal(projectRoot);
+    const evidence = selectEvidence(events, input);
+    const references = sourceReferences(evidence);
+    const sourceEventIds = evidence.map((event) => event.eventId);
+    const last = evidence.at(-1);
+    const experienceBasis = { sourceEventIds, sourceContextIds: references.contextIds, sourceSnapshotIds: references.snapshotIds, paths: references.paths, git: anchor(last), privacy: privacy(evidence), extractor, createdAt: last.occurredAt };
+    const experience = {
+        experienceId: `exp-${hash(experienceBasis).slice(0, 20)}`,
+        schemaVersion: 1,
+        ...experienceBasis,
+        contentHash: hash(experienceBasis),
+        summary: `Metadata-only experience from ${sourceEventIds.length} journal events.`,
+    };
+    const experienceResult = await appendEvent(projectRoot, {
+        type: 'experience.recorded', source: { kind: 'agent' }, occurredAt: experience.createdAt,
+        idempotencyKey: `experience:${experience.experienceId}`, git: experience.git,
+        privacy: experience.privacy, payload: { record: experience },
+    });
+    let proposalResult = null;
+    let proposal = null;
+    if (candidateEligible(evidence)) {
+        const targetKind = input.targetKind ?? 'skill';
+        const proposalBasis = { sourceExperienceIds: [experience.experienceId], evidence: sourceEventIds.map((eventId) => ({ eventId, relation: 'derived_from' })), applicability: applicability(last), targetKind, extractor, createdAt: experience.createdAt };
+        const contentHash = hash(proposalBasis);
+        proposal = {
+            proposalId: `proposal-${contentHash.slice(0, 20)}`,
+            schemaVersion: 1,
+            targetKind,
+            targetId: `${targetKind}-${contentHash.slice(0, 20)}`,
+            status: 'candidate',
+            sourceExperienceIds: proposalBasis.sourceExperienceIds,
+            evidence: proposalBasis.evidence,
+            lineage: [],
+            applicability: proposalBasis.applicability,
+            contentHash,
+            summary: `Candidate ${targetKind} derived from metadata-only experience ${experience.experienceId}.`,
+            extractor,
+            createdAt: experience.createdAt,
+        };
+        proposalResult = await appendEvent(projectRoot, {
+            type: 'evolution.proposed', source: { kind: 'agent' }, occurredAt: proposal.createdAt,
+            idempotencyKey: `evolution-proposal:${proposal.proposalId}`, git: experience.git,
+            privacy: experience.privacy, payload: { record: proposal },
+        });
+    }
+    if (experienceResult.appended || proposalResult?.appended)
+        await rebuildProjections(projectRoot);
+    return { experienceId: experience.experienceId, experienceEventId: experienceResult.event.eventId, proposalId: proposal?.proposalId ?? null, proposalEventId: proposalResult?.event.eventId ?? null, recorded: experienceResult.appended || Boolean(proposalResult?.appended) };
+}
+export async function listEvolutionProposals(startPath) {
+    const projectRoot = await enabledProject(startPath);
+    return Object.values(projectEvents(await readJournal(projectRoot)).proposals).sort((left, right) => left.proposal.proposalId.localeCompare(right.proposal.proposalId));
+}
+export async function inspectEvolutionProposal(startPath, proposalId) {
+    const proposal = (await listEvolutionProposals(startPath)).find((item) => item.proposal.proposalId === proposalId);
+    if (!proposal)
+        throw new Error(`evolution proposal not found: ${proposalId}`);
+    return proposal;
+}
+export async function acceptEvolutionCandidate(startPath, input) {
+    const projectRoot = await enabledProject(startPath);
+    const rationale = requireReason(input.rationale);
+    const state = await inspectEvolutionProposal(projectRoot, input.proposalId);
+    if (state.proposal.targetKind !== 'skill' && state.proposal.targetKind !== 'compiler-recipe')
+        throw new Error('only skill and compiler-recipe proposals can be accepted in Phase 1');
+    if (state.status !== 'candidate')
+        throw new Error(`candidate acceptance requires a candidate proposal: ${input.proposalId}`);
+    if (state.acceptedArtifact)
+        throw new Error(`candidate artifact already accepted: ${input.proposalId}`);
+    const git = await readGitWorktreeState(projectRoot);
+    const artifact = {
+        artifactId: state.proposal.targetId,
+        schemaVersion: 1,
+        proposalId: state.proposal.proposalId,
+        kind: state.proposal.targetKind,
+        status: 'candidate',
+        applicability: state.proposal.applicability,
+        contentHash: state.proposal.contentHash,
+        lineage: state.proposal.lineage,
+        rationale,
+        createdAt: new Date().toISOString(),
+    };
+    const result = await appendEvent(projectRoot, {
+        type: 'evolution.candidate.accepted', source: { kind: 'cli' }, idempotencyKey: `evolution-accept:${artifact.artifactId}:${hash(rationale).slice(0, 16)}`,
+        git: currentAnchor(git), payload: { record: artifact },
+    });
+    if (result.appended)
+        await rebuildProjections(projectRoot);
+    return { accepted: result.appended, eventId: result.event.eventId };
+}
+export async function transitionEvolutionProposal(startPath, input) {
+    const projectRoot = await enabledProject(startPath);
+    const rationale = requireReason(input.rationale);
+    const state = await inspectEvolutionProposal(projectRoot, input.proposalId);
+    if (input.to === 'superseded' && !input.supersedes)
+        throw new Error('superseding an evolution proposal requires lineage');
+    const git = await readGitWorktreeState(projectRoot);
+    const result = await appendEvent(projectRoot, {
+        type: `evolution.${input.to}`,
+        source: { kind: 'cli' },
+        idempotencyKey: `evolution-transition:${input.proposalId}:${state.status}:${input.to}:${hash({ rationale, supersedes: input.supersedes }).slice(0, 16)}`,
+        git: currentAnchor(git),
+        payload: { transition: { entity: 'proposal', entityId: input.proposalId, from: state.status, to: input.to, reason: rationale, ...(input.supersedes ? { supersedes: input.supersedes } : {}) } },
+    });
+    if (result.appended)
+        await rebuildProjections(projectRoot);
+    return { transitioned: result.appended, eventId: result.event.eventId };
+}

package/dist/src/cognition/import-memory.d.ts

@@ -0,0 +1,18 @@
+export declare function importMemory(startPath?: string, apply?: boolean): Promise<{
+    projectRoot: string;
+    applied: boolean;
+    scannedBytes: number;
+    results: {
+        status: string;
+        knowledgeId: string | null;
+        source: string;
+        line: number;
+        statement: string;
+        fingerprint: string;
+    }[];
+    skipped: {
+        source: string;
+        reason: string;
+    }[];
+    trust: string;
+}>;

package/dist/src/cognition/import-memory.js

@@ -0,0 +1,124 @@
+import { lstat, readdir, readFile, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { resolveProjectRoot } from '../project/project-resolver.js';
+import { filterPaths } from '../capture/context-filter.js';
+import { learnKnowledge, listKnowledge } from '../runtime/knowledge.js';
+import { loadManifest } from '../runtime/init.js';
+import { withLock } from '../storage/lock.js';
+import { locksDirectory } from '../storage/layout.js';
+const sources = ['memory', '.memory', '.claude', '.zcode', '.cursor', '.curcor', '.codex', 'AGENTS.md', 'agents.md', 'CLAUDE.md', 'MEMORY.md', '.cursorrules'];
+const hash = (text) => crypto.createHash('sha256').update(text).digest('hex');
+const sensitive = /(?:api[_-]?key|token|password|secret)\s*[:=]\s*\S+|\b(?:sk-|sk_|ghp_|github_pat_)[A-Za-z0-9_-]+|-----BEGIN .*PRIVATE KEY-----/i;
+export async function importMemory(startPath, apply = false) {
+    const root = await resolveProjectRoot(startPath);
+    await loadManifest(root);
+    const candidates = [];
+    const skipped = [];
+    const visited = new Set();
+    let bytes = 0;
+    let entries = 0;
+    const canonicalRoot = await realpath(root);
+    async function scan(relative, depth = 0) {
+        if (++entries > 2000 || candidates.length >= 500 || depth > 8) {
+            skipped.push({ source: relative, reason: 'scan-budget' });
+            return;
+        }
+        const absolute = path.join(root, relative);
+        let info;
+        try {
+            info = await lstat(absolute);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (info.isSymbolicLink()) {
+            skipped.push({ source: relative, reason: 'symlink' });
+            return;
+        }
+        const resolved = await realpath(absolute);
+        const within = path.relative(canonicalRoot, resolved);
+        if (within.startsWith('..') || path.isAbsolute(within)) {
+            skipped.push({ source: relative, reason: 'outside-project' });
+            return;
+        }
+        const key = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+        if (visited.has(key))
+            return;
+        visited.add(key);
+        if ((await filterPaths(root, [relative])).length === 0) {
+            skipped.push({ source: relative, reason: 'ignored' });
+            return;
+        }
+        if (info.isDirectory()) {
+            for (const entry of (await readdir(absolute)).sort()) {
+                if (entries >= 2000 || candidates.length >= 500) {
+                    skipped.push({ source: relative, reason: 'scan-budget' });
+                    break;
+                }
+                await scan(path.join(relative, entry), depth + 1);
+            }
+            return;
+        }
+        if (!info.isFile() || !/\.(?:md|mdc|txt)$/i.test(relative) && path.basename(relative) !== '.cursorrules')
+            return;
+        if (info.size > 64 * 1024 || bytes + info.size > 2 * 1024 * 1024) {
+            skipped.push({ source: relative, reason: 'byte-budget' });
+            return;
+        }
+        bytes += info.size;
+        const text = await readFile(absolute, 'utf8');
+        let managed = false;
+        let code = false;
+        for (const [index, raw] of text.split(/\r?\n/).entries()) {
+            if (raw.includes('<!-- fluffy-context:start -->')) {
+                managed = true;
+                continue;
+            }
+            if (raw.includes('<!-- fluffy-context:end -->')) {
+                managed = false;
+                continue;
+            }
+            if (managed)
+                continue;
+            if (/^\s*```/.test(raw)) {
+                code = !code;
+                continue;
+            }
+            if (code || /^\s*#/.test(raw))
+                continue;
+            const statement = raw.replace(/^\s*(?:[-*+] |\d+\. )/, '').trim();
+            if (statement.length < 20 || statement.length > 1500)
+                continue;
+            if (sensitive.test(statement)) {
+                skipped.push({ source: `${relative}:${index + 1}`, reason: 'potential-secret' });
+                continue;
+            }
+            if (candidates.length >= 500) {
+                skipped.push({ source: relative, reason: 'candidate-budget' });
+                break;
+            }
+            candidates.push({ source: relative.replaceAll('\\', '/'), line: index + 1, statement,
+                fingerprint: hash(statement.replace(/\s+/g, ' ').toLowerCase()) });
+        }
+    }
+    for (const source of sources)
+        await scan(source);
+    const run = async () => {
+        const known = new Set((await listKnowledge(root, true)).map((item) => hash(item.statement.replace(/\s+/g, ' ').toLowerCase())));
+        const results = [];
+        for (const candidate of candidates) {
+            const duplicate = known.has(candidate.fingerprint);
+            known.add(candidate.fingerprint);
+            const record = apply && !duplicate ? await learnKnowledge(root, candidate.statement, {
+                kind: 'imported-memory', evidence: [`${candidate.source}:${candidate.line}`, `sha256:${candidate.fingerprint}`],
+            }) : null;
+            results.push({ ...candidate, status: duplicate ? 'duplicate' : apply ? 'candidate' : 'preview', knowledgeId: record?.knowledgeId ?? null });
+        }
+        return { projectRoot: root, applied: apply, scannedBytes: bytes, results, skipped,
+            trust: 'Imported text is unverified evidence; inspect and verify against the project before injection.' };
+    };
+    return apply ? withLock(path.join(locksDirectory(root), 'memory-import.lock'), run) : run();
+}

package/dist/src/cognition/journal-segments.d.ts

@@ -0,0 +1,11 @@
+export declare const JOURNAL_SEGMENT_BYTES: number;
+export declare function journalFiles(root: string): Promise<string[]>;
+export declare function readSegment(root: string, name: string): Promise<Buffer>;
+export declare function archiveSegment(root: string, name: string): Promise<void>;
+export declare function appendJournalLine(root: string, line: string): Promise<void>;
+export declare function journalStorage(root: string, expand?: boolean): Promise<{
+    bytes: number;
+    expandedBytes: number | null;
+    archives: number;
+    segments: number;
+}>;