@wowok/agent-mcp 2.6.9 → 2.7.1

package/dist/persona/bridge.js

@@ -0,0 +1,86 @@
+const REQUIREMENT_RULE_MAP = [
+    { keywords: ["arbitration", "arb"], rule_id: "r_trust" },
+    { keywords: ["compensation", "fund"], rule_id: "r_fund" },
+    { keywords: ["region", "location"], rule_id: "r_region" },
+    { keywords: ["price", "budget"], rule_id: "r_price" },
+    { keywords: ["industry"], rule_id: "r_industry" },
+    { keywords: ["capability"], rule_id: "r_capabilities" },
+    { keywords: ["trust", "score"], rule_id: "r_trust" },
+];
+const FORBID_KEYWORDS = ["forbid", "never", "no "];
+function mapRequirement(req) {
+    const lower = req.toLowerCase();
+    const forbid = FORBID_KEYWORDS.some((k) => lower.includes(k));
+    for (const m of REQUIREMENT_RULE_MAP) {
+        if (m.keywords.some((k) => lower.includes(k))) {
+            return { rule_id: m.rule_id, condition: forbid ? "forbid" : "require", note: req };
+        }
+    }
+    return { rule_id: "r_trust", condition: forbid ? "forbid" : "require", note: req };
+}
+export function personaToInjection(effective) {
+    const requirements = (effective.layer.requirements ?? []).map(mapRequirement);
+    const intent = [
+        `role=${effective.role}`,
+        effective.industries.length ? `industries=${effective.industries.join(",")}` : "",
+        effective.layer.identity?.self_description ?? "",
+    ].filter(Boolean).join("; ");
+    return {
+        intent,
+        preferences: effective.layer.preferences ?? {},
+        requirements: requirements.length ? requirements : undefined,
+    };
+}
+export function personaToContextText(effective) {
+    const lines = [];
+    lines.push(`# Effective Persona (role=${effective.role}, industries=${effective.industries.join(",") || "any"})`);
+    const id = effective.layer.identity;
+    if (id) {
+        if (id.self_description)
+            lines.push(`- self: ${id.self_description}`);
+        if (id.region)
+            lines.push(`- region: ${id.region}`);
+        if (id.languages?.length)
+            lines.push(`- languages: ${id.languages.join(", ")}`);
+    }
+    if (effective.layer.strategy?.length) {
+        lines.push("- strategy:");
+        for (const s of effective.layer.strategy)
+            lines.push(`  - ${s}`);
+    }
+    if (effective.layer.rules?.length) {
+        lines.push("- rules:");
+        for (const r of effective.layer.rules)
+            lines.push(`  - ${r}`);
+    }
+    if (effective.layer.requirements?.length) {
+        lines.push("- requirements:");
+        for (const r of effective.layer.requirements)
+            lines.push(`  - ${r}`);
+    }
+    if (effective.layer.spec) {
+        lines.push("- spec:");
+        lines.push(effective.layer.spec);
+    }
+    return lines.join("\n");
+}
+export function mergeInjections(base, override) {
+    if (!base && !override)
+        return undefined;
+    if (!base)
+        return override ?? undefined;
+    if (!override)
+        return base;
+    return {
+        intent: override.intent ?? base.intent,
+        preferences: { ...(base.preferences ?? {}), ...(override.preferences ?? {}) },
+        requirements: [...(base.requirements ?? []), ...(override.requirements ?? [])],
+        overrides: {
+            rules: { ...(base.overrides?.rules ?? {}), ...(override.overrides?.rules ?? {}) },
+            data_sources: {
+                ...(base.overrides?.data_sources ?? {}),
+                ...(override.overrides?.data_sources ?? {}),
+            },
+        },
+    };
+}

package/dist/persona/defaults.d.ts

@@ -0,0 +1,4 @@
+import { type Industry, type Persona, type PersonaRole } from "./types.js";
+export declare const GENERIC_PERSONA: Persona;
+export declare function getIndustryDefault(role: PersonaRole, industry: Industry): Persona;
+export declare function listIndustryDefaults(): Persona[];

package/dist/persona/defaults.js

@@ -0,0 +1,195 @@
+import { getDefaultPreferences } from "../customer/user-preferences.js";
+import { PERSONA_VERSION, } from "./types.js";
+function safePrefs(prefs) {
+    const { budget_range: _budget, ...rest } = prefs;
+    return rest;
+}
+function industryPrefs(industry) {
+    return safePrefs(getDefaultPreferences(industry));
+}
+const SPECS = [
+    {
+        role: "merchant", industry: "freelance",
+        strategy: [
+            "Deliver in milestones and release per milestone (avoid all-or-nothing non-acceptance).",
+            "Record WIP hash at each key node as evidence.",
+            "Use an accept_guard time gate so non-accepting clients auto-release after the deadline.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "must have a compensation fund",
+            "forbid full upfront payment before any delivery",
+        ],
+    },
+    {
+        role: "user", industry: "freelance",
+        strategy: [
+            "Pay per milestone, verify each before releasing the next.",
+            "Verify WIP hash before accepting a delivery.",
+            "Open arbitration if the provider is unresponsive.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "must have a compensation fund",
+            "forbid direct payment without escrow",
+        ],
+    },
+    {
+        role: "merchant", industry: "rental",
+        strategy: [
+            "Record pre/post rental WIP hashes as the damage-claim baseline.",
+            "Hold the deposit in a graded allocator (normal return auto-releases).",
+            "Keep an evidence chain for any damage claim.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "damage claims require pre-rental baseline evidence",
+        ],
+    },
+    {
+        role: "user", industry: "rental",
+        strategy: [
+            "Record condition evidence (WIP hash) before renting.",
+            "Confirm the return only after verifying no damage.",
+            "Open arbitration against unfair damage claims.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "deposit must be refundable (a return path must exist)",
+        ],
+    },
+    {
+        role: "merchant", industry: "education",
+        strategy: [
+            "Release tuition per lesson (1/N) to structurally prevent run-away disputes.",
+            "Keep attendance/completion evidence.",
+            "Declare the refund policy up front.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "tuition must be escrowed (not directly received)",
+        ],
+    },
+    {
+        role: "user", industry: "education",
+        strategy: [
+            "Pay per lesson, never full upfront.",
+            "Confirm completed lessons before paying.",
+            "Request proportional refund if the course is cancelled.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "forbid one-time full upfront payment",
+        ],
+    },
+    {
+        role: "merchant", industry: "travel",
+        strategy: [
+            "Model multi-leg trips as a multi-leg machine with a transparent fund waterfall.",
+            "Declare the cancellation policy up front.",
+            "Separate refundable vs non-refundable legs.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "funds must be escrowed (conditionally released)",
+        ],
+    },
+    {
+        role: "user", industry: "travel",
+        strategy: [
+            "Confirm the cancellation/refund policy before booking.",
+            "Watch cross-leg responsibility in multi-leg trips.",
+            "Pursue the non-refundable downstream on flight cancellation.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "cancellation must be refundable (a refund path must exist)",
+        ],
+    },
+    {
+        role: "merchant", industry: "subscription",
+        strategy: [
+            "Charge each period via charge_guard_signer (explicit user signature).",
+            "Keep 100% of revenue (no platform cut).",
+            "Declare pauses/cancellation explicitly.",
+        ],
+        requirements: [
+            "forbid auto-renewal traps (every period must be explicitly signed)",
+        ],
+    },
+    {
+        role: "user", industry: "subscription",
+        strategy: [
+            "Confirm authorization before each charge.",
+            "Cancel anytime without friction.",
+            "Stop charging when the creator pauses.",
+        ],
+        requirements: [
+            "forbid auto-renewal (every period must be explicitly signed)",
+            "cancellation must be frictionless",
+        ],
+    },
+    {
+        role: "merchant", industry: "retail",
+        strategy: [
+            "Release funds on confirmed receipt (escrow).",
+            "Keep an evidence chain for authenticity disputes.",
+            "Declare the return policy up front.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "funds must be escrowed (released on confirmed receipt)",
+        ],
+    },
+    {
+        role: "user", industry: "retail",
+        strategy: [
+            "Verify authenticity before confirming receipt.",
+            "Never confirm receipt before the goods arrive.",
+            "Open arbitration for counterfeit / not-received.",
+        ],
+        requirements: [
+            "must have arbitration",
+            "not-received must be refundable",
+        ],
+    },
+];
+function buildDefault(spec) {
+    const industries = spec.industry ? [spec.industry] : [];
+    const longTerm = {
+        identity: {
+            self_description: `${spec.role} in ${spec.industry ?? "any"} industry`,
+        },
+        preferences: spec.industry ? industryPrefs(spec.industry) : {},
+    };
+    const current = {
+        strategy: spec.strategy,
+        requirements: spec.requirements,
+    };
+    return {
+        version: PERSONA_VERSION,
+        scope: "system",
+        role: spec.role,
+        industries,
+        long_term: longTerm,
+        current,
+        updated_at: 0,
+    };
+}
+const DEFAULTS = SPECS.map(buildDefault);
+export const GENERIC_PERSONA = {
+    version: PERSONA_VERSION,
+    scope: "system",
+    role: "user",
+    industries: [],
+    long_term: { identity: { self_description: "generic WoWok user" } },
+    current: {},
+    updated_at: 0,
+};
+export function getIndustryDefault(role, industry) {
+    const found = DEFAULTS.find((p) => p.role === role && p.industries[0] === industry);
+    return found ? { ...found } : { ...GENERIC_PERSONA, role };
+}
+export function listIndustryDefaults() {
+    return DEFAULTS.map((p) => ({ ...p }));
+}

package/dist/persona/experience-bridge.d.ts

@@ -0,0 +1,3 @@
+import type { UserProfile } from "../experience/types.js";
+import type { PersonaLayer } from "./types.js";
+export declare function profileToCurrentLayer(profile: UserProfile): PersonaLayer;

package/dist/persona/experience-bridge.js

@@ -0,0 +1,23 @@
+export function profileToCurrentLayer(profile) {
+    if (profile.total_operations <= 0) {
+        return {};
+    }
+    const layer = {};
+    const preferences = {};
+    if (profile.risk_appetite && profile.risk_appetite !== "balanced")
+        preferences.risk_appetite = profile.risk_appetite;
+    if (profile.expertise_tier && profile.expertise_tier !== "novice")
+        preferences.expertise_tier = profile.expertise_tier;
+    if (profile.preferred_confirmation && profile.preferred_confirmation !== "standard")
+        preferences.preferred_confirmation = profile.preferred_confirmation;
+    if (profile.preferred_industries?.length)
+        preferences.preferred_industries = profile.preferred_industries;
+    if (typeof profile.success_rate === "number")
+        preferences.success_rate = profile.success_rate;
+    if (Object.keys(preferences).length)
+        layer.preferences = preferences;
+    if (profile.frequent_pitfalls?.length) {
+        layer.rules = profile.frequent_pitfalls.map((p) => `avoid pitfall: ${p}`);
+    }
+    return layer;
+}

package/dist/persona/index.d.ts

@@ -0,0 +1,18 @@
+import { type PersonaAnalysis } from "./analyzer.js";
+import type { EffectivePersona, Industry, Persona, PersonaLayer, PersonaRole, PersonaScope } from "./types.js";
+import type { UserProfile } from "../experience/types.js";
+export { GENERIC_PERSONA, getIndustryDefault, listIndustryDefaults } from "./defaults.js";
+export { SqlitePersonaStore, getPersonaStore, setPersonaStore } from "./store.js";
+export { countPersonaLines, emptyPersona, mergeLayers, mutateLayer, resolveEffective, validatePersona } from "./model.js";
+export { personaToContextText, personaToInjection, mergeInjections } from "./bridge.js";
+export { analyzePersonaContext } from "./analyzer.js";
+export { profileToCurrentLayer } from "./experience-bridge.js";
+export type { EffectivePersona, Industry, Persona, PersonaIdentity, PersonaLayer, PersonaMutationMode, PersonaRole, PersonaScope, } from "./types.js";
+export declare function getEffectivePersona(account?: string, industry?: Industry, role?: PersonaRole): Promise<EffectivePersona>;
+export declare function analysisToLayerDelta(analysis: PersonaAnalysis): PersonaLayer;
+export declare function applyAnalysisToCurrent(scope: PersonaScope, account: string | undefined, analysis: PersonaAnalysis, mode?: "merge" | "replace", role?: PersonaRole, industries?: Industry[]): Promise<Persona>;
+export declare function syncExperienceToCurrent(account?: string, profile?: UserProfile): Promise<{
+    persona: Persona;
+    applied: PersonaLayer;
+    effective: EffectivePersona;
+}>;

package/dist/persona/index.js

@@ -0,0 +1,71 @@
+import { GENERIC_PERSONA, getIndustryDefault } from "./defaults.js";
+import { getPersonaStore } from "./store.js";
+import { emptyPersona, mutateLayer, resolveEffective, validatePersona, } from "./model.js";
+import { profileToCurrentLayer } from "./experience-bridge.js";
+import { getProfile } from "../experience/index.js";
+export { GENERIC_PERSONA, getIndustryDefault, listIndustryDefaults } from "./defaults.js";
+export { SqlitePersonaStore, getPersonaStore, setPersonaStore } from "./store.js";
+export { countPersonaLines, emptyPersona, mergeLayers, mutateLayer, resolveEffective, validatePersona } from "./model.js";
+export { personaToContextText, personaToInjection, mergeInjections } from "./bridge.js";
+export { analyzePersonaContext } from "./analyzer.js";
+export { profileToCurrentLayer } from "./experience-bridge.js";
+export async function getEffectivePersona(account, industry, role) {
+    const store = getPersonaStore();
+    const system = await store.get("system");
+    const acct = account ? await store.get("account", account) : null;
+    const base = industry
+        ? getIndustryDefault(role ?? "user", industry)
+        : { ...GENERIC_PERSONA, role: role ?? "user" };
+    return resolveEffective(system, acct, base);
+}
+export function analysisToLayerDelta(analysis) {
+    const layer = {};
+    if (analysis.preferences && Object.keys(analysis.preferences).length) {
+        layer.preferences = analysis.preferences;
+    }
+    if (analysis.requirements.length)
+        layer.requirements = analysis.requirements;
+    if (analysis.rules.length)
+        layer.rules = analysis.rules;
+    return layer;
+}
+export async function applyAnalysisToCurrent(scope, account, analysis, mode = "merge", role, industries) {
+    const store = getPersonaStore();
+    const existing = scope === "account" && account
+        ? await store.get("account", account)
+        : await store.get("system");
+    const resolvedRole = role ?? analysis.role ?? existing?.role ?? "user";
+    const resolvedIndustries = industries ?? analysis.industries;
+    const base = existing ?? emptyPersona(scope, account, resolvedRole, resolvedIndustries);
+    const mergedIndustries = Array.from(new Set([...base.industries, ...(resolvedIndustries ?? [])]));
+    const delta = analysisToLayerDelta(analysis);
+    const current = mutateLayer(base.current, delta, mode);
+    const persona = {
+        ...base,
+        role: resolvedRole,
+        industries: mergedIndustries,
+        current,
+        updated_at: Date.now(),
+    };
+    const issues = validatePersona(persona);
+    if (issues.length > 0) {
+        throw new Error(`persona invalid after apply: ${issues.join("; ")}`);
+    }
+    await store.put(persona);
+    return persona;
+}
+export async function syncExperienceToCurrent(account, profile) {
+    const store = getPersonaStore();
+    const scope = account ? "account" : "system";
+    const existing = account ? await store.get("account", account) : await store.get("system");
+    const base = existing ?? emptyPersona(scope, account, "user", []);
+    const delta = profileToCurrentLayer(profile ?? getProfile());
+    const current = mutateLayer(base.current, delta, "merge");
+    const persona = { ...base, current, updated_at: Date.now() };
+    const issues = validatePersona(persona);
+    if (issues.length > 0) {
+        throw new Error(`persona invalid after sync: ${issues.join("; ")}`);
+    }
+    await store.put(persona);
+    return { persona, applied: delta, effective: await getEffectivePersona(account) };
+}

package/dist/persona/model.d.ts

@@ -0,0 +1,7 @@
+import { type EffectivePersona, type Persona, type PersonaLayer, type PersonaMutationMode } from "./types.js";
+export declare function mergeLayers(layers: PersonaLayer[]): PersonaLayer;
+export declare function mutateLayer(layer: PersonaLayer, delta: PersonaLayer, mode: PersonaMutationMode): PersonaLayer;
+export declare function resolveEffective(system?: Persona | null, account?: Persona | null, base?: Persona | null): EffectivePersona;
+export declare function countPersonaLines(persona: Persona): number;
+export declare function validatePersona(persona: Persona): string[];
+export declare function emptyPersona(scope: "system" | "account", account: string | undefined, role: Persona["role"], industries: Persona["industries"]): Persona;

package/dist/persona/model.js

@@ -0,0 +1,111 @@
+import { PERSONA_MAX_LINES, PERSONA_VERSION, } from "./types.js";
+function dedupe(items) {
+    return Array.from(new Set(items.filter((s) => typeof s === "string" && s.length > 0)));
+}
+export function mergeLayers(layers) {
+    const merged = {};
+    for (const layer of layers) {
+        if (!layer)
+            continue;
+        if (layer.identity) {
+            merged.identity = { ...merged.identity, ...layer.identity };
+            if (layer.identity.languages) {
+                merged.identity.languages = dedupe([
+                    ...(merged.identity.languages ?? []),
+                    ...layer.identity.languages,
+                ]);
+            }
+        }
+        if (layer.preferences) {
+            merged.preferences = { ...merged.preferences, ...layer.preferences };
+        }
+        if (layer.strategy) {
+            merged.strategy = dedupe([...(merged.strategy ?? []), ...layer.strategy]);
+        }
+        if (layer.rules) {
+            merged.rules = dedupe([...(merged.rules ?? []), ...layer.rules]);
+        }
+        if (layer.requirements) {
+            merged.requirements = dedupe([...(merged.requirements ?? []), ...layer.requirements]);
+        }
+        if (layer.spec) {
+            merged.spec = [merged.spec, layer.spec].filter(Boolean).join("\n\n");
+        }
+    }
+    return merged;
+}
+export function mutateLayer(layer, delta, mode) {
+    if (mode === "replace") {
+        return { ...delta };
+    }
+    return mergeLayers([layer, delta]);
+}
+export function resolveEffective(system, account, base) {
+    const layers = [];
+    const sources = [];
+    if (base) {
+        layers.push(base.long_term);
+        sources.push({ scope: base.scope, part: "long_term" });
+        layers.push(base.current);
+        sources.push({ scope: base.scope, part: "current" });
+    }
+    if (system) {
+        layers.push(system.long_term);
+        sources.push({ scope: "system", part: "long_term" });
+        layers.push(system.current);
+        sources.push({ scope: "system", part: "current" });
+    }
+    if (account) {
+        layers.push(account.long_term);
+        sources.push({ scope: "account", account: account.account, part: "long_term" });
+        layers.push(account.current);
+        sources.push({ scope: "account", account: account.account, part: "current" });
+    }
+    const winner = account ?? system ?? base;
+    return {
+        scope: account ? "account" : system ? "system" : base ? "system" : "system",
+        account: account?.account ?? system?.account,
+        role: winner?.role ?? "user",
+        industries: winner?.industries ?? [],
+        layer: mergeLayers(layers),
+        sources,
+    };
+}
+export function countPersonaLines(persona) {
+    return JSON.stringify(persona, null, 2).split("\n").length;
+}
+export function validatePersona(persona) {
+    const issues = [];
+    if (persona.version !== PERSONA_VERSION) {
+        issues.push(`version must be ${PERSONA_VERSION}`);
+    }
+    if (persona.scope === "account" && !persona.account) {
+        issues.push("account is required when scope=account");
+    }
+    if (persona.scope !== "account" && persona.account) {
+        issues.push("account should only be set when scope=account");
+    }
+    if (!persona.role || !["merchant", "user", "arbitrator"].includes(persona.role)) {
+        issues.push("role must be merchant|user|arbitrator");
+    }
+    if (!Array.isArray(persona.industries)) {
+        issues.push("industries must be an array");
+    }
+    const lines = countPersonaLines(persona);
+    if (lines > PERSONA_MAX_LINES) {
+        issues.push(`persona is ${lines} lines (max ${PERSONA_MAX_LINES})`);
+    }
+    return issues;
+}
+export function emptyPersona(scope, account, role, industries) {
+    return {
+        version: PERSONA_VERSION,
+        scope,
+        account,
+        role,
+        industries,
+        long_term: {},
+        current: {},
+        updated_at: Date.now(),
+    };
+}

package/dist/persona/store.d.ts

@@ -0,0 +1,19 @@
+import { SQLiteStorage } from "@wowok/wowok";
+import type { Persona, PersonaScope } from "./types.js";
+export interface PersonaStore {
+    get(scope: PersonaScope, account?: string): Promise<Persona | null>;
+    list(): Promise<Persona[]>;
+    put(persona: Persona): Promise<void>;
+    delete(scope: PersonaScope, account?: string): Promise<boolean>;
+}
+export declare class SqlitePersonaStore implements PersonaStore {
+    private readonly kv;
+    constructor(kv?: SQLiteStorage);
+    private key;
+    get(scope: PersonaScope, account?: string): Promise<Persona | null>;
+    list(): Promise<Persona[]>;
+    put(persona: Persona): Promise<void>;
+    delete(scope: PersonaScope, account?: string): Promise<boolean>;
+}
+export declare function getPersonaStore(): PersonaStore;
+export declare function setPersonaStore(store: PersonaStore): void;

package/dist/persona/store.js

@@ -0,0 +1,62 @@
+import { SQLiteStorage } from "@wowok/wowok";
+function safeParse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+const SQLITE_KEY_PREFIX = "persona:";
+const SQLITE_SYSTEM_KEY = "persona:system";
+const SQLITE_ACCOUNT_PREFIX = "persona:account:";
+export class SqlitePersonaStore {
+    kv;
+    constructor(kv) {
+        this.kv = kv ?? new SQLiteStorage();
+    }
+    key(scope, account) {
+        return scope === "account" && account
+            ? `${SQLITE_ACCOUNT_PREFIX}${account}`
+            : SQLITE_SYSTEM_KEY;
+    }
+    async get(scope, account) {
+        const raw = await this.kv.get(this.key(scope, account));
+        return raw ? safeParse(raw) : null;
+    }
+    async list() {
+        const rows = await this.kv.list(SQLITE_KEY_PREFIX);
+        const personas = [];
+        for (const { value } of rows) {
+            const persona = safeParse(value);
+            if (persona)
+                personas.push(persona);
+        }
+        const systemRaw = await this.kv.get(SQLITE_SYSTEM_KEY);
+        if (systemRaw) {
+            const persona = safeParse(systemRaw);
+            if (persona)
+                personas.push(persona);
+        }
+        return personas;
+    }
+    async put(persona) {
+        await this.kv.put(this.key(persona.scope, persona.account), JSON.stringify(persona));
+    }
+    async delete(scope, account) {
+        const key = this.key(scope, account);
+        const exists = (await this.kv.get(key)) !== undefined;
+        if (exists)
+            await this.kv.del(key);
+        return exists;
+    }
+}
+let _store = null;
+export function getPersonaStore() {
+    if (!_store)
+        _store = new SqlitePersonaStore();
+    return _store;
+}
+export function setPersonaStore(store) {
+    _store = store;
+}

package/dist/persona/types.d.ts

@@ -0,0 +1,43 @@
+export type PersonaScope = "system" | "account";
+export type PersonaRole = "merchant" | "user" | "arbitrator";
+export type Industry = "freelance" | "rental" | "education" | "travel" | "subscription" | "retail";
+export declare const SUPPORTED_INDUSTRIES: Industry[];
+export interface PersonaIdentity {
+    region?: string;
+    languages?: string[];
+    self_description?: string;
+}
+export interface PersonaLayer {
+    identity?: PersonaIdentity;
+    preferences?: Record<string, unknown>;
+    strategy?: string[];
+    rules?: string[];
+    requirements?: string[];
+    spec?: string;
+}
+export type PersonaMutationMode = "merge" | "replace";
+export interface Persona {
+    version: number;
+    scope: PersonaScope;
+    account?: string;
+    role: PersonaRole;
+    industries: Industry[];
+    long_term: PersonaLayer;
+    current: PersonaLayer;
+    updated_at: number;
+}
+export interface PersonaSource {
+    scope: PersonaScope;
+    account?: string;
+    part: "long_term" | "current";
+}
+export interface EffectivePersona {
+    scope: PersonaScope;
+    account?: string;
+    role: PersonaRole;
+    industries: Industry[];
+    layer: PersonaLayer;
+    sources: PersonaSource[];
+}
+export declare const PERSONA_VERSION = 1;
+export declare const PERSONA_MAX_LINES = 300;

package/dist/persona/types.js

@@ -0,0 +1,5 @@
+export const SUPPORTED_INDUSTRIES = [
+    "freelance", "rental", "education", "travel", "subscription", "retail",
+];
+export const PERSONA_VERSION = 1;
+export const PERSONA_MAX_LINES = 300;

package/dist/project/handlers.d.ts

@@ -269,6 +269,11 @@ export declare function handleEvaluateProject(v: ProjectInput): Promise<{
     evaluationId: string;
     refreshWarning: string | undefined;
     graphFallbackWarning: string | undefined;
+} | {
+    action: "evaluate_project";
+    async_mode: true;
+    task_id: string;
+    hint: string;
 }>;
 export declare function handleSaveEvaluation(v: ProjectInput): Promise<{
     action: "save_evaluation";