@silicaclaw/cli 2026.3.19-9 → 2026.3.20-10

package/packages/core/dist/packages/core/src/publicProfileSummary.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveCapabilitiesSummary = deriveCapabilitiesSummary;
+exports.buildPublicProfileSummary = buildPublicProfileSummary;
+const DEFAULT_VISIBILITY = {
+    show_tags: true,
+    show_last_seen: true,
+    show_capabilities_summary: true,
+};
+const CAPABILITY_KEYS = ["browser", "computer", "research", "openclaw"];
+function deriveCapabilitiesSummary(tags) {
+    const normalized = new Set(tags.map((tag) => String(tag).trim().toLowerCase()).filter(Boolean));
+    return CAPABILITY_KEYS.filter((key) => normalized.has(key));
+}
+function buildPublicProfileSummary(args) {
+    const visibility = {
+        show_tags: typeof args.visibility?.show_tags === "boolean"
+            ? args.visibility.show_tags
+            : DEFAULT_VISIBILITY.show_tags,
+        show_last_seen: typeof args.visibility?.show_last_seen === "boolean"
+            ? args.visibility.show_last_seen
+            : DEFAULT_VISIBILITY.show_last_seen,
+        show_capabilities_summary: typeof args.visibility?.show_capabilities_summary === "boolean"
+            ? args.visibility.show_capabilities_summary
+            : DEFAULT_VISIBILITY.show_capabilities_summary,
+    };
+    const tags = visibility.show_tags ? args.profile.tags : [];
+    const capabilities = visibility.show_capabilities_summary ? deriveCapabilitiesSummary(args.profile.tags) : [];
+    const now = Number.isFinite(args.now) ? Number(args.now) : Date.now();
+    const ttl = Number.isFinite(args.presence_ttl_ms) ? Number(args.presence_ttl_ms) : 30_000;
+    const age = args.last_seen_at ? Math.max(0, now - args.last_seen_at) : Number.POSITIVE_INFINITY;
+    const freshness_status = age <= ttl ? "live" : age <= ttl * 3 ? "recently_seen" : "stale";
+    const verified_profile = Boolean(args.verified_profile);
+    const verified_presence_recent = freshness_status !== "stale" && Boolean(args.last_seen_at);
+    const verification_status = !verified_profile
+        ? "unverified"
+        : verified_presence_recent
+            ? "verified"
+            : "stale";
+    const visible_fields = [
+        "display_name",
+        "bio",
+        "public_enabled",
+        "profile_updated_at",
+        visibility.show_tags ? "tags" : "",
+        visibility.show_last_seen ? "presence_seen_at" : "",
+        visibility.show_capabilities_summary ? "capabilities_summary" : "",
+    ].filter((field) => Boolean(field));
+    const hidden_fields = [
+        visibility.show_tags ? "" : "tags",
+        visibility.show_last_seen ? "" : "presence_seen_at",
+        visibility.show_capabilities_summary ? "" : "capabilities_summary",
+    ].filter((field) => Boolean(field));
+    return {
+        agent_id: args.profile.agent_id,
+        is_self: Boolean(args.is_self),
+        display_name: args.profile.display_name,
+        bio: args.profile.bio,
+        avatar_url: args.profile.avatar_url,
+        private_encryption_public_key: args.profile.private_encryption_public_key,
+        public_enabled: args.profile.public_enabled,
+        updated_at: args.profile.updated_at,
+        online: args.online,
+        last_seen_at: visibility.show_last_seen ? args.last_seen_at : null,
+        tags,
+        network_mode: args.network_mode ?? "unknown",
+        openclaw_bound: Boolean(args.openclaw_bound),
+        capabilities_summary: capabilities,
+        profile_version: args.profile_version ?? "v1",
+        public_key_fingerprint: args.public_key_fingerprint ?? null,
+        profile_updated_at: args.profile.updated_at,
+        presence_seen_at: visibility.show_last_seen ? args.last_seen_at : null,
+        freshness_status,
+        verified_profile,
+        verified_presence_recent,
+        verification_status,
+        signed_claims: {
+            display_name: args.profile.display_name,
+            bio: args.profile.bio,
+            avatar_url: args.profile.avatar_url,
+            private_encryption_public_key: args.profile.private_encryption_public_key,
+            tags,
+            public_enabled: args.profile.public_enabled,
+            profile_version: args.profile_version ?? "v1",
+            profile_updated_at: args.profile.updated_at,
+            public_key_fingerprint: args.public_key_fingerprint ?? null,
+            verified_profile,
+        },
+        observed_state: {
+            online: args.online,
+            freshness_status,
+            presence_seen_at: visibility.show_last_seen ? args.last_seen_at : null,
+            verified_presence_recent,
+        },
+        integration_metadata: {
+            network_mode: args.network_mode ?? "unknown",
+            openclaw_bound: Boolean(args.openclaw_bound),
+            verification_status,
+        },
+        public_visibility: {
+            visible_fields,
+            hidden_fields,
+        },
+        visibility,
+    };
+}

package/packages/core/dist/packages/core/src/socialConfig.d.ts

@@ -0,0 +1,100 @@
+export type SocialIdentityConfig = {
+    display_name: string;
+    bio: string;
+    avatar_url: string;
+    tags: string[];
+};
+export type SocialNetworkAdapter = "mock" | "local-event-bus" | "real-preview" | "webrtc-preview" | "relay-preview";
+export type SocialNetworkMode = "local" | "lan" | "global-preview";
+export type SocialNetworkConfig = {
+    mode: SocialNetworkMode;
+    namespace: string;
+    adapter: SocialNetworkAdapter;
+    port: number;
+    signaling_url: string;
+    signaling_urls: string[];
+    room: string;
+    seed_peers: string[];
+    bootstrap_hints: string[];
+};
+export type SocialDiscoveryConfig = {
+    discoverable: boolean;
+    allow_profile_broadcast: boolean;
+    allow_presence_broadcast: boolean;
+    allow_message_broadcast: boolean;
+};
+export type SocialVisibilityConfig = {
+    show_display_name: boolean;
+    show_bio: boolean;
+    show_tags: boolean;
+    show_agent_id: boolean;
+    show_last_seen: boolean;
+    show_capabilities_summary: boolean;
+};
+export type SocialOpenClawConfig = {
+    bind_existing_identity: boolean;
+    use_openclaw_profile_if_available: boolean;
+};
+export type SocialConfig = {
+    enabled: boolean;
+    public_enabled: boolean;
+    identity: SocialIdentityConfig;
+    network: SocialNetworkConfig;
+    discovery: SocialDiscoveryConfig;
+    visibility: SocialVisibilityConfig;
+    openclaw: SocialOpenClawConfig;
+};
+export type SocialLoadMeta = {
+    found: boolean;
+    source_path: string | null;
+    parse_error: string | null;
+    loaded_at: number;
+};
+export type SocialRuntimeConfig = {
+    enabled: boolean;
+    public_enabled: boolean;
+    source_path: string | null;
+    last_loaded_at: number;
+    social_found: boolean;
+    parse_error: string | null;
+    resolved_identity: {
+        agent_id: string;
+        public_key: string;
+        created_at: number;
+        source: "silicaclaw-existing" | "openclaw-existing" | "silicaclaw-generated";
+    } | null;
+    resolved_profile: {
+        display_name: string;
+        bio: string;
+        avatar_url?: string;
+        tags: string[];
+        public_enabled: boolean;
+    } | null;
+    resolved_network: {
+        mode: SocialNetworkMode;
+        adapter: SocialNetworkAdapter;
+        namespace: string;
+        port: number | null;
+        signaling_url: string;
+        signaling_urls: string[];
+        room: string;
+        seed_peers: string[];
+        bootstrap_hints: string[];
+        bootstrap_sources: string[];
+    };
+    resolved_discovery: SocialDiscoveryConfig;
+    visibility: SocialVisibilityConfig;
+    openclaw: SocialOpenClawConfig;
+};
+export declare function parseFrontmatterObject(frontmatter: string): Record<string, unknown>;
+export declare function extractFrontmatter(content: string): string | null;
+export declare function normalizeSocialConfig(input: unknown): SocialConfig;
+export declare function getDefaultSocialConfig(): SocialConfig;
+export type DefaultSocialTemplateOptions = {
+    display_name?: string;
+    bio?: string;
+    tags?: string[];
+    mode?: SocialNetworkMode;
+    public_enabled?: boolean;
+};
+export declare function generateDefaultSocialMdTemplate(options?: DefaultSocialTemplateOptions): string;

package/packages/core/dist/packages/core/src/socialConfig.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatterObject = parseFrontmatterObject;
+exports.extractFrontmatter = extractFrontmatter;
+exports.normalizeSocialConfig = normalizeSocialConfig;
+exports.getDefaultSocialConfig = getDefaultSocialConfig;
+exports.generateDefaultSocialMdTemplate = generateDefaultSocialMdTemplate;
+const silicaclaw_defaults_json_1 = __importDefault(require("../../../config/silicaclaw-defaults.json"));
+const DEFAULT_SOCIAL_CONFIG = {
+    enabled: true,
+    public_enabled: false,
+    identity: {
+        display_name: "",
+        bio: "",
+        avatar_url: "",
+        tags: [],
+    },
+    network: {
+        mode: silicaclaw_defaults_json_1.default.network.default_mode,
+        namespace: silicaclaw_defaults_json_1.default.network.default_namespace,
+        adapter: "relay-preview",
+        port: silicaclaw_defaults_json_1.default.ports.network_default,
+        signaling_url: silicaclaw_defaults_json_1.default.network.global_preview.relay_url,
+        signaling_urls: [],
+        room: silicaclaw_defaults_json_1.default.network.global_preview.room,
+        seed_peers: [],
+        bootstrap_hints: [],
+    },
+    discovery: {
+        discoverable: true,
+        allow_profile_broadcast: true,
+        allow_presence_broadcast: true,
+        allow_message_broadcast: true,
+    },
+    visibility: {
+        show_display_name: true,
+        show_bio: true,
+        show_tags: true,
+        show_agent_id: true,
+        show_last_seen: true,
+        show_capabilities_summary: true,
+    },
+    openclaw: {
+        bind_existing_identity: true,
+        use_openclaw_profile_if_available: true,
+    },
+};
+function parseScalar(value) {
+    const trimmed = value.trim();
+    if (trimmed === "[]")
+        return [];
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        const inner = trimmed.slice(1, -1).trim();
+        if (!inner)
+            return [];
+        return inner
+            .split(",")
+            .map((item) => item.trim())
+            .map((item) => (item.startsWith('"') && item.endsWith('"')) || (item.startsWith("'") && item.endsWith("'"))
+            ? item.slice(1, -1)
+            : item)
+            .filter(Boolean);
+    }
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (trimmed === "null")
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function countIndent(line) {
+    let count = 0;
+    while (count < line.length && line[count] === " ")
+        count += 1;
+    return count;
+}
+function findNextSignificantLine(lines, start) {
+    for (let i = start; i < lines.length; i += 1) {
+        const raw = lines[i];
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        return { line: trimmed, indent: countIndent(raw) };
+    }
+    return null;
+}
+function parseFrontmatterObject(frontmatter) {
+    const root = {};
+    const lines = frontmatter.replace(/\r\n/g, "\n").split("\n");
+    const stack = [{ indent: -1, value: root, kind: "object" }];
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        const trimmed = raw.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const indent = countIndent(raw);
+        while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+            stack.pop();
+        }
+        const current = stack[stack.length - 1];
+        if (trimmed.startsWith("- ")) {
+            if (current.kind !== "array") {
+                continue;
+            }
+            const itemRaw = trimmed.slice(2).trim();
+            if (!itemRaw) {
+                const child = {};
+                current.value.push(child);
+                stack.push({ indent, value: child, kind: "object" });
+                continue;
+            }
+            const keyValue = itemRaw.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
+            if (keyValue) {
+                const child = {};
+                const key = keyValue[1];
+                const valueRaw = keyValue[2];
+                child[key] = valueRaw ? parseScalar(valueRaw) : "";
+                current.value.push(child);
+                continue;
+            }
+            current.value.push(parseScalar(itemRaw));
+            continue;
+        }
+        const match = trimmed.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
+        if (!match || current.kind !== "object") {
+            continue;
+        }
+        const key = match[1];
+        const valueRaw = match[2];
+        const obj = current.value;
+        if (valueRaw) {
+            obj[key] = parseScalar(valueRaw);
+            continue;
+        }
+        const next = findNextSignificantLine(lines, i + 1);
+        const nextIsArray = Boolean(next && next.indent > indent && next.line.startsWith("- "));
+        if (nextIsArray) {
+            const arr = [];
+            obj[key] = arr;
+            stack.push({ indent, value: arr, kind: "array" });
+            continue;
+        }
+        const childObj = {};
+        obj[key] = childObj;
+        stack.push({ indent, value: childObj, kind: "object" });
+    }
+    return root;
+}
+function extractFrontmatter(content) {
+    const normalized = content.replace(/\r\n/g, "\n");
+    if (!normalized.startsWith("---\n")) {
+        return null;
+    }
+    const end = normalized.indexOf("\n---", 4);
+    if (end < 0) {
+        return null;
+    }
+    return normalized.slice(4, end).trim();
+}
+function asObject(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function asBool(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function asString(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+function asNumber(value, fallback) {
+    return Number.isFinite(value) ? Number(value) : fallback;
+}
+function asStringArray(value, fallback) {
+    if (!Array.isArray(value))
+        return fallback;
+    return value.map((item) => String(item).trim()).filter(Boolean);
+}
+function asAdapter(value, fallback) {
+    if (value === "mock" ||
+        value === "local-event-bus" ||
+        value === "real-preview" ||
+        value === "webrtc-preview" ||
+        value === "relay-preview") {
+        return value;
+    }
+    return fallback;
+}
+function asMode(value, fallback) {
+    if (value === "local" || value === "lan" || value === "global-preview") {
+        return value;
+    }
+    return fallback;
+}
+function adapterForMode(mode) {
+    if (mode === "local")
+        return "local-event-bus";
+    if (mode === "lan")
+        return "real-preview";
+    return "relay-preview";
+}
+function normalizeSocialConfig(input) {
+    const root = asObject(input);
+    const identity = asObject(root.identity);
+    const network = asObject(root.network);
+    const discovery = asObject(root.discovery);
+    const visibility = asObject(root.visibility);
+    const openclaw = asObject(root.openclaw);
+    const signalingUrl = asString(network.signaling_url, DEFAULT_SOCIAL_CONFIG.network.signaling_url);
+    const signalingUrls = asStringArray(network.signaling_urls, DEFAULT_SOCIAL_CONFIG.network.signaling_urls);
+    const mode = asMode(network.mode, DEFAULT_SOCIAL_CONFIG.network.mode);
+    return {
+        enabled: asBool(root.enabled, DEFAULT_SOCIAL_CONFIG.enabled),
+        public_enabled: asBool(root.public_enabled, DEFAULT_SOCIAL_CONFIG.public_enabled),
+        identity: {
+            display_name: asString(identity.display_name, DEFAULT_SOCIAL_CONFIG.identity.display_name),
+            bio: asString(identity.bio, DEFAULT_SOCIAL_CONFIG.identity.bio),
+            avatar_url: asString(identity.avatar_url, DEFAULT_SOCIAL_CONFIG.identity.avatar_url),
+            tags: asStringArray(identity.tags, DEFAULT_SOCIAL_CONFIG.identity.tags),
+        },
+        network: {
+            mode,
+            namespace: asString(network.namespace, DEFAULT_SOCIAL_CONFIG.network.namespace),
+            adapter: asAdapter(network.adapter, adapterForMode(mode)),
+            port: asNumber(network.port, DEFAULT_SOCIAL_CONFIG.network.port),
+            signaling_url: signalingUrl,
+            signaling_urls: signalingUrls.length > 0 ? signalingUrls : signalingUrl ? [signalingUrl] : [],
+            room: asString(network.room, DEFAULT_SOCIAL_CONFIG.network.room),
+            seed_peers: asStringArray(network.seed_peers, DEFAULT_SOCIAL_CONFIG.network.seed_peers),
+            bootstrap_hints: asStringArray(network.bootstrap_hints, DEFAULT_SOCIAL_CONFIG.network.bootstrap_hints),
+        },
+        discovery: {
+            discoverable: asBool(discovery.discoverable, DEFAULT_SOCIAL_CONFIG.discovery.discoverable),
+            allow_profile_broadcast: asBool(discovery.allow_profile_broadcast, DEFAULT_SOCIAL_CONFIG.discovery.allow_profile_broadcast),
+            allow_presence_broadcast: asBool(discovery.allow_presence_broadcast, DEFAULT_SOCIAL_CONFIG.discovery.allow_presence_broadcast),
+            allow_message_broadcast: asBool(discovery.allow_message_broadcast, DEFAULT_SOCIAL_CONFIG.discovery.allow_message_broadcast),
+        },
+        visibility: {
+            show_display_name: asBool(visibility.show_display_name, DEFAULT_SOCIAL_CONFIG.visibility.show_display_name),
+            show_bio: asBool(visibility.show_bio, DEFAULT_SOCIAL_CONFIG.visibility.show_bio),
+            show_tags: asBool(visibility.show_tags, DEFAULT_SOCIAL_CONFIG.visibility.show_tags),
+            show_agent_id: asBool(visibility.show_agent_id, DEFAULT_SOCIAL_CONFIG.visibility.show_agent_id),
+            show_last_seen: asBool(visibility.show_last_seen, DEFAULT_SOCIAL_CONFIG.visibility.show_last_seen),
+            show_capabilities_summary: asBool(visibility.show_capabilities_summary, DEFAULT_SOCIAL_CONFIG.visibility.show_capabilities_summary),
+        },
+        openclaw: {
+            bind_existing_identity: asBool(openclaw.bind_existing_identity, DEFAULT_SOCIAL_CONFIG.openclaw.bind_existing_identity),
+            use_openclaw_profile_if_available: asBool(openclaw.use_openclaw_profile_if_available, DEFAULT_SOCIAL_CONFIG.openclaw.use_openclaw_profile_if_available),
+        },
+    };
+}
+function getDefaultSocialConfig() {
+    return JSON.parse(JSON.stringify(DEFAULT_SOCIAL_CONFIG));
+}
+function generateDefaultSocialMdTemplate(options = {}) {
+    const displayName = options.display_name?.trim() || "My OpenClaw Agent";
+    const bio = options.bio?.trim() || "Local AI agent running on this machine";
+    const tags = Array.isArray(options.tags) && options.tags.length > 0 ? options.tags : ["openclaw", "local-first"];
+    const mode = options.mode ?? "global-preview";
+    const publicEnabled = typeof options.public_enabled === "boolean" ? options.public_enabled : false;
+    return `---
+enabled: true
+public_enabled: ${publicEnabled}
+
+identity:
+  display_name: ${JSON.stringify(displayName)}
+  bio: ${JSON.stringify(bio)}
+  tags:
+${tags.map((tag) => `    - ${tag}`).join("\n")}
+
+network:
+  mode: ${JSON.stringify(mode)}
+
+discovery:
+  discoverable: true
+  allow_profile_broadcast: true
+  allow_presence_broadcast: true
+  allow_message_broadcast: true
+
+openclaw:
+  bind_existing_identity: true
+  use_openclaw_profile_if_available: true
+---
+
+# social.md
+
+This file configures how OpenClaw integrates with SilicaClaw.
+`;
+}

package/packages/core/dist/packages/core/src/socialMessage.d.ts

@@ -0,0 +1,19 @@
+import { AgentIdentity, SocialMessageObservationRecord, SocialMessageRecord } from "./types";
+export declare function signSocialMessage(input: {
+    identity: AgentIdentity;
+    message_id: string;
+    display_name: string;
+    topic: string;
+    body: string;
+    created_at?: number;
+}): SocialMessageRecord;
+export declare function verifySocialMessage(record: SocialMessageRecord): boolean;
+export declare function signSocialMessageObservation(input: {
+    identity: AgentIdentity;
+    observation_id: string;
+    message_id: string;
+    observed_agent_id: string;
+    observer_display_name: string;
+    observed_at?: number;
+}): SocialMessageObservationRecord;
+export declare function verifySocialMessageObservation(record: SocialMessageObservationRecord): boolean;

package/packages/core/dist/packages/core/src/socialMessage.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signSocialMessage = signSocialMessage;
+exports.verifySocialMessage = verifySocialMessage;
+exports.signSocialMessageObservation = signSocialMessageObservation;
+exports.verifySocialMessageObservation = verifySocialMessageObservation;
+const crypto_1 = require("./crypto");
+function unsignedSocialMessage(record) {
+    const { signature: _signature, ...rest } = record;
+    return rest;
+}
+function signSocialMessage(input) {
+    const payload = {
+        type: "social.message",
+        message_id: input.message_id,
+        agent_id: input.identity.agent_id,
+        public_key: input.identity.public_key,
+        display_name: input.display_name,
+        topic: input.topic,
+        body: input.body,
+        created_at: input.created_at ?? Date.now(),
+    };
+    return {
+        ...payload,
+        signature: (0, crypto_1.signPayload)(payload, input.identity.private_key),
+    };
+}
+function verifySocialMessage(record) {
+    try {
+        if ((0, crypto_1.hashPublicKey)((0, crypto_1.fromBase64)(record.public_key)) !== record.agent_id) {
+            return false;
+        }
+        return (0, crypto_1.verifyPayload)(unsignedSocialMessage(record), record.signature, record.public_key);
+    }
+    catch {
+        return false;
+    }
+}
+function unsignedSocialMessageObservation(record) {
+    const { signature: _signature, ...rest } = record;
+    return rest;
+}
+function signSocialMessageObservation(input) {
+    const payload = {
+        type: "social.message.observation",
+        observation_id: input.observation_id,
+        message_id: input.message_id,
+        observed_agent_id: input.observed_agent_id,
+        observer_agent_id: input.identity.agent_id,
+        observer_public_key: input.identity.public_key,
+        observer_display_name: input.observer_display_name,
+        observed_at: input.observed_at ?? Date.now(),
+    };
+    return {
+        ...payload,
+        signature: (0, crypto_1.signPayload)(payload, input.identity.private_key),
+    };
+}
+function verifySocialMessageObservation(record) {
+    try {
+        if ((0, crypto_1.hashPublicKey)((0, crypto_1.fromBase64)(record.observer_public_key)) !== record.observer_agent_id) {
+            return false;
+        }
+        return (0, crypto_1.verifyPayload)(unsignedSocialMessageObservation(record), record.signature, record.observer_public_key);
+    }
+    catch {
+        return false;
+    }
+}

package/packages/core/dist/packages/core/src/socialResolver.d.ts

@@ -0,0 +1,46 @@
+import { AgentIdentity, ProfileInput, PublicProfile } from "./types";
+import { DefaultSocialTemplateOptions, SocialConfig, SocialLoadMeta } from "./socialConfig";
+export type SocialFileLookup = {
+    found: boolean;
+    source_path: string | null;
+    content: string | null;
+};
+export type OpenClawIdentityLookup = {
+    identity: AgentIdentity | null;
+    source_path: string | null;
+};
+export type OpenClawProfileLookup = {
+    profile: Partial<PublicProfile> | null;
+    source_path: string | null;
+};
+export type LoadedSocialConfig = {
+    config: SocialConfig;
+    meta: SocialLoadMeta;
+    raw_frontmatter: Record<string, unknown> | null;
+};
+export type ResolvedIdentityResult = {
+    identity: AgentIdentity;
+    source: "silicaclaw-existing" | "openclaw-existing" | "silicaclaw-generated";
+    openclaw_source_path: string | null;
+};
+export declare function getSocialConfigSearchPaths(rootDir?: string, homeDir?: string): string[];
+export declare function findSocialMd(rootDir?: string): SocialFileLookup;
+export declare function loadSocialConfig(rootDir?: string): LoadedSocialConfig;
+export declare function findOpenClawIdentity(rootDir?: string, homeDir?: string): OpenClawIdentityLookup;
+export declare function findOpenClawProfile(rootDir?: string, homeDir?: string): OpenClawProfileLookup;
+export declare function resolveIdentityWithSocial(args: {
+    socialConfig: SocialConfig;
+    existingIdentity: AgentIdentity | null;
+    generatedIdentity: AgentIdentity;
+    rootDir?: string;
+}): ResolvedIdentityResult;
+export declare function resolveProfileInputWithSocial(args: {
+    socialConfig: SocialConfig;
+    agentId: string;
+    existingProfile: PublicProfile | null;
+    rootDir?: string;
+}): ProfileInput;
+export declare function ensureDefaultSocialMd(rootDir?: string, options?: DefaultSocialTemplateOptions): {
+    path: string;
+    created: boolean;
+};