forge-openclaw-plugin 0.2.48 → 0.2.49

package/dist/server/server/src/repositories/agent-runtime-sessions.js

@@ -1,7 +1,8 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { getDatabase, runInTransaction } from "../db.js";
 import { recordActivityEvent } from "./activity-events.js";
 import { listAgentActions } from "./collaboration.js";
+import { ensureBotUser, getUserById } from "./users.js";
 import { agentActionSchema, agentRuntimeEventLevelSchema, agentRuntimeReconnectPlanSchema, agentRuntimeSessionEventSchema, agentRuntimeSessionSchema, createAgentRuntimeSessionEventSchema, createAgentRuntimeSessionSchema, disconnectAgentRuntimeSessionSchema, heartbeatAgentRuntimeSessionSchema, reconnectAgentRuntimeSessionSchema } from "../types.js";
 function parseMetadata(raw) {
     try {
@@ -211,7 +212,95 @@ function ensureCurrentSessionInstance(row, externalSessionId) {
     }
     return true;
 }
-function disconnectSupersededSingletonSessions(parsed, sessionId, now) {
+function normalizeIdentityPart(value) {
+    return (value
+        ?.trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._:]+/g, "_")
+        .replace(/^_+|_+$/g, "") ?? "");
+}
+function shortHash(value) {
+    return createHash("sha1").update(value).digest("hex").slice(0, 12);
+}
+function canonicalRuntimeAgentLabel(provider) {
+    if (provider === "openclaw") {
+        return "Forge OpenClaw";
+    }
+    if (provider === "hermes") {
+        return "Forge Hermes";
+    }
+    return "Forge Codex";
+}
+function canonicalRuntimeDescription(provider) {
+    return `${canonicalRuntimeAgentLabel(provider)} runtime agent with stable Forge identity and linked Kanban user.`;
+}
+function canonicalAgentUserSpec(provider) {
+    if (provider === "openclaw") {
+        return {
+            id: "user_agent_openclaw",
+            handle: "openclaw",
+            displayName: "OpenClaw",
+            description: "OpenClaw runtime actor linked to Forge agent identity and Kanban ownership.",
+            accentColor: "#38bdf8"
+        };
+    }
+    if (provider === "hermes") {
+        return {
+            id: "user_agent_hermes",
+            handle: "hermes",
+            displayName: "Hermes",
+            description: "Hermes runtime actor linked to Forge agent identity and Kanban ownership.",
+            accentColor: "#a78bfa"
+        };
+    }
+    return {
+        id: "user_agent_codex",
+        handle: "codex",
+        displayName: "Codex",
+        description: "Codex runtime actor linked to Forge agent identity and Kanban ownership.",
+        accentColor: "#22c55e"
+    };
+}
+function deriveMachineKey(input) {
+    const explicit = normalizeIdentityPart(input.machineKey);
+    if (explicit) {
+        return explicit;
+    }
+    const source = [
+        normalizeText(input.dataRoot) ?? "",
+        normalizeText(input.baseUrl) ?? "local"
+    ].join("|");
+    return `machine_${shortHash(source)}`;
+}
+function derivePersonaKey(input) {
+    return (normalizeIdentityPart(input.personaKey) ||
+        normalizeIdentityPart(input.agentType) ||
+        "default");
+}
+function deriveAgentIdentityKey(input) {
+    const explicit = normalizeIdentityPart(input.agentIdentityKey);
+    if (explicit) {
+        return explicit;
+    }
+    return `runtime:${input.provider}:${deriveMachineKey(input)}:${derivePersonaKey(input)}`;
+}
+function linkAgentIdentityUsers(agentId, provider, linkedUserIds, now) {
+    const primaryUser = ensureBotUser(canonicalAgentUserSpec(provider));
+    const normalizedUserIds = Array.from(new Set([primaryUser.id, ...linkedUserIds.map((id) => id.trim()).filter(Boolean)]));
+    for (const userId of normalizedUserIds) {
+        if (!getUserById(userId)) {
+            continue;
+        }
+        getDatabase()
+            .prepare(`INSERT INTO agent_identity_users (agent_id, user_id, role, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(agent_id, user_id) DO UPDATE SET
+           role = excluded.role,
+           updated_at = excluded.updated_at`)
+            .run(agentId, userId, userId === primaryUser.id ? "primary" : "linked", now, now);
+    }
+}
+function disconnectSupersededSingletonSessions(parsed, sessionId, agentId, now) {
     if (!parsed.metadata?.singleton) {
         return;
     }
@@ -224,11 +313,11 @@ function disconnectSupersededSingletonSessions(parsed, sessionId, now) {
          created_at, updated_at
        FROM agent_runtime_sessions
        WHERE provider = ?
-         AND agent_label = ?
+         AND agent_id = ?
          AND coalesce(base_url, '') = coalesce(?, '')
          AND coalesce(data_root, '') = coalesce(?, '')
          AND id <> ?`)
-        .all(parsed.provider, parsed.agentLabel, normalizeText(parsed.baseUrl), normalizeText(parsed.dataRoot), sessionId);
+        .all(parsed.provider, agentId, normalizeText(parsed.baseUrl), normalizeText(parsed.dataRoot), sessionId);
     for (const row of rows) {
         if (row.status === "disconnected" && row.ended_at) {
             continue;
@@ -251,29 +340,45 @@ function disconnectSupersededSingletonSessions(parsed, sessionId, now) {
     }
 }
 function upsertRuntimeAgentIdentity(input) {
+    const identityKey = deriveAgentIdentityKey(input);
+    const machineKey = deriveMachineKey(input);
+    const personaKey = derivePersonaKey(input);
+    const label = canonicalRuntimeAgentLabel(input.provider);
     const existing = getDatabase()
         .prepare(`SELECT id
        FROM agent_identities
-       WHERE lower(label) = lower(?)
+       WHERE identity_key = ?
+          OR (
+            (identity_key IS NULL OR machine_key IS NULL OR machine_key = 'legacy' OR identity_key LIKE 'runtime:%:legacy:%')
+            AND (
+              provider = ?
+              OR lower(agent_type) = lower(?)
+              OR lower(label) = lower(?)
+            )
+          )
        LIMIT 1`)
-        .get(input.agentLabel);
+        .get(identityKey, input.provider, input.provider, label);
     const now = new Date().toISOString();
-    const description = `${input.provider[0].toUpperCase()}${input.provider.slice(1)} runtime session participant registered through Forge.`;
+    const description = canonicalRuntimeDescription(input.provider);
     if (existing) {
         getDatabase()
             .prepare(`UPDATE agent_identities
-         SET agent_type = ?, updated_at = ?
+         SET label = ?, agent_type = ?, identity_key = ?, provider = ?,
+             machine_key = ?, persona_key = ?, description = ?, updated_at = ?
          WHERE id = ?`)
-            .run(input.agentType || input.provider, now, existing.id);
+            .run(label, input.agentType || input.provider, identityKey, input.provider, machineKey, personaKey, description, now, existing.id);
+        linkAgentIdentityUsers(existing.id, input.provider, input.linkedUserIds, now);
         return existing.id;
     }
     const agentId = `agt_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
     getDatabase()
         .prepare(`INSERT INTO agent_identities (
-        id, label, agent_type, trust_level, autonomy_mode, approval_mode,
+        id, label, agent_type, identity_key, provider, machine_key, persona_key,
+        trust_level, autonomy_mode, approval_mode,
         description, created_at, updated_at
-      ) VALUES (?, ?, ?, 'trusted', 'approval_required', 'approval_by_default', ?, ?, ?)`)
-        .run(agentId, input.agentLabel, input.agentType || input.provider, description, now, now);
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'trusted', 'approval_required', 'approval_by_default', ?, ?, ?)`)
+        .run(agentId, label, input.agentType || input.provider, identityKey, input.provider, machineKey, personaKey, description, now, now);
+    linkAgentIdentityUsers(agentId, input.provider, input.linkedUserIds, now);
     return agentId;
 }
 function insertSessionEvent(sessionId, input, now = new Date().toISOString()) {
@@ -321,6 +426,7 @@ export function registerAgentRuntimeSession(input) {
     return runInTransaction(() => {
         const now = new Date().toISOString();
         const agentId = upsertRuntimeAgentIdentity(parsed);
+        const agentLabel = canonicalRuntimeAgentLabel(parsed.provider);
         const existing = getSessionRowByCompositeKey(parsed.provider, parsed.sessionKey);
         const sessionId = existing?.id ?? `ags_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
         if (existing) {
@@ -332,7 +438,7 @@ export function registerAgentRuntimeSession(input) {
                last_error = ?, last_seen_at = ?, last_heartbeat_at = ?, started_at = ?,
                ended_at = NULL, metadata_json = ?, updated_at = ?
            WHERE id = ?`)
-                .run(agentId, parsed.agentLabel, parsed.agentType || parsed.provider, parsed.sessionLabel || parsed.sessionKey, parsed.actorLabel, parsed.connectionMode, parsed.status === "error" ? "error" : "connected", normalizeText(parsed.baseUrl), normalizeText(parsed.webUrl), normalizeText(parsed.dataRoot), normalizeText(parsed.externalSessionId), parsed.staleAfterSeconds, normalizeText(parsed.lastError), now, now, now, JSON.stringify(parsed.metadata), now, sessionId);
+                .run(agentId, agentLabel, parsed.agentType || parsed.provider, parsed.sessionLabel || parsed.sessionKey, parsed.actorLabel, parsed.connectionMode, parsed.status === "error" ? "error" : "connected", normalizeText(parsed.baseUrl), normalizeText(parsed.webUrl), normalizeText(parsed.dataRoot), normalizeText(parsed.externalSessionId), parsed.staleAfterSeconds, normalizeText(parsed.lastError), now, now, now, JSON.stringify(parsed.metadata), now, sessionId);
             insertSessionEvent(sessionId, {
                 eventType: "session_registered",
                 title: "Session re-registered",
@@ -349,7 +455,7 @@ export function registerAgentRuntimeSession(input) {
              last_seen_at, last_heartbeat_at, started_at, ended_at, metadata_json,
              created_at, updated_at
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, NULL, ?, ?, ?, ?, NULL, ?, ?, ?)`)
-                .run(sessionId, agentId, parsed.agentLabel, parsed.agentType || parsed.provider, parsed.provider, parsed.sessionKey, parsed.sessionLabel || parsed.sessionKey, parsed.actorLabel, parsed.connectionMode, parsed.status === "error" ? "error" : "connected", normalizeText(parsed.baseUrl), normalizeText(parsed.webUrl), normalizeText(parsed.dataRoot), normalizeText(parsed.externalSessionId), parsed.staleAfterSeconds, normalizeText(parsed.lastError), now, now, now, JSON.stringify(parsed.metadata), now, now);
+                .run(sessionId, agentId, agentLabel, parsed.agentType || parsed.provider, parsed.provider, parsed.sessionKey, parsed.sessionLabel || parsed.sessionKey, parsed.actorLabel, parsed.connectionMode, parsed.status === "error" ? "error" : "connected", normalizeText(parsed.baseUrl), normalizeText(parsed.webUrl), normalizeText(parsed.dataRoot), normalizeText(parsed.externalSessionId), parsed.staleAfterSeconds, normalizeText(parsed.lastError), now, now, now, JSON.stringify(parsed.metadata), now, now);
             insertSessionEvent(sessionId, {
                 eventType: "session_registered",
                 title: "Session registered",
@@ -357,12 +463,12 @@ export function registerAgentRuntimeSession(input) {
                 metadata: parsed.metadata
             }, now);
         }
-        disconnectSupersededSingletonSessions(parsed, sessionId, now);
+        disconnectSupersededSingletonSessions(parsed, sessionId, agentId, now);
         recordActivityEvent({
             entityType: "session",
             entityId: sessionId,
             eventType: "agent_session_registered",
-            title: `Agent session registered: ${parsed.agentLabel}`,
+            title: `Agent session registered: ${agentLabel}`,
             description: `${parsed.provider} registered a live agent session.`,
             actor: parsed.actorLabel,
             source: "agent",

package/dist/server/server/src/repositories/model-settings.js

@@ -47,6 +47,11 @@ export function buildConnectionAgentIdentity(connection) {
         id: connection.agentId,
         label: connection.agentLabel,
         agentType: connection.provider,
+        identityKey: `model:${connection.id}`,
+        provider: null,
+        machineKey: null,
+        personaKey: connection.provider,
+        linkedUsers: [],
         trustLevel: "trusted",
         autonomyMode: "approval_required",
         approvalMode: "approval_by_default",

package/dist/server/server/src/repositories/settings.js

@@ -7,6 +7,7 @@ import { recordActivityEvent } from "./activity-events.js";
 import { recordEventLog } from "./event-log.js";
 import { resolveGoogleCalendarOauthPublicConfig } from "../services/google-calendar-oauth-config.js";
 import { buildConnectionAgentIdentity, FORGE_DEFAULT_AGENT_ID, listAiModelConnections, syncForgeManagedWikiProfile } from "./model-settings.js";
+import { listUsersByIds } from "./users.js";
 import { agentBootstrapPolicySchema, agentScopePolicySchema, createAgentTokenSchema, legacyAgentBootstrapPolicy, defaultAgentScopePolicy, agentIdentitySchema, customThemeSchema, settingsPayloadSchema, updateSettingsSchema } from "../types.js";
 const settingsFileSchema = settingsPayloadSchema.deepPartial();
 let settingsFileSyncDepth = 0;
@@ -303,11 +304,40 @@ function pickComparableOverrideSubset(source, template) {
     }
     return picked;
 }
-function mapAgent(row) {
+function listAgentIdentityUserLinks(agentIds) {
+    if (agentIds.length === 0) {
+        return new Map();
+    }
+    const placeholders = agentIds.map(() => "?").join(",");
+    const rows = getDatabase()
+        .prepare(`SELECT agent_id, user_id, role
+       FROM agent_identity_users
+       WHERE agent_id IN (${placeholders})
+       ORDER BY role = 'primary' DESC, created_at ASC`)
+        .all(...agentIds);
+    const usersById = new Map(listUsersByIds(rows.map((row) => row.user_id)).map((user) => [user.id, user]));
+    const linksByAgentId = new Map();
+    for (const row of rows) {
+        const current = linksByAgentId.get(row.agent_id) ?? [];
+        current.push({
+            userId: row.user_id,
+            role: row.role,
+            user: usersById.get(row.user_id) ?? null
+        });
+        linksByAgentId.set(row.agent_id, current);
+    }
+    return linksByAgentId;
+}
+function mapAgent(row, linkedUsers = []) {
     return agentIdentitySchema.parse({
         id: row.id,
         label: row.label,
         agentType: row.agent_type,
+        identityKey: row.identity_key,
+        provider: row.provider,
+        machineKey: row.machine_key,
+        personaKey: row.persona_key,
+        linkedUsers,
         trustLevel: row.trust_level,
         autonomyMode: row.autonomy_mode,
         approvalMode: row.approval_mode,
@@ -351,6 +381,10 @@ function findAgentIdentity(agentId) {
          agent_identities.id,
          agent_identities.label,
          agent_identities.agent_type,
+         agent_identities.identity_key,
+         agent_identities.provider,
+         agent_identities.machine_key,
+         agent_identities.persona_key,
          agent_identities.trust_level,
          agent_identities.autonomy_mode,
          agent_identities.approval_mode,
@@ -358,36 +392,76 @@ function findAgentIdentity(agentId) {
          agent_identities.created_at,
          agent_identities.updated_at,
          COUNT(agent_tokens.id) AS token_count,
-         COALESCE(SUM(CASE WHEN agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
+         COALESCE(SUM(CASE WHEN agent_tokens.id IS NOT NULL AND agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
        FROM agent_identities
        LEFT JOIN agent_tokens ON agent_tokens.agent_id = agent_identities.id
        WHERE agent_identities.id = ?
        GROUP BY agent_identities.id`)
         .get(agentId);
-    return row ? mapAgent(row) : undefined;
+    const links = row ? listAgentIdentityUserLinks([row.id]) : new Map();
+    return row ? mapAgent(row, links.get(row.id) ?? []) : undefined;
+}
+function normalizeAgentIdentityPart(value) {
+    return value
+        ?.trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._:]+/g, "_")
+        .replace(/^_+|_+$/g, "") || "";
+}
+function runtimeProviderFromAgentType(agentType) {
+    const normalized = normalizeAgentIdentityPart(agentType);
+    if (normalized === "openclaw" ||
+        normalized === "hermes" ||
+        normalized === "codex") {
+        return normalized;
+    }
+    return null;
+}
+function deriveTokenAgentIdentityFields(input) {
+    const provider = runtimeProviderFromAgentType(input.agentType);
+    if (!provider) {
+        return {
+            identityKey: null,
+            provider: null,
+            machineKey: null,
+            personaKey: null
+        };
+    }
+    return {
+        identityKey: `runtime:${provider}:token:default`,
+        provider,
+        machineKey: "token",
+        personaKey: "default"
+    };
 }
 function upsertAgentIdentity(input) {
     const now = new Date().toISOString();
+    const identityFields = deriveTokenAgentIdentityFields(input);
     const existing = getDatabase()
         .prepare(`SELECT id
        FROM agent_identities
-       WHERE lower(label) = lower(?)
+       WHERE (? IS NOT NULL AND identity_key = ?)
+          OR lower(label) = lower(?)
        LIMIT 1`)
-        .get(input.agentLabel);
+        .get(identityFields.identityKey, identityFields.identityKey, input.agentLabel);
     if (existing) {
         getDatabase()
             .prepare(`UPDATE agent_identities
-         SET agent_type = ?, trust_level = ?, autonomy_mode = ?, approval_mode = ?, description = ?, updated_at = ?
+         SET agent_type = ?, identity_key = COALESCE(identity_key, ?),
+             provider = COALESCE(provider, ?), machine_key = COALESCE(machine_key, ?),
+             persona_key = COALESCE(persona_key, ?), trust_level = ?,
+             autonomy_mode = ?, approval_mode = ?, description = ?, updated_at = ?
          WHERE id = ?`)
-            .run(input.agentType, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, existing.id);
+            .run(input.agentType, identityFields.identityKey, identityFields.provider, identityFields.machineKey, identityFields.personaKey, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, existing.id);
         return findAgentIdentity(existing.id);
     }
     const agentId = `agt_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
     getDatabase()
         .prepare(`INSERT INTO agent_identities (
-        id, label, agent_type, trust_level, autonomy_mode, approval_mode, description, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(agentId, input.agentLabel, input.agentType, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, now);
+        id, label, agent_type, identity_key, provider, machine_key, persona_key,
+        trust_level, autonomy_mode, approval_mode, description, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(agentId, input.agentLabel, input.agentType, identityFields.identityKey, identityFields.provider, identityFields.machineKey, identityFields.personaKey, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, now);
     return findAgentIdentity(agentId);
 }
 function ensureSettingsRow(now = new Date().toISOString()) {
@@ -441,6 +515,10 @@ export function listAgentIdentities() {
          agent_identities.id,
          agent_identities.label,
          agent_identities.agent_type,
+         agent_identities.identity_key,
+         agent_identities.provider,
+         agent_identities.machine_key,
+         agent_identities.persona_key,
          agent_identities.trust_level,
          agent_identities.autonomy_mode,
          agent_identities.approval_mode,
@@ -448,19 +526,25 @@ export function listAgentIdentities() {
          agent_identities.created_at,
          agent_identities.updated_at,
          COUNT(agent_tokens.id) AS token_count,
-         COALESCE(SUM(CASE WHEN agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
+         COALESCE(SUM(CASE WHEN agent_tokens.id IS NOT NULL AND agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
        FROM agent_identities
        LEFT JOIN agent_tokens ON agent_tokens.agent_id = agent_identities.id
        GROUP BY agent_identities.id
        ORDER BY agent_identities.created_at DESC`)
         .all();
-    const manualAgents = rows.map(mapAgent);
+    const links = listAgentIdentityUserLinks(rows.map((row) => row.id));
+    const manualAgents = rows.map((row) => mapAgent(row, links.get(row.id) ?? []));
     const modelAgents = listAiModelConnections().map(buildConnectionAgentIdentity);
     const settings = readSettingsRow();
     const forgeAgent = agentIdentitySchema.parse({
         id: FORGE_DEFAULT_AGENT_ID,
         label: "Forge Agent",
         agentType: "forge_default",
+        identityKey: "forge:default",
+        provider: null,
+        machineKey: null,
+        personaKey: "default",
+        linkedUsers: [],
         trustLevel: "trusted",
         autonomyMode: "approval_required",
         approvalMode: "approval_by_default",
@@ -470,7 +554,11 @@ export function listAgentIdentities() {
         createdAt: settings.created_at,
         updatedAt: settings.updated_at
     });
-    return [forgeAgent, ...modelAgents, ...manualAgents];
+    const deduped = new Map();
+    for (const agent of [forgeAgent, ...modelAgents, ...manualAgents]) {
+        deduped.set(agent.identityKey ?? agent.id, agent);
+    }
+    return Array.from(deduped.values());
 }
 export function isPsycheAuthRequired() {
     ensureSettingsRow();

package/dist/server/server/src/repositories/users.js

@@ -153,6 +153,29 @@ export function ensureSystemUsers() {
         }
     }
 }
+export function ensureBotUser(input) {
+    const parsed = createUserSchema.parse({
+        kind: "bot",
+        handle: normalizeHandle(input.handle),
+        displayName: input.displayName,
+        description: input.description,
+        accentColor: input.accentColor
+    });
+    const now = new Date().toISOString();
+    getDatabase()
+        .prepare(`INSERT INTO users (id, kind, handle, display_name, description, accent_color, created_at, updated_at)
+       VALUES (?, 'bot', ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         kind = 'bot',
+         handle = excluded.handle,
+         display_name = excluded.display_name,
+         description = excluded.description,
+         accent_color = excluded.accent_color,
+         updated_at = excluded.updated_at`)
+        .run(input.id, parsed.handle, parsed.displayName, parsed.description, parsed.accentColor, now, now);
+    ensurePermissiveGrantsForUser(input.id, now);
+    return getUserById(input.id);
+}
 function ensurePermissiveGrantsForUser(userId, now) {
     const existingUsers = listUsers();
     for (const otherUser of existingUsers) {

package/dist/server/server/src/types.js

@@ -2104,6 +2104,15 @@ export const agentIdentitySchema = z.object({
     id: z.string(),
     label: z.string(),
     agentType: z.string(),
+    identityKey: z.string().nullable().default(null),
+    provider: agentRuntimeProviderSchema.nullable().default(null),
+    machineKey: z.string().nullable().default(null),
+    personaKey: z.string().nullable().default(null),
+    linkedUsers: z.array(z.object({
+        userId: z.string(),
+        role: z.string(),
+        user: userSummarySchema.nullable().default(null)
+    })).default([]),
     trustLevel: agentTrustLevelSchema,
     autonomyMode: autonomyModeSchema,
     approvalMode: approvalModeSchema,
@@ -2188,6 +2197,10 @@ export const createAgentRuntimeSessionSchema = z.object({
     provider: agentRuntimeProviderSchema,
     agentLabel: nonEmptyTrimmedString,
     agentType: trimmedString.default("assistant"),
+    agentIdentityKey: trimmedString.optional(),
+    machineKey: trimmedString.optional(),
+    personaKey: trimmedString.optional(),
+    linkedUserIds: uniqueStringArraySchema.default([]),
     actorLabel: nonEmptyTrimmedString,
     sessionKey: nonEmptyTrimmedString,
     sessionLabel: trimmedString.default(""),

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "forge-openclaw-plugin",
   "name": "Forge",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
-  "version": "0.2.48",
+  "version": "0.2.49",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.48",
+  "version": "0.2.49",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "MIT",
@@ -95,10 +95,13 @@
     "zustand": "^5.0.5"
   },
   "overrides": {
+    "@aws-sdk/xml-builder": "^3.972.19",
     "basic-ftp": "^5.3.0",
     "axios": "^1.15.0",
+    "fast-xml-parser": "^5.7.1",
     "follow-redirects": "^1.16.0",
-    "hono": "4.12.14"
+    "hono": "4.12.14",
+    "uuid": "^14.0.0"
   },
   "scripts": {
     "build": "node ./scripts/build.mjs"