@haaaiawd/second-nature 0.1.1 → 0.1.3

package/runtime/connectors/social-community/moltbook/adapter.d.ts

@@ -0,0 +1,15 @@
+import type { ConnectorRequest, ExecutionPlan, RawAttempt } from "../../base/contract.js";
+export interface MoltbookApiClient {
+    readFeed(payload: Record<string, unknown>): Promise<unknown>;
+    publishPost(payload: Record<string, unknown>): Promise<unknown>;
+    replyComment(payload: Record<string, unknown>): Promise<unknown>;
+}
+export interface MoltbookSkillRunner {
+    run(intent: string, payload: Record<string, unknown>): Promise<unknown>;
+}
+export declare function createMoltbookRunner(input: {
+    apiClient: MoltbookApiClient;
+    skillRunner: MoltbookSkillRunner;
+}): {
+    run(plan: ExecutionPlan, request: ConnectorRequest): Promise<RawAttempt>;
+};

package/runtime/connectors/social-community/moltbook/adapter.js

@@ -0,0 +1,48 @@
+export function createMoltbookRunner(input) {
+    const { apiClient, skillRunner } = input;
+    return {
+        async run(plan, request) {
+            const started = Date.now();
+            try {
+                const payload = await executeByChannel(plan, request.payload, apiClient, skillRunner);
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill" || plan.channel === "browser",
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: plan.channel,
+                        data: payload,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    degraded: plan.channel === "skill" || plan.channel === "browser",
+                    success: false,
+                    error,
+                };
+            }
+        },
+    };
+}
+async function executeByChannel(plan, payload, apiClient, skillRunner) {
+    if (plan.channel === "api_rest") {
+        if (plan.intent === "feed.read")
+            return apiClient.readFeed(payload);
+        if (plan.intent === "post.publish")
+            return apiClient.publishPost(payload);
+        if (plan.intent === "comment.reply")
+            return apiClient.replyComment(payload);
+        throw { code: "protocol_mismatch", detail: `unsupported intent for moltbook api: ${plan.intent}` };
+    }
+    if (plan.channel === "skill" || plan.channel === "browser") {
+        return skillRunner.run(plan.intent, payload);
+    }
+    throw { code: "protocol_mismatch", detail: `unsupported channel for moltbook: ${plan.channel}` };
+}

package/runtime/connectors/social-community/moltbook/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./manifest.js";
+export * from "./adapter.js";

package/runtime/connectors/social-community/moltbook/index.js

@@ -0,0 +1,2 @@
+export * from "./manifest.js";
+export * from "./adapter.js";

package/runtime/connectors/social-community/moltbook/manifest.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectorManifest } from "../../base/manifest.js";
+export declare const moltbookManifest: ConnectorManifest;
+export declare const MOLTBOOK_DOC_RISK: {
+    readonly key: "moltbook_skill_doc_availability";
+    readonly fallbackChannel: "skill";
+    readonly note: "official skill/doc may be transiently unavailable; adapter seam remains replaceable via injected skill runner";
+};

package/runtime/connectors/social-community/moltbook/manifest.js

@@ -0,0 +1,12 @@
+export const moltbookManifest = {
+    platformId: "moltbook",
+    supportedCapabilities: ["feed.read", "post.publish", "comment.reply"],
+    channelPriority: ["api_rest", "skill", "browser"],
+    credentialTypes: ["api_key"],
+    degradedChannels: ["skill", "browser"],
+};
+export const MOLTBOOK_DOC_RISK = {
+    key: "moltbook_skill_doc_availability",
+    fallbackChannel: "skill",
+    note: "official skill/doc may be transiently unavailable; adapter seam remains replaceable via injected skill runner",
+};

package/runtime/core/second-nature/guidance/apply-guidance.d.ts

@@ -0,0 +1,10 @@
+import type { GuidanceFallback, GuidancePayload } from "../../../guidance/index.js";
+export interface AppliedGuidanceContext {
+    source: "guidance_payload" | "minimal_fallback";
+    sceneType: string;
+    atmosphereText?: string;
+    impulseTexts: string[];
+    personaRationales: string[];
+    outputConstraints: string[];
+}
+export declare function applyGuidance(input: GuidancePayload | GuidanceFallback): AppliedGuidanceContext;

package/runtime/core/second-nature/guidance/apply-guidance.js

@@ -0,0 +1,10 @@
+export function applyGuidance(input) {
+    return {
+        source: "minimal" in input && input.minimal ? "minimal_fallback" : "guidance_payload",
+        sceneType: input.scene.sceneType,
+        atmosphereText: input.atmosphere?.text,
+        impulseTexts: input.impulses.map((item) => item.text),
+        personaRationales: input.personaReinforcement.map((item) => item.rationale),
+        outputConstraints: input.outputGuard?.constraints ?? [],
+    };
+}

package/runtime/core/second-nature/guidance/request-guidance.d.ts

@@ -0,0 +1,18 @@
+import { type GuidanceFallback, type GuidancePayload, type GuidanceUnavailable, type PersonaCandidate, type SceneContext } from "../../../guidance/index.js";
+export interface RequestGuidancePort {
+    assembleGuidance(input: {
+        sceneContext: SceneContext;
+        personaCandidates: PersonaCandidate[];
+    }): Promise<GuidancePayload | GuidanceUnavailable>;
+}
+export interface RequestGuidanceResult {
+    owner: "control-plane-system";
+    sceneContext: SceneContext;
+    guidance: GuidancePayload | GuidanceFallback;
+    usedFallback: boolean;
+}
+export declare function requestGuidance(input: {
+    sceneContext: SceneContext;
+    personaCandidates?: PersonaCandidate[];
+    port?: RequestGuidancePort;
+}): Promise<RequestGuidanceResult>;

package/runtime/core/second-nature/guidance/request-guidance.js

@@ -0,0 +1,22 @@
+import { assembleGuidance, buildMinimalGuidanceFallback, } from "../../../guidance/index.js";
+export async function requestGuidance(input) {
+    const port = input.port ?? { assembleGuidance };
+    const result = await port.assembleGuidance({
+        sceneContext: input.sceneContext,
+        personaCandidates: input.personaCandidates ?? [],
+    });
+    if ("available" in result) {
+        return {
+            owner: "control-plane-system",
+            sceneContext: input.sceneContext,
+            guidance: buildMinimalGuidanceFallback(input.sceneContext),
+            usedFallback: true,
+        };
+    }
+    return {
+        owner: "control-plane-system",
+        sceneContext: input.sceneContext,
+        guidance: result,
+        usedFallback: false,
+    };
+}

package/runtime/core/second-nature/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./types.js";
+export * from "./rhythm/rhythm-policy.js";
+export * from "./rhythm/select-window.js";
+export * from "./orchestrator/intent-planner.js";
+export * from "./orchestrator/guard-layer.js";
+export * from "./orchestrator/lease-manager.js";
+export * from "./orchestrator/effect-dispatcher.js";
+export * from "./orchestrator/resume-from-checkpoint.js";
+export * from "./quiet/quiet-pipeline.js";
+export * from "./reflection/run-narrative-reflection.js";
+export * from "./outreach/evaluate-outreach.js";
+export * from "./outreach/build-message.js";
+export * from "./guidance/request-guidance.js";
+export * from "./guidance/apply-guidance.js";

package/runtime/core/second-nature/index.js

@@ -0,0 +1,14 @@
+export * from "./types.js";
+export * from "./rhythm/rhythm-policy.js";
+export * from "./rhythm/select-window.js";
+export * from "./orchestrator/intent-planner.js";
+export * from "./orchestrator/guard-layer.js";
+export * from "./orchestrator/lease-manager.js";
+export * from "./orchestrator/effect-dispatcher.js";
+export * from "./orchestrator/resume-from-checkpoint.js";
+export * from "./quiet/quiet-pipeline.js";
+export * from "./reflection/run-narrative-reflection.js";
+export * from "./outreach/evaluate-outreach.js";
+export * from "./outreach/build-message.js";
+export * from "./guidance/request-guidance.js";
+export * from "./guidance/apply-guidance.js";

package/runtime/core/second-nature/orchestrator/effect-dispatcher.d.ts

@@ -0,0 +1,100 @@
+import type { ConnectorResult, CapabilityIntent } from "../../../connectors/base/contract.js";
+import { LeaseManager, type EffectClass } from "./lease-manager.js";
+export interface AllowedIntent {
+    id: string;
+    kind: "work" | "exploration" | "social" | "reflection" | "outreach" | "maintenance";
+    summary: string;
+    effectClass: EffectClass;
+    platformId?: string;
+    payload?: Record<string, unknown>;
+}
+export interface DecisionContext {
+    decisionId: string;
+    intentId: string;
+    tickId: string;
+    checkpointId: string;
+    traceId: string;
+}
+export interface IntentCommitPort {
+    createIntentCommitRecord(input: {
+        intentId: string;
+        decisionId: string;
+        checkpointId?: string;
+        state: "planned" | "dispatched" | "externally_acknowledged" | "committed" | "reconcile" | "aborted";
+    }): Promise<{
+        id: string;
+    }>;
+    advanceIntentCommitState(id: string, state: "planned" | "dispatched" | "externally_acknowledged" | "committed" | "reconcile" | "aborted", metadata?: Record<string, unknown>): Promise<void>;
+    commitIntentOutcome(id: string, outcome: {
+        traceId: string;
+        outcomeRef: string;
+    }): Promise<void>;
+    abortIntentCommit(id: string, reason: string): Promise<void>;
+}
+export interface ConnectorExecutor {
+    executeEffect(input: {
+        platformId: string;
+        intent: CapabilityIntent;
+        payload: Record<string, unknown>;
+        decisionId: string;
+        intentId: string;
+        idempotencyKey: string;
+    }): Promise<ConnectorResult<unknown>>;
+}
+export interface CheckpointPort {
+    saveCheckpoint(input: {
+        id: string;
+        tickId: string;
+        intentId: string;
+        phase: "before_effect" | "before_quiet_write";
+        snapshotRef: string;
+    }): Promise<void>;
+}
+export interface MemoryPort {
+    persistCurationResult(input: {
+        summary: string;
+        sourceRefs: string[];
+        traceId: string;
+    }): Promise<void>;
+}
+export interface ReflectionPort {
+    runNarrativeReflection(input: {
+        decisionId: string;
+        intentId: string;
+        traceId: string;
+    }): Promise<{
+        outcomeRef: string;
+    }>;
+}
+export type DispatchResult = {
+    status: "deferred";
+    reason: string;
+} | {
+    status: "effect_executed";
+    result: ConnectorResult<unknown>;
+    commitId: string;
+} | {
+    status: "curated";
+    commitId: string;
+} | {
+    status: "reflected";
+    commitId: string;
+} | {
+    status: "maintenance_done";
+    commitId: string;
+};
+export declare class EffectDispatcher {
+    private readonly leaseManager;
+    private readonly commitPort;
+    private readonly connectorExecutor;
+    private readonly checkpointPort;
+    private readonly memoryPort;
+    private readonly reflectionPort;
+    constructor(leaseManager: LeaseManager, commitPort: IntentCommitPort, connectorExecutor: ConnectorExecutor, checkpointPort: CheckpointPort, memoryPort: MemoryPort, reflectionPort: ReflectionPort);
+    dispatchEffect(intent: AllowedIntent, decision: DecisionContext): Promise<DispatchResult>;
+}
+export declare function buildDecisionContext(input: {
+    tickId: string;
+    decisionId?: string;
+    intentId: string;
+}): DecisionContext;

package/runtime/core/second-nature/orchestrator/effect-dispatcher.js

@@ -0,0 +1,139 @@
+import * as crypto from "crypto";
+function needsLease(effectClass) {
+    return effectClass === "external_platform_action" || effectClass === "user_outreach";
+}
+function needsCheckpoint(effectClass) {
+    return effectClass !== "maintenance";
+}
+function toCapabilityIntent(intent) {
+    if (intent.kind === "work")
+        return "work.discover";
+    if (intent.kind === "exploration")
+        return "feed.read";
+    if (intent.kind === "social")
+        return "comment.reply";
+    if (intent.kind === "outreach")
+        return "message.send";
+    return "feed.read";
+}
+export class EffectDispatcher {
+    leaseManager;
+    commitPort;
+    connectorExecutor;
+    checkpointPort;
+    memoryPort;
+    reflectionPort;
+    constructor(leaseManager, commitPort, connectorExecutor, checkpointPort, memoryPort, reflectionPort) {
+        this.leaseManager = leaseManager;
+        this.commitPort = commitPort;
+        this.connectorExecutor = connectorExecutor;
+        this.checkpointPort = checkpointPort;
+        this.memoryPort = memoryPort;
+        this.reflectionPort = reflectionPort;
+    }
+    async dispatchEffect(intent, decision) {
+        const lease = needsLease(intent.effectClass)
+            ? await this.leaseManager.acquire(intent.effectClass, intent.platformId ?? intent.id)
+            : await this.leaseManager.acquire("maintenance");
+        if (!lease.granted) {
+            return { status: "deferred", reason: "lease_unavailable" };
+        }
+        if (needsCheckpoint(intent.effectClass)) {
+            await this.checkpointPort.saveCheckpoint({
+                id: decision.checkpointId,
+                tickId: decision.tickId,
+                intentId: decision.intentId,
+                phase: intent.effectClass === "external_platform_action" ? "before_effect" : "before_quiet_write",
+                snapshotRef: decision.traceId,
+            });
+        }
+        const commit = await this.commitPort.createIntentCommitRecord({
+            intentId: decision.intentId,
+            decisionId: decision.decisionId,
+            checkpointId: decision.checkpointId,
+            state: "planned",
+        });
+        try {
+            if (intent.effectClass === "external_platform_action") {
+                await this.commitPort.advanceIntentCommitState(commit.id, "dispatched");
+                const result = await this.connectorExecutor.executeEffect({
+                    platformId: intent.platformId ?? "unknown",
+                    intent: toCapabilityIntent(intent),
+                    payload: intent.payload ?? {},
+                    decisionId: decision.decisionId,
+                    intentId: decision.intentId,
+                    idempotencyKey: `idem:${decision.decisionId}:${decision.intentId}`,
+                });
+                if (result.status === "success") {
+                    await this.commitPort.advanceIntentCommitState(commit.id, "externally_acknowledged", {
+                        outcomeRef: result.metadata.platformId,
+                    });
+                    await this.commitPort.commitIntentOutcome(commit.id, {
+                        traceId: decision.traceId,
+                        outcomeRef: result.metadata.platformId,
+                    });
+                }
+                else {
+                    if (result.status === "retryable_failure") {
+                        await this.commitPort.advanceIntentCommitState(commit.id, "reconcile", {
+                            failureClass: result.failureClass,
+                        });
+                    }
+                    else {
+                        await this.commitPort.abortIntentCommit(commit.id, result.failureClass ?? "external_effect_failed");
+                    }
+                }
+                return { status: "effect_executed", result, commitId: commit.id };
+            }
+            if (intent.effectClass === "memory_curation") {
+                await this.commitPort.advanceIntentCommitState(commit.id, "dispatched");
+                await this.memoryPort.persistCurationResult({
+                    summary: intent.summary,
+                    sourceRefs: [decision.traceId],
+                    traceId: decision.traceId,
+                });
+                await this.commitPort.commitIntentOutcome(commit.id, {
+                    traceId: decision.traceId,
+                    outcomeRef: "memory_curation",
+                });
+                return { status: "curated", commitId: commit.id };
+            }
+            if (intent.effectClass === "narrative_reflection") {
+                await this.commitPort.advanceIntentCommitState(commit.id, "dispatched");
+                const reflection = await this.reflectionPort.runNarrativeReflection({
+                    decisionId: decision.decisionId,
+                    intentId: decision.intentId,
+                    traceId: decision.traceId,
+                });
+                await this.commitPort.commitIntentOutcome(commit.id, {
+                    traceId: decision.traceId,
+                    outcomeRef: reflection.outcomeRef,
+                });
+                return { status: "reflected", commitId: commit.id };
+            }
+            await this.commitPort.advanceIntentCommitState(commit.id, "dispatched");
+            await this.commitPort.commitIntentOutcome(commit.id, {
+                traceId: decision.traceId,
+                outcomeRef: "maintenance",
+            });
+            return { status: "maintenance_done", commitId: commit.id };
+        }
+        catch (error) {
+            await this.commitPort.abortIntentCommit(commit.id, String(error));
+            throw error;
+        }
+        finally {
+            await lease.release();
+        }
+    }
+}
+export function buildDecisionContext(input) {
+    const decisionId = input.decisionId ?? crypto.randomUUID();
+    return {
+        decisionId,
+        intentId: input.intentId,
+        tickId: input.tickId,
+        checkpointId: `checkpoint:${input.intentId}:${Date.now()}`,
+        traceId: `trace:${decisionId}`,
+    };
+}

package/runtime/core/second-nature/orchestrator/guard-layer.d.ts

@@ -0,0 +1,2 @@
+import type { CandidateIntent, ContinuitySnapshot, GuardEvaluation } from "../types.js";
+export declare function evaluateGuards(intent: CandidateIntent, snapshot: ContinuitySnapshot): GuardEvaluation;

package/runtime/core/second-nature/orchestrator/guard-layer.js

@@ -0,0 +1,54 @@
+function stableIntentHash(intent) {
+    return `${intent.kind}:${intent.summary}`;
+}
+function isDuplicateIntent(intent, snapshot) {
+    const hash = stableIntentHash(intent);
+    return snapshot.deniedIntents.some((item) => item.intentHash === hash && item.reason === "duplicate_intent");
+}
+function isBudgetExceeded(intent, snapshot) {
+    if (intent.kind !== "social")
+        return false;
+    if (!snapshot.budgets)
+        return false;
+    return snapshot.budgets.socialUsed >= snapshot.budgets.socialLimit;
+}
+function isQuietSuppressed(intent, snapshot) {
+    if (snapshot.mode !== "quiet")
+        return false;
+    if (intent.effectClass === "maintenance" || intent.effectClass === "memory_curation" || intent.effectClass === "narrative_reflection") {
+        return false;
+    }
+    return true;
+}
+export function evaluateGuards(intent, snapshot) {
+    const reasons = [];
+    if (isDuplicateIntent(intent, snapshot)) {
+        reasons.push("duplicate_intent");
+    }
+    if (isBudgetExceeded(intent, snapshot)) {
+        reasons.push("budget_exceeded");
+    }
+    if (isQuietSuppressed(intent, snapshot)) {
+        reasons.push("quiet_window");
+    }
+    if (snapshot.awaitingUserInput) {
+        reasons.push("awaiting_user");
+    }
+    if (reasons.length === 0) {
+        return {
+            verdict: "allow",
+            reasons,
+            quietSuppressed: false,
+            leaseRequired: intent.effectClass === "external_platform_action" || intent.effectClass === "user_outreach",
+            requiresCheckpoint: intent.effectClass !== "maintenance",
+        };
+    }
+    const escalated = reasons.includes("awaiting_user") && intent.kind === "outreach";
+    return {
+        verdict: escalated ? "escalate" : "deny",
+        reasons,
+        quietSuppressed: reasons.includes("quiet_window"),
+        leaseRequired: false,
+        requiresCheckpoint: false,
+    };
+}

package/runtime/core/second-nature/orchestrator/intent-planner.d.ts

@@ -0,0 +1,3 @@
+import type { CandidateIntent, ContinuitySnapshot, DecisionBasis } from "../types.js";
+export declare function planIntent(snapshot: ContinuitySnapshot): CandidateIntent[];
+export declare function decideDecisionBasis(intent: CandidateIntent): DecisionBasis;

package/runtime/core/second-nature/orchestrator/intent-planner.js

@@ -0,0 +1,92 @@
+const MAX_CANDIDATES = 6;
+function planObligationIntents(snapshot) {
+    return snapshot.pendingObligations.map((obligation, index) => ({
+        id: `intent-obligation-${index}`,
+        kind: "work",
+        priority: 100 - index,
+        source: "obligation",
+        summary: `fulfill obligation: ${obligation}`,
+        effectClass: "external_platform_action",
+    }));
+}
+function planPlatformIntents(snapshot) {
+    const socialPriorityBase = snapshot.budgets && snapshot.budgets.socialUsed >= snapshot.budgets.socialLimit ? 10 : 60;
+    return [
+        {
+            id: "intent-exploration",
+            kind: "exploration",
+            priority: 70,
+            source: "tick",
+            summary: "scan platform opportunities",
+            effectClass: "external_platform_action",
+        },
+        {
+            id: "intent-social",
+            kind: "social",
+            priority: socialPriorityBase,
+            source: "tick",
+            summary: "engage social platforms",
+            effectClass: "external_platform_action",
+        },
+    ];
+}
+function planQuietIntents(snapshot) {
+    if (snapshot.mode !== "quiet") {
+        return [];
+    }
+    return [
+        {
+            id: "intent-maintenance",
+            kind: "maintenance",
+            priority: 90,
+            source: "quiet_plan",
+            summary: "run maintenance checks",
+            effectClass: "maintenance",
+        },
+        {
+            id: "intent-reflection",
+            kind: "reflection",
+            priority: 80,
+            source: "quiet_plan",
+            summary: "run narrative reflection",
+            effectClass: "narrative_reflection",
+        },
+    ];
+}
+function planOutreachIntents(snapshot) {
+    if (snapshot.recentOutreachHashes.length > 3) {
+        return [];
+    }
+    return [
+        {
+            id: "intent-outreach",
+            kind: "outreach",
+            priority: 40,
+            source: "tick",
+            summary: "consider proactive user outreach",
+            effectClass: "user_outreach",
+        },
+    ];
+}
+export function planIntent(snapshot) {
+    const intents = [
+        ...planObligationIntents(snapshot),
+        ...planPlatformIntents(snapshot),
+        ...planQuietIntents(snapshot),
+        ...planOutreachIntents(snapshot),
+    ];
+    return intents
+        .sort((a, b) => b.priority - a.priority)
+        .slice(0, MAX_CANDIDATES);
+}
+export function decideDecisionBasis(intent) {
+    if (intent.source === "obligation")
+        return "rule_only";
+    if (intent.kind === "maintenance")
+        return "rule_only";
+    if (intent.kind === "outreach" || intent.kind === "reflection")
+        return "model_assisted";
+    if (intent.kind === "exploration" || intent.kind === "social" || intent.kind === "work")
+        return "score_based";
+    return "rule_only";
+}

package/runtime/core/second-nature/orchestrator/lease-manager.d.ts

@@ -0,0 +1,14 @@
+export type EffectClass = "external_platform_action" | "memory_curation" | "narrative_reflection" | "user_outreach" | "maintenance";
+export interface LeaseHandle {
+    id: string;
+    granted: boolean;
+    scope: string;
+    release(): Promise<void>;
+}
+export declare class LeaseManager {
+    private readonly ttlMs;
+    private readonly leases;
+    constructor(ttlMs?: number);
+    acquire(effectClass: EffectClass, scopeHint?: string): Promise<LeaseHandle>;
+    private resolveScope;
+}

package/runtime/core/second-nature/orchestrator/lease-manager.js

@@ -0,0 +1,58 @@
+import * as crypto from "crypto";
+const GLOBAL_SCOPE = "global-control-plane-flight";
+const DEFAULT_TTL_MS = 90_000;
+export class LeaseManager {
+    ttlMs;
+    leases = new Map();
+    constructor(ttlMs = DEFAULT_TTL_MS) {
+        this.ttlMs = ttlMs;
+    }
+    async acquire(effectClass, scopeHint) {
+        const scope = this.resolveScope(effectClass, scopeHint);
+        if (!scope) {
+            return {
+                id: "no-lease-required",
+                granted: true,
+                scope: "none",
+                async release() {
+                    return;
+                },
+            };
+        }
+        const now = Date.now();
+        const existing = this.leases.get(scope);
+        if (existing && existing.expiresAt > now) {
+            return {
+                id: existing.id,
+                granted: false,
+                scope,
+                async release() {
+                    return;
+                },
+            };
+        }
+        const record = {
+            id: crypto.randomUUID(),
+            scope,
+            expiresAt: now + this.ttlMs,
+        };
+        this.leases.set(scope, record);
+        return {
+            id: record.id,
+            granted: true,
+            scope,
+            release: async () => {
+                const current = this.leases.get(scope);
+                if (current && current.id === record.id) {
+                    this.leases.delete(scope);
+                }
+            },
+        };
+    }
+    resolveScope(effectClass, scopeHint) {
+        if (effectClass === "external_platform_action" || effectClass === "user_outreach") {
+            return scopeHint && scopeHint.length > 0 ? `${GLOBAL_SCOPE}:${scopeHint}` : GLOBAL_SCOPE;
+        }
+        return null;
+    }
+}