bikky 0.4.2 → 0.4.4

package/dist/mcp/types.d.ts

@@ -1,6 +1,7 @@
 /**
  * Type definitions for the Memory MCP server.
  */
+import type { OperationOrigin } from "../provenance/origin.js";
 export interface McpToolResult {
     [key: string]: unknown;
     content: Array<{
@@ -36,6 +37,9 @@ export interface QdrantFilterCondition {
     is_empty?: {
         key: string;
     };
+    must?: QdrantFilterCondition[];
+    should?: QdrantFilterCondition[];
+    must_not?: QdrantFilterCondition[];
 }
 export interface QdrantFilter {
     must: QdrantFilterCondition[];
@@ -67,8 +71,12 @@ export interface FactPayload {
     kind?: string;
     layer?: string | null;
     memory_subtype?: string | null;
+    origin?: OperationOrigin;
+    last_operation_origin?: OperationOrigin;
+    /** @deprecated Origin is canonical for new writes. */
     actor_id?: string;
     entities: string[];
+    /** @deprecated Origin is canonical for new writes. */
     source?: string;
     confidence: number;
     importance?: number;
@@ -79,8 +87,16 @@ export interface FactPayload {
     verification_count?: number;
     useful_count?: number;
     not_useful_count?: number;
+    useful_feedback_count?: number;
+    not_useful_feedback_count?: number;
+    misleading_count?: number;
+    wrong_count?: number;
+    irrelevant_count?: number;
+    last_useful_at?: string;
     last_used_at?: string;
     last_feedback_at?: string;
+    recall_count?: number;
+    last_recalled_at?: string;
     superseded_by: string | null;
     superseded_at: string | null;
     created_at: string;
@@ -131,15 +147,34 @@ export interface FactPayload {
     event_session_id?: string;
     recall_query?: string;
     returned_fact_ids?: string[];
+    result_count?: number;
+    search_scope?: string;
+    searched_destinations?: string[];
+    failed_destinations?: string[];
+    target_fact_id?: string;
     feedback_note?: string;
+    feedback_kind?: string;
     outcome?: string;
     outcome_summary?: string;
+    scope_type?: string;
+    scope_value?: string;
+    rollup_type?: string;
+    rollup_generated_at?: string;
+    rollup_window_start?: string;
+    rollup_window_end?: string;
+    active_fact_count?: number;
+    stale_count?: number;
+    low_confidence_count?: number;
 }
 export interface FilterParams {
     category?: string;
     domain?: string;
     kind?: string;
     memory_subtype?: string;
+    origin_user_id?: string;
+    origin_agent_id?: string;
+    origin_interface?: string;
+    /** @deprecated Use origin_user_id / origin_agent_id. */
     actor_id?: string;
     entity?: string;
     session_id?: string;

package/dist/package-verifier.d.ts

@@ -0,0 +1,19 @@
+export interface PackageVerifierPattern {
+    re: RegExp;
+    reason: string;
+}
+export interface PackageVerifierSpec {
+    name: string;
+    requiredPaths: string[];
+}
+export declare const TEXT_EXTENSIONS: Set<string>;
+export declare const FORBIDDEN_PATH_PATTERNS: PackageVerifierPattern[];
+export declare const FORBIDDEN_CONTENT_PATTERNS: PackageVerifierPattern[];
+export declare function normalizePackPath(file: string): string;
+export declare function findForbiddenPath(file: string, patterns?: ReadonlyArray<PackageVerifierPattern>): PackageVerifierPattern | null;
+export declare function findForbiddenContent(content: string, patterns?: ReadonlyArray<PackageVerifierPattern>): PackageVerifierPattern | null;
+export declare function assertPackageContents(pkg: PackageVerifierSpec, files: string[], patterns?: ReadonlyArray<PackageVerifierPattern>): void;
+export declare function shouldScanTextByMetadata(file: string, size: number, textExtensions?: ReadonlySet<string>): boolean;
+export declare function shouldScanText(file: string): boolean;
+export declare function assertSafeTextContent(pkgName: string, relPath: string, content: string): void;
+//# sourceMappingURL=package-verifier.d.ts.map

package/dist/package-verifier.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+const privateIdentityPathPattern = () => new RegExp([
+    ["saber", "zrelli", "private"].join("-"),
+    ["saber", "apate"].join("-"),
+    "ap" + "ate",
+].join("|"), "i");
+const privateIdentityContentPattern = () => new RegExp([
+    ["saber", "zrelli", "private"].join("-"),
+    ["saber", "apate"].join("-"),
+    ["apate", "ai"].join("-"),
+    ["apate", "com"].join("\\."),
+].join("|"), "i");
+export const TEXT_EXTENSIONS = new Set([
+    ".css",
+    ".d.ts",
+    ".html",
+    ".js",
+    ".json",
+    ".md",
+    ".svg",
+    ".txt",
+]);
+export const FORBIDDEN_PATH_PATTERNS = [
+    { re: /(^|\/)(tasks|node_modules|\.git)(\/|$)/, reason: "task, node_modules, or git metadata" },
+    { re: /(^|\/)\.env($|\.)/, reason: "environment files" },
+    { re: /(\.test|\.itest)\.(js|d\.ts)$/i, reason: "compiled test artifacts" },
+    { re: /(^|\/)(id_rsa|id_ed25519|.*\.pem|.*\.key)$/i, reason: "private key material" },
+    { re: /(^|\/)Users\/|\/Users\//i, reason: "absolute local user paths" },
+    { re: privateIdentityPathPattern(), reason: "private identity references" },
+];
+export const FORBIDDEN_CONTENT_PATTERNS = [
+    { re: /gh[pousr]_[A-Za-z0-9_]{20,}/, reason: "GitHub token" },
+    { re: /github_pat_[A-Za-z0-9_]{20,}/, reason: "GitHub fine-grained token" },
+    { re: /sk-[A-Za-z0-9]{20,}/, reason: "OpenAI-style API key" },
+    { re: /AKIA[0-9A-Z]{16}/, reason: "AWS access key id" },
+    { re: /AIza[0-9A-Za-z_-]{35}/, reason: "Google API key" },
+    { re: /xox[baprs]-[0-9A-Za-z-]{20,}/, reason: "Slack token" },
+    { re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/, reason: "private key block" },
+    { re: /\/Users\/saber\b/i, reason: "local user path" },
+    { re: privateIdentityContentPattern(), reason: "private identity reference" },
+];
+export function normalizePackPath(file) {
+    return file.replace(/^package\//, "");
+}
+export function findForbiddenPath(file, patterns = FORBIDDEN_PATH_PATTERNS) {
+    return patterns.find(({ re }) => re.test(file)) ?? null;
+}
+export function findForbiddenContent(content, patterns = FORBIDDEN_CONTENT_PATTERNS) {
+    return patterns.find(({ re }) => re.test(content)) ?? null;
+}
+export function assertPackageContents(pkg, files, patterns = FORBIDDEN_PATH_PATTERNS) {
+    const fileSet = new Set(files);
+    for (const requiredPath of pkg.requiredPaths) {
+        if (!fileSet.has(requiredPath)) {
+            throw new Error(`${pkg.name} package is missing required file: ${requiredPath}`);
+        }
+    }
+    for (const file of files) {
+        const forbidden = findForbiddenPath(file, patterns);
+        if (forbidden) {
+            throw new Error(`${pkg.name} package includes forbidden path (${forbidden.reason}): ${file}`);
+        }
+    }
+}
+export function shouldScanTextByMetadata(file, size, textExtensions = TEXT_EXTENSIONS) {
+    if (size > 2_000_000)
+        return false;
+    const lower = file.toLowerCase();
+    if (lower.endsWith(".d.ts"))
+        return true;
+    return textExtensions.has(path.extname(lower));
+}
+export function shouldScanText(file) {
+    return shouldScanTextByMetadata(file, fs.statSync(file).size);
+}
+export function assertSafeTextContent(pkgName, relPath, content) {
+    const forbidden = findForbiddenContent(content);
+    if (forbidden) {
+        throw new Error(`${pkgName} package includes forbidden content (${forbidden.reason}) in ${relPath}`);
+    }
+}
+//# sourceMappingURL=package-verifier.js.map

package/dist/prompts/brief.d.ts

@@ -6,7 +6,7 @@
  */
 import { type PromptDescriptor, type RenderedPrompt } from "./index.js";
 export declare const BRIEF_PROMPT_DESCRIPTOR: PromptDescriptor;
-declare const ALLOWED_HEADINGS: readonly ["Engineering", "Product", "Human", "System"];
+declare const ALLOWED_HEADINGS: readonly ["Engineering", "Product", "System"];
 export interface BriefInput {
     /** ISO date string injected into the brief header. */
     generatedAt: string;
@@ -14,6 +14,6 @@ export interface BriefInput {
     sections: Partial<Record<(typeof ALLOWED_HEADINGS)[number], string[]>>;
 }
 export declare const briefPrompt: (input: BriefInput) => RenderedPrompt;
-export declare const ALLOWED_BRIEF_HEADINGS: readonly ["Engineering", "Product", "Human", "System"];
+export declare const ALLOWED_BRIEF_HEADINGS: readonly ["Engineering", "Product", "System"];
 export {};
 //# sourceMappingURL=brief.d.ts.map

package/dist/prompts/brief.js

@@ -12,7 +12,6 @@ export const BRIEF_PROMPT_DESCRIPTOR = {
 const ALLOWED_HEADINGS = [
     "Engineering",
     "Product",
-    "Human",
     "System",
 ];
 const SYSTEM_TEMPLATE = (allowedHeadings) => `<role>

package/dist/prompts/extraction.js

@@ -12,13 +12,18 @@ export const EXTRACTION_PROMPT_DESCRIPTOR = {
 const SUBTYPE_REASONING = `## Subtype reasoning (think step-by-step BEFORE picking memory_subtype)
 For each candidate fact, walk these four top-level categories first, then pick the most concrete memory_subtype:
 
-  ENGINEERING — how the software is built and operated:
+  ENGINEERING — how the software is built and operated, including collaboration preferences:
     codebase_map      → file paths, symbols, modules, repo structure
     architecture_decision → engineering/system design choice with rationale
     infra_topology    → clusters, services, queues, datastores, regions
     access_pattern    → roles, permissions, auth flows, approval gates
     operational_procedure  → runbook / deploy / rollout / maintenance / incident steps
     troubleshooting_gotcha → stable failure mode, debugging quirk, surprising behaviour
+    preference             → explicit style, tooling, or interaction preference
+    person_profile         → durable role, expertise, person/team context
+    ownership_note         → owner, approver, escalation path, accountability
+    working_agreement      → collaboration norm or operating rule
+    activity_event         → explicit actor-action-object event with durable project value
     convention             → produced by distillation, not this extraction prompt
 
   PRODUCT — what the product should be and how it succeeds:
@@ -30,13 +35,6 @@ For each candidate fact, walk these four top-level categories first, then pick t
     success_metric         → KPI, adoption/retention/quality metric, evaluation target
     market_insight         → audience, customer/community feedback, competitor/GTM insight
 
-  HUMAN — durable people, preferences, and collaboration context:
-    preference             → explicit style, tooling, or interaction preference
-    person_profile         → durable role, expertise, person/team context
-    ownership_note         → owner, approver, escalation path, accountability
-    working_agreement      → collaboration norm or operating rule
-    activity_event         → explicit actor-action-object event with durable project value
-
 Disambiguation rules (apply in order; first match wins):
   R1. If the fact describes a *failure* or *workaround* → troubleshooting_gotcha (NOT operational_procedure).
   R2. If the fact names *files / modules / symbols* → codebase_map (NOT infra_topology).
@@ -62,7 +60,7 @@ Example 2 — codebase vs infra:
 Example 3 — domain_rule vs preference:
   TEXT: "I prefer kebab-case branch names; it's just my style."
   → memory_subtype: preference (R6: 'I prefer' + 'my style')
-  → subtype_reason: "Personal style → Human → R6 wins → preference."
+  → subtype_reason: "Personal style → Engineering → R6 wins → preference."
 
 Example 4 — product vs engineering decision:
   TEXT: "We decided the memory page should show categories and subtype chips directly because a sub-tab layer made the ontology feel confusing."
@@ -72,7 +70,7 @@ Example 4 — product vs engineering decision:
 Example 5 — durable activity event:
   TEXT: "Saber merged PR #85 after approving the subtype UX copy changes."
   → memory_subtype: activity_event (R7: actor + durable state-changing action + object)
-  → subtype_reason: "Actor-action-object event tied to a PR → Human → R7 wins → activity_event."`;
+  → subtype_reason: "Actor-action-object event tied to a PR → Engineering → R7 wins → activity_event."`;
 const SELF_JUDGMENT = `## Self-judgment (think step-by-step BEFORE emitting each fact)
 
 For every candidate fact, judge it on three axes. The verifier downstream USES these values, so be honest — bad self-judgment costs the fact its place in memory.
@@ -218,7 +216,7 @@ If nothing passes the quality gate, return: {"facts": []}`;
 const buildSystem = () => {
     return [
         "<role>",
-        "You are Bikky's knowledge-extraction agent for open-source coding agents. You read session transcripts and emit durable Engineering, Product, Human, and System-aligned facts that help a future agent continue useful work.",
+        "You are Bikky's knowledge-extraction agent for open-source coding agents. You read session transcripts and emit durable Engineering, Product, and System-aligned facts that help a future agent continue useful work.",
         "</role>",
         "",
         "<task>",

package/dist/provenance/origin.d.ts

@@ -0,0 +1,57 @@
+import type { BikkyConfig } from "../config.js";
+export type OriginIdentityType = "user" | "coding_agent" | "daemon" | "ui" | "api" | "cli" | "docs" | "system" | "unknown";
+export type OriginIdentitySource = "config" | "shell" | "git" | "env" | "hostname";
+export type OriginInterface = "mcp" | "daemon" | "ui" | "api" | "cli" | "system";
+export type OriginAction = "create" | "update" | "delete" | "verify" | "forget" | "review" | "correct" | "reinforce" | "supersede" | "recall" | "aggregate" | "feedback";
+export type OriginMetadataValue = string | number | boolean | null;
+export interface OriginIdentity {
+    type: OriginIdentityType;
+    id: string | null;
+    name: string | null;
+    source: OriginIdentitySource;
+}
+export interface OperationOrigin {
+    schema_version: 1;
+    user: OriginIdentity | null;
+    agent: OriginIdentity;
+    interface: OriginInterface;
+    operation: {
+        action: OriginAction;
+        tool?: string;
+        route?: string;
+        subsystem?: string;
+        outcome?: string;
+    };
+    metadata?: Record<string, OriginMetadataValue>;
+}
+export interface ResolveUserIdentityOptions {
+    config?: Pick<BikkyConfig, "identity"> | null;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+    hostname?: string;
+    shellUsername?: string | null;
+}
+export interface ResolveAgentIdentityOptions {
+    type?: OriginIdentityType;
+    interface?: OriginInterface;
+    env?: NodeJS.ProcessEnv;
+    hostname?: string;
+}
+export interface BuildOperationOriginInput extends ResolveUserIdentityOptions {
+    interface: OriginInterface;
+    action: OriginAction;
+    tool?: string;
+    route?: string;
+    subsystem?: string;
+    outcome?: string;
+    agentType?: OriginIdentityType;
+    metadata?: Record<string, unknown>;
+}
+export declare function normalizeOriginId(value: string | null | undefined): string | null;
+export declare function resolveUserIdentity(options?: ResolveUserIdentityOptions): OriginIdentity;
+export declare function inferUserIdentity(options?: Omit<ResolveUserIdentityOptions, "config">): OriginIdentity;
+export declare function resolveAgentIdentity(options?: ResolveAgentIdentityOptions): OriginIdentity;
+export declare function sanitizeOriginMetadata(metadata: Record<string, unknown> | undefined): Record<string, OriginMetadataValue> | undefined;
+export declare function buildOperationOrigin(input: BuildOperationOriginInput): OperationOrigin;
+export declare function isOperationOrigin(value: unknown): value is OperationOrigin;
+//# sourceMappingURL=origin.d.ts.map

package/dist/provenance/origin.js

@@ -0,0 +1,254 @@
+import crypto from "node:crypto";
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+const MAX_NAME_LENGTH = 128;
+const MAX_OPERATION_FIELD_LENGTH = 128;
+const MAX_METADATA_KEYS = 32;
+const MAX_METADATA_KEY_LENGTH = 64;
+const MAX_METADATA_STRING_LENGTH = 256;
+const hash = (value) => crypto.createHash("sha256").update(value.trim().toLowerCase()).digest("hex").slice(0, 12);
+const slug = (value) => value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+const looksLikeEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim());
+const cleanName = (value) => {
+    const trimmed = value?.trim();
+    if (!trimmed || looksLikeEmail(trimmed))
+        return null;
+    return trimmed.slice(0, MAX_NAME_LENGTH);
+};
+const cleanOperationField = (value) => {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed.slice(0, MAX_OPERATION_FIELD_LENGTH) : undefined;
+};
+export function normalizeOriginId(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    if (looksLikeEmail(trimmed))
+        return `email:${hash(trimmed)}`;
+    const normalized = slug(trimmed);
+    return normalized || `id:${hash(trimmed)}`;
+}
+function generatedId(prefix, value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return null;
+    if (looksLikeEmail(trimmed))
+        return `${prefix}:email:${hash(trimmed)}`;
+    const normalized = slug(trimmed);
+    return normalized ? `${prefix}:${normalized}` : `${prefix}:${hash(trimmed)}`;
+}
+function configuredIdentity(type, rawId, rawName, source) {
+    const name = cleanName(rawName);
+    const id = normalizeOriginId(rawId) ?? (name ? generatedId(type === "user" ? "user" : type, name) : null);
+    if (!id && !name)
+        return null;
+    return { type, id, name, source };
+}
+function readGitConfig(key, cwd) {
+    try {
+        const value = execFileSync("git", ["config", "--get", key], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 1000,
+        }).trim();
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function gitUserIdentity(cwd) {
+    const gitName = readGitConfig("user.name", cwd);
+    const gitEmail = readGitConfig("user.email", cwd);
+    const nameSlug = slug(gitName ?? "");
+    if (gitEmail) {
+        return {
+            type: "user",
+            id: nameSlug ? `git:${nameSlug}:${hash(gitEmail)}` : `git:${hash(gitEmail)}`,
+            name: cleanName(gitName),
+            source: "git",
+        };
+    }
+    if (nameSlug) {
+        return {
+            type: "user",
+            id: `git:${nameSlug}`,
+            name: cleanName(gitName),
+            source: "git",
+        };
+    }
+    return null;
+}
+function shellUserName(options) {
+    if (Object.prototype.hasOwnProperty.call(options, "shellUsername") && options.shellUsername === null) {
+        return null;
+    }
+    const explicit = cleanName(options.shellUsername);
+    if (explicit)
+        return explicit;
+    try {
+        const user = os.userInfo().username;
+        const cleaned = cleanName(user);
+        if (cleaned)
+            return cleaned;
+    }
+    catch {
+        // ignore and fall through to env-derived shell names
+    }
+    const env = options.env ?? process.env;
+    return cleanName(env.USER ?? env.LOGNAME ?? env.USERNAME);
+}
+function hostnameValue(hostname) {
+    const explicit = hostname?.trim();
+    if (explicit)
+        return explicit;
+    const detected = os.hostname().trim();
+    return detected || "unknown-host";
+}
+function hostnameIdentity(type, hostname, prefix) {
+    const host = hostnameValue(hostname);
+    return {
+        type,
+        id: generatedId(prefix ?? "host", host),
+        name: cleanName(host),
+        source: "hostname",
+    };
+}
+export function resolveUserIdentity(options = {}) {
+    const env = options.env ?? process.env;
+    const fromConfig = configuredIdentity("user", options.config?.identity.user_id, options.config?.identity.user_name, "config");
+    if (fromConfig)
+        return fromConfig;
+    const fromEnv = configuredIdentity("user", env.BIKKY_USER_ID, env.BIKKY_USER_NAME, "env");
+    if (fromEnv)
+        return fromEnv;
+    const fromGit = gitUserIdentity(options.cwd);
+    if (fromGit)
+        return fromGit;
+    const shellName = shellUserName(options);
+    if (shellName) {
+        return {
+            type: "user",
+            id: generatedId("shell", shellName),
+            name: shellName,
+            source: "shell",
+        };
+    }
+    return hostnameIdentity("user", options.hostname);
+}
+export function inferUserIdentity(options = {}) {
+    return resolveUserIdentity({ ...options, config: null });
+}
+function defaultAgentType(originInterface) {
+    switch (originInterface) {
+        case "mcp":
+            return "coding_agent";
+        case "daemon":
+            return "daemon";
+        case "ui":
+            return "ui";
+        case "api":
+            return "api";
+        case "cli":
+            return "cli";
+        case "system":
+            return "system";
+    }
+}
+function defaultAgentName(type, originInterface) {
+    if (type === "coding_agent" && originInterface === "mcp")
+        return "Bikky MCP client";
+    if (type === "daemon")
+        return "Bikky daemon";
+    if (type === "ui")
+        return "Bikky UI";
+    if (type === "api")
+        return "Bikky API";
+    if (type === "cli")
+        return "Bikky CLI";
+    if (type === "system")
+        return "Bikky system";
+    if (type === "docs")
+        return "Bikky docs importer";
+    return "Bikky";
+}
+export function resolveAgentIdentity(options = {}) {
+    const env = options.env ?? process.env;
+    const type = options.type ?? (options.interface ? defaultAgentType(options.interface) : "unknown");
+    const envIdentity = configuredIdentity(type, env.BIKKY_AGENT_ID, env.BIKKY_AGENT_NAME, "env");
+    if (envIdentity)
+        return envIdentity;
+    const host = hostnameValue(options.hostname);
+    return {
+        type,
+        id: generatedId(type, host),
+        name: cleanName(`${defaultAgentName(type, options.interface)} on ${host}`),
+        source: "hostname",
+    };
+}
+export function sanitizeOriginMetadata(metadata) {
+    if (!metadata)
+        return undefined;
+    const sanitized = {};
+    for (const [rawKey, rawValue] of Object.entries(metadata).slice(0, MAX_METADATA_KEYS)) {
+        const key = rawKey.trim().replace(/[^a-zA-Z0-9_.-]+/g, "_").slice(0, MAX_METADATA_KEY_LENGTH);
+        if (!key)
+            continue;
+        if (rawValue === null || typeof rawValue === "boolean") {
+            sanitized[key] = rawValue;
+        }
+        else if (typeof rawValue === "number") {
+            if (Number.isFinite(rawValue))
+                sanitized[key] = rawValue;
+        }
+        else if (typeof rawValue === "string") {
+            sanitized[key] = rawValue.slice(0, MAX_METADATA_STRING_LENGTH);
+        }
+    }
+    return Object.keys(sanitized).length > 0 ? sanitized : undefined;
+}
+export function buildOperationOrigin(input) {
+    const operation = {
+        action: input.action,
+    };
+    const tool = cleanOperationField(input.tool);
+    const route = cleanOperationField(input.route);
+    const subsystem = cleanOperationField(input.subsystem);
+    const outcome = cleanOperationField(input.outcome);
+    if (tool)
+        operation.tool = tool;
+    if (route)
+        operation.route = route;
+    if (subsystem)
+        operation.subsystem = subsystem;
+    if (outcome)
+        operation.outcome = outcome;
+    const origin = {
+        schema_version: 1,
+        user: resolveUserIdentity(input),
+        agent: resolveAgentIdentity({
+            type: input.agentType,
+            interface: input.interface,
+            env: input.env,
+            hostname: input.hostname,
+        }),
+        interface: input.interface,
+        operation,
+    };
+    const metadata = sanitizeOriginMetadata(input.metadata);
+    if (metadata)
+        origin.metadata = metadata;
+    return origin;
+}
+export function isOperationOrigin(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return candidate.schema_version === 1
+        && Boolean(candidate.agent)
+        && typeof candidate.interface === "string"
+        && Boolean(candidate.operation)
+        && typeof candidate.operation?.action === "string";
+}
+//# sourceMappingURL=origin.js.map

package/dist/routing-context.d.ts

@@ -0,0 +1,16 @@
+import type { RoutingInput } from "./routing.js";
+type RoutingMetadata = Record<string, unknown>;
+export interface MemoryRoutingInput {
+    destination?: string | null;
+    cwd?: string;
+    content?: string | null;
+    entities?: ReadonlyArray<string>;
+    metadata?: RoutingMetadata | null;
+    context?: RoutingMetadata | null;
+    extraContent?: ReadonlyArray<unknown>;
+}
+export declare const routingText: (values: ReadonlyArray<unknown>) => string;
+export declare const buildMemoryRoutingInput: (input: MemoryRoutingInput) => RoutingInput;
+export declare const mergeRoutingInputs: (base: RoutingInput, override?: RoutingInput) => RoutingInput;
+export {};
+//# sourceMappingURL=routing-context.d.ts.map

package/dist/routing-context.js

@@ -0,0 +1,55 @@
+const appendRoutingText = (parts, value) => {
+    if (value === null || value === undefined)
+        return;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        const text = String(value).trim();
+        if (text)
+            parts.push(text);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            appendRoutingText(parts, item);
+        return;
+    }
+    if (typeof value === "object") {
+        for (const [key, nested] of Object.entries(value)) {
+            appendRoutingText(parts, key);
+            appendRoutingText(parts, nested);
+        }
+    }
+};
+export const routingText = (values) => {
+    const parts = [];
+    for (const value of values)
+        appendRoutingText(parts, value);
+    return Array.from(new Set(parts)).join("\n");
+};
+export const buildMemoryRoutingInput = (input) => {
+    const metadata = {
+        ...(input.metadata ?? {}),
+        ...(input.context ?? {}),
+    };
+    return {
+        destination: input.destination,
+        cwd: input.cwd,
+        content: routingText([input.content, input.entities, metadata, ...(input.extraContent ?? [])]),
+        entities: input.entities,
+        metadata,
+    };
+};
+export const mergeRoutingInputs = (base, override) => {
+    if (!override)
+        return base;
+    return {
+        destination: override.destination ?? base.destination,
+        cwd: override.cwd ?? base.cwd,
+        content: routingText([base.content, override.content]),
+        entities: Array.from(new Set([...(base.entities ?? []), ...(override.entities ?? [])])),
+        metadata: {
+            ...(base.metadata ?? {}),
+            ...(override.metadata ?? {}),
+        },
+    };
+};
+//# sourceMappingURL=routing-context.js.map

package/dist/status.d.ts

@@ -58,6 +58,7 @@ export interface MaintenanceStatusReport {
     state_path: string;
     relation_inference: MaintenanceJobStatus;
     entity_typing: MaintenanceJobStatus;
+    memory_quality_rollups: MaintenanceJobStatus;
 }
 export interface UiStatusReport {
     status: DiagnosticState;