@haaaiawd/second-nature 0.1.39 → 0.1.41

package/runtime/connectors/services/connector-executor-adapter.js

@@ -14,6 +14,8 @@ import { createCredentialVault } from "../../storage/services/credential-vault.j
 import { createCredentialRouteContextPort } from "./credential-route-context.js";
 import { scanConnectorManifests } from "../registry/manifest-scanner.js";
 import { parseConnectorManifestV6 } from "../manifest/manifest-parser.js";
+import fs from "node:fs";
+import path from "node:path";
 const DEFAULT_AGENT_WORLD_USERNAME = "nyx_ha";
 const DEFAULT_AGENT_WORLD_PROFILE_PATH_TEMPLATE = "/api/agents/profile/{username}";
 function readString(value) {
@@ -101,71 +103,206 @@ async function fetchAgentWorldJson(input) {
     }
     return resp.json();
 }
-function createAdaptiveExecutionRunner(vault) {
+function createMoltbookMockRunner(workspaceRoot) {
     return {
         async run(_plan, request) {
-            const platformId = request.platformId;
             const started = Date.now();
-            if (platformId !== "moltbook" &&
-                platformId !== "evomap" &&
-                platformId !== "agent-world") {
+            const mockPath = workspaceRoot
+                ? path.join(workspaceRoot, ".second-nature", "mock", "moltbook-feed.json")
+                : undefined;
+            if (!mockPath || !fs.existsSync(mockPath)) {
                 return {
-                    platformId,
+                    platformId: request.platformId,
                     channel: request.preferredChannel ?? "api_rest",
                     latencyMs: Date.now() - started,
                     success: false,
                     error: {
-                        code: "unknown_platform",
-                        detail: `no execution runner for ${platformId}`,
+                        code: "configuration_missing",
+                        detail: "SECOND_NATURE_MOLTBOOK_BASE_URL not set and no mock data found",
                     },
                 };
             }
-            const credential = await vault.loadCredentialContext(platformId);
-            if (!credential ||
-                credential.status !== "active" ||
-                !credential.encryptedValue) {
+            try {
+                const raw = fs.readFileSync(mockPath, "utf-8");
+                const data = JSON.parse(raw);
                 return {
-                    platformId,
+                    platformId: request.platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    degraded: true,
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: request.preferredChannel ?? "api_rest",
+                        data: {
+                            source: "mock",
+                            items: Array.isArray(data.items) ? data.items : [],
+                        },
+                    },
+                };
+            }
+            catch (err) {
+                return {
+                    platformId: request.platformId,
                     channel: request.preferredChannel ?? "api_rest",
                     latencyMs: Date.now() - started,
                     success: false,
                     error: {
-                        code: "auth_failure",
-                        detail: "credential_unavailable_for_execution",
+                        code: "mock_read_error",
+                        detail: String(err),
                     },
                 };
             }
-            if (platformId === "moltbook") {
-                const baseUrl = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-                if (!baseUrl) {
+        },
+    };
+}
+function findWorkspaceManifest(platformId, workspaceRoot) {
+    if (!workspaceRoot)
+        return undefined;
+    for (const file of scanConnectorManifests(workspaceRoot)) {
+        const parsed = parseConnectorManifestV6(file.content, file.path);
+        if (parsed.ok && parsed.manifest.platformId === platformId) {
+            return parsed.manifest;
+        }
+    }
+    return undefined;
+}
+function resolveDeclarativeHttpPath(capabilityId) {
+    return `/${capabilityId.replace(/\./g, "/")}`;
+}
+function resolveDeclarativeHttpMethod(capabilityId) {
+    const readOps = ["read", "list", "discover", "get", "heartbeat", "fetch"];
+    if (readOps.some((op) => capabilityId.includes(op)))
+        return "GET";
+    return "POST";
+}
+function createDeclarativeHttpRunner(manifest, credential) {
+    return {
+        async run(plan, request) {
+            const started = Date.now();
+            const baseUrl = manifest.runner.config?.baseUrl ?? "";
+            if (!baseUrl) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "configuration_missing",
+                        detail: "runner.config.baseUrl not set for declarative_http connector",
+                    },
+                };
+            }
+            const httpPath = resolveDeclarativeHttpPath(request.intent);
+            const method = resolveDeclarativeHttpMethod(request.intent);
+            try {
+                const headers = {
+                    "Content-Type": "application/json",
+                };
+                if (credential?.encryptedValue) {
+                    headers.Authorization = `Bearer ${credential.encryptedValue}`;
+                }
+                const resp = await fetch(`${baseUrl.replace(/\/+$/, "")}${httpPath}`, {
+                    method,
+                    headers,
+                    body: method !== "GET" && request.payload ? JSON.stringify(request.payload) : undefined,
+                });
+                if (!resp.ok) {
                     return {
-                        platformId,
-                        channel: request.preferredChannel ?? "api_rest",
+                        platformId: request.platformId,
+                        channel: plan.channel,
                         latencyMs: Date.now() - started,
                         success: false,
                         error: {
-                            code: "configuration_missing",
-                            detail: "SECOND_NATURE_MOLTBOOK_BASE_URL not set",
+                            code: "api_error",
+                            detail: `HTTP ${resp.status}: ${await resp.text().catch(() => "")}`,
                         },
                     };
                 }
-                const apiClient = createMoltbookApiClient({
-                    baseUrl,
-                    accessToken: credential.encryptedValue,
-                    timeoutMs: 10000,
-                });
-                const runner = createMoltbookRunner({
-                    apiClient,
-                    skillRunner: {
-                        run: async () => {
-                            throw {
-                                code: "protocol_mismatch",
-                                detail: "moltbook_skill_runner_not_configured",
-                            };
-                        },
+                const data = await resp.json();
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: plan.channel,
+                        data,
                     },
-                });
-                return runner.run(_plan, request);
+                };
+            }
+            catch (err) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "network_error",
+                        detail: String(err),
+                    },
+                };
+            }
+        },
+    };
+}
+function createAdaptiveExecutionRunner(vault, workspaceRoot) {
+    return {
+        async run(_plan, request) {
+            const platformId = request.platformId;
+            const started = Date.now();
+            const workspaceManifest = findWorkspaceManifest(platformId, workspaceRoot);
+            const isBuiltInPlatform = platformId === "moltbook" ||
+                platformId === "evomap" ||
+                platformId === "agent-world";
+            const requiresCredential = isBuiltInPlatform ||
+                Boolean(workspaceManifest?.credentials.some((credential) => credential.required !== false));
+            const credential = requiresCredential
+                ? await vault.loadCredentialContext(platformId)
+                : undefined;
+            if (requiresCredential &&
+                (!credential ||
+                    credential.status !== "active" ||
+                    !credential.encryptedValue)) {
+                return {
+                    platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "auth_failure",
+                        detail: "credential_unavailable_for_execution",
+                    },
+                };
+            }
+            const activeCredential = credential?.status === "active" && credential.encryptedValue
+                ? { encryptedValue: credential.encryptedValue }
+                : undefined;
+            if (platformId === "moltbook") {
+                const baseUrl = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+                if (baseUrl) {
+                    const apiClient = createMoltbookApiClient({
+                        baseUrl,
+                        accessToken: activeCredential.encryptedValue,
+                        timeoutMs: 10000,
+                    });
+                    const runner = createMoltbookRunner({
+                        apiClient,
+                        skillRunner: {
+                            run: async () => {
+                                throw {
+                                    code: "protocol_mismatch",
+                                    detail: "moltbook_skill_runner_not_configured",
+                                };
+                            },
+                        },
+                    });
+                    return runner.run(_plan, request);
+                }
+                // Mock fallback when real API is not configured
+                const mockRunner = createMoltbookMockRunner(workspaceRoot);
+                return mockRunner.run(_plan, request);
             }
             if (platformId === "evomap") {
                 return {
@@ -194,7 +331,7 @@ function createAdaptiveExecutionRunner(vault) {
                     };
                 }
                 const runner = createAgentWorldRunner({
-                    apiKey: credential.encryptedValue,
+                    apiKey: activeCredential.encryptedValue,
                     apiClient: {
                         async readFeed(payload, _apiKey) {
                             const username = resolveAgentWorldUsername(payload, "feed");
@@ -235,7 +372,21 @@ function createAdaptiveExecutionRunner(vault) {
                 });
                 return runner.run(_plan, request);
             }
-            throw new Error(`unreachable_connector_platform:${platformId}`);
+            // Wave 83: workspace declarative_http connector fallback
+            if (workspaceManifest && workspaceManifest.runner.kind === "declarative_http") {
+                const httpRunner = createDeclarativeHttpRunner(workspaceManifest, activeCredential);
+                return httpRunner.run(_plan, request);
+            }
+            return {
+                platformId,
+                channel: request.preferredChannel ?? "api_rest",
+                latencyMs: Date.now() - started,
+                success: false,
+                error: {
+                    code: "unknown_platform",
+                    detail: `no execution runner for ${platformId}`,
+                },
+            };
         },
     };
 }
@@ -249,7 +400,7 @@ export function createConnectorExecutorAdapter(options) {
     const routeContextPort = createCredentialRouteContextPort(vault);
     const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
     const telemetry = new ExecutionTelemetry(options.observabilityDb);
-    const executionRunner = createAdaptiveExecutionRunner(vault);
+    const executionRunner = createAdaptiveExecutionRunner(vault, options.workspaceRoot);
     const policy = createConnectorPolicyLayer({
         routePlanner,
         executionRunner,

package/runtime/core/second-nature/body/tool-affordance/affordance-context-scope.d.ts

@@ -5,7 +5,7 @@
  * - platformIds whitelist (empty = all platforms)
  * - goalKind trust-tier filtering (task_completion prefers write/claim;
  *   passive_sensing exposes only read-only)
- * - allowedStatuses defaults to safe subset; blocked/pending_trust always excluded
+ * - allowedStatuses defaults to heartbeat-usable statuses; blocked/pending_trust always excluded
  * - Credential-bearing items never enter affordance (ADR-003)
  *
  * Dependencies:

package/runtime/core/second-nature/body/tool-affordance/affordance-context-scope.js

@@ -5,7 +5,7 @@
  * - platformIds whitelist (empty = all platforms)
  * - goalKind trust-tier filtering (task_completion prefers write/claim;
  *   passive_sensing exposes only read-only)
- * - allowedStatuses defaults to safe subset; blocked/pending_trust always excluded
+ * - allowedStatuses defaults to heartbeat-usable statuses; blocked/pending_trust always excluded
  * - Credential-bearing items never enter affordance (ADR-003)
  *
  * Dependencies:
@@ -20,6 +20,7 @@
 export const DEFAULT_ALLOWED_STATUSES = [
     "safe",
     "exploratory",
+    "needs_auth",
 ];
 const BLOCKED_STATUSES = [
     "unavailable", // painful is allowed for diagnostics; unavailable is blocked from active use

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

@@ -1,12 +1,12 @@
-import type { GuidanceFallback, GuidancePayload } from "../../../guidance/index.js";
-export interface AppliedGuidanceContext {
-    source: "guidance_payload" | "minimal_fallback";
-    sceneType: string;
-    atmosphereText?: string;
-    impulseTexts: string[];
-    personaRationales: string[];
-    /** @deprecated Use expressionConstraints. Kept for backward compatibility. */
-    outputConstraints: string[];
-    expressionConstraints: string[];
-}
-export declare function applyGuidance(input: GuidancePayload | GuidanceFallback): AppliedGuidanceContext;
+import type { GuidanceFallback, GuidancePayload } from "../../../guidance/index.js";
+export interface AppliedGuidanceContext {
+    source: "guidance_payload" | "minimal_fallback";
+    sceneType: string;
+    atmosphereText?: string;
+    impulseTexts: string[];
+    personaRationales: string[];
+    /** @deprecated Use expressionConstraints. Kept for backward compatibility. */
+    outputConstraints: string[];
+    expressionConstraints: string[];
+}
+export declare function applyGuidance(input: GuidancePayload | GuidanceFallback): AppliedGuidanceContext;

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

@@ -1,15 +1,15 @@
-export function applyGuidance(input) {
-    const isMinimal = "minimal" in input && input.minimal;
-    const boundaryConstraints = input.expressionBoundary?.constraints
-        ?? input.outputGuard?.constraints
-        ?? [];
-    return {
-        source: isMinimal ? "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 ?? [],
-        expressionConstraints: boundaryConstraints,
-    };
-}
+export function applyGuidance(input) {
+    const isMinimal = "minimal" in input && input.minimal;
+    const boundaryConstraints = input.expressionBoundary?.constraints
+        ?? input.outputGuard?.constraints
+        ?? [];
+    return {
+        source: isMinimal ? "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 ?? [],
+        expressionConstraints: boundaryConstraints,
+    };
+}

package/runtime/core/second-nature/guidance/user-reply-continuity.d.ts

@@ -1,50 +1,50 @@
-/**
- * User Reply Light Continuity Contract
- *
- * Per T6.1.1: Provides very light continuity guidance for direct user replies.
- * This is separate from the platform `reply` scene - it only provides
- * lightweight persona continuity and tone consistency for user-facing chat.
- *
- * Key differences from platform `reply` scene:
- * - No platform-specific impulses
- * - No comment/reply formatting constraints
- * - Only persona continuity and minimal tone guidance
- * - Does not enter the reply scene impulse system
- */
-import type { GuidanceFallback, GuidancePayload } from "../../../guidance/index.js";
-import type { PersonaCandidate } from "../../../guidance/index.js";
-/**
- * Scene context for user reply - uses a distinct scene type
- * to avoid confusion with platform reply scene.
- */
-export declare const USER_REPLY_SCENE_TYPE: "user_reply";
-export type UserReplySceneType = typeof USER_REPLY_SCENE_TYPE;
-/**
- * Build very light continuity guidance for direct user replies.
- *
- * Returns a minimal guidance payload with:
- * - Light atmosphere (continuity-focused)
- * - NO impulses (unlike platform reply scene)
- * - Optional persona reinforcement (1-2 snippets max)
- * - Minimal expression boundary (tone consistency only)
- */
-export declare function buildLightReplyContinuity(input: {
-    replyContext: {
-        recentTone?: string;
-        lastInteractionSummary?: string;
-    };
-    personaCandidates?: PersonaCandidate[];
-}): Promise<GuidancePayload | GuidanceFallback>;
-/**
- * Check if an input should be classified as direct user reply.
- *
- * Classification criteria:
- * - Trigger source is user_reply
- * - Not a platform comment/reply
- * - Not an explicit task delegation
- */
-export declare function isDirectUserReply(input: {
-    triggerSource: string;
-    isPlatformReply: boolean;
-    isExplicitTask: boolean;
-}): boolean;
+/**
+ * User Reply Light Continuity Contract
+ *
+ * Per T6.1.1: Provides very light continuity guidance for direct user replies.
+ * This is separate from the platform `reply` scene - it only provides
+ * lightweight persona continuity and tone consistency for user-facing chat.
+ *
+ * Key differences from platform `reply` scene:
+ * - No platform-specific impulses
+ * - No comment/reply formatting constraints
+ * - Only persona continuity and minimal tone guidance
+ * - Does not enter the reply scene impulse system
+ */
+import type { GuidanceFallback, GuidancePayload } from "../../../guidance/index.js";
+import type { PersonaCandidate } from "../../../guidance/index.js";
+/**
+ * Scene context for user reply - uses a distinct scene type
+ * to avoid confusion with platform reply scene.
+ */
+export declare const USER_REPLY_SCENE_TYPE: "user_reply";
+export type UserReplySceneType = typeof USER_REPLY_SCENE_TYPE;
+/**
+ * Build very light continuity guidance for direct user replies.
+ *
+ * Returns a minimal guidance payload with:
+ * - Light atmosphere (continuity-focused)
+ * - NO impulses (unlike platform reply scene)
+ * - Optional persona reinforcement (1-2 snippets max)
+ * - Minimal expression boundary (tone consistency only)
+ */
+export declare function buildLightReplyContinuity(input: {
+    replyContext: {
+        recentTone?: string;
+        lastInteractionSummary?: string;
+    };
+    personaCandidates?: PersonaCandidate[];
+}): Promise<GuidancePayload | GuidanceFallback>;
+/**
+ * Check if an input should be classified as direct user reply.
+ *
+ * Classification criteria:
+ * - Trigger source is user_reply
+ * - Not a platform comment/reply
+ * - Not an explicit task delegation
+ */
+export declare function isDirectUserReply(input: {
+    triggerSource: string;
+    isPlatformReply: boolean;
+    isExplicitTask: boolean;
+}): boolean;

package/runtime/core/second-nature/guidance/user-reply-continuity.js

@@ -1,89 +1,89 @@
-import { buildMinimalGuidanceFallback } from "../../../guidance/fallback.js";
-import { buildExpressionBoundary } from "../../../guidance/output-guard.js";
-import { selectPersonaSnippets } from "../../../guidance/persona-selection.js";
-import { getShortAtmosphereTemplate } from "../../../guidance/template-registry.js";
-/**
- * Scene context for user reply - uses a distinct scene type
- * to avoid confusion with platform reply scene.
- */
-export const USER_REPLY_SCENE_TYPE = "user_reply";
-/**
- * Build very light continuity guidance for direct user replies.
- *
- * Returns a minimal guidance payload with:
- * - Light atmosphere (continuity-focused)
- * - NO impulses (unlike platform reply scene)
- * - Optional persona reinforcement (1-2 snippets max)
- * - Minimal expression boundary (tone consistency only)
- */
-export async function buildLightReplyContinuity(input) {
-    const sceneContext = {
-        sceneType: "user_reply",
-        mode: "active",
-        riskLevel: "low",
-        sceneSummary: "direct user reply continuity",
-    };
-    try {
-        // Light atmosphere - continuity focused (T-V7C.C.7: short constraint style)
-        const atmosphereTemplate = getShortAtmosphereTemplate(sceneContext.mode, sceneContext.riskLevel);
-        const atmosphere = {
-            kind: "atmosphere",
-            text: `保持同一个人的语气。${input.replyContext.recentTone ? `最近语气参考：${input.replyContext.recentTone}` : "延续既有连续感。"}`,
-            openness: "open",
-            pressureLabels: ["user_reply", "continuity"],
-            reviewStatus: atmosphereTemplate.reviewStatus,
-        };
-        // NO impulses for user reply - this is the key difference from platform reply
-        const impulses = [];
-        // Minimal persona reinforcement - only if candidates available
-        let personaReinforcement = [];
-        if (input.personaCandidates && input.personaCandidates.length > 0) {
-            const personaDecision = selectPersonaSnippets({
-                sceneContext,
-                candidates: input.personaCandidates.slice(0, 2), // Max 2 snippets for light continuity
-            });
-            personaReinforcement = personaDecision.snippets;
-        }
-        // Minimal expression boundary - tone consistency only (T-V7C.C.7)
-        const outputGuard = {
-            kind: "output_guard",
-            constraints: [
-                "保持对话语气，不要用帖子回复腔",
-                "延续同一个人格连续性",
-            ],
-            hardGuardPriority: true,
-            _semanticNote: "output_guard_only_shapes_expression",
-        };
-        const expressionBoundary = buildExpressionBoundary(sceneContext.sceneType);
-        // Override with user-reply-specific constraints
-        expressionBoundary.constraints = [
-            "保持对话语气，不要用帖子回复腔",
-            "延续同一个人格连续性",
-        ];
-        return {
-            scene: sceneContext,
-            atmosphere,
-            impulses,
-            personaReinforcement,
-            outputGuard,
-            expressionBoundary,
-        };
-    }
-    catch {
-        // Fallback to minimal guidance
-        return buildMinimalGuidanceFallback(sceneContext);
-    }
-}
-/**
- * Check if an input should be classified as direct user reply.
- *
- * Classification criteria:
- * - Trigger source is user_reply
- * - Not a platform comment/reply
- * - Not an explicit task delegation
- */
-export function isDirectUserReply(input) {
-    return (input.triggerSource === "user_reply" &&
-        !input.isPlatformReply &&
-        !input.isExplicitTask);
-}
+import { buildMinimalGuidanceFallback } from "../../../guidance/fallback.js";
+import { buildExpressionBoundary } from "../../../guidance/output-guard.js";
+import { selectPersonaSnippets } from "../../../guidance/persona-selection.js";
+import { getShortAtmosphereTemplate } from "../../../guidance/template-registry.js";
+/**
+ * Scene context for user reply - uses a distinct scene type
+ * to avoid confusion with platform reply scene.
+ */
+export const USER_REPLY_SCENE_TYPE = "user_reply";
+/**
+ * Build very light continuity guidance for direct user replies.
+ *
+ * Returns a minimal guidance payload with:
+ * - Light atmosphere (continuity-focused)
+ * - NO impulses (unlike platform reply scene)
+ * - Optional persona reinforcement (1-2 snippets max)
+ * - Minimal expression boundary (tone consistency only)
+ */
+export async function buildLightReplyContinuity(input) {
+    const sceneContext = {
+        sceneType: "user_reply",
+        mode: "active",
+        riskLevel: "low",
+        sceneSummary: "direct user reply continuity",
+    };
+    try {
+        // Light atmosphere - continuity focused (T-V7C.C.7: short constraint style)
+        const atmosphereTemplate = getShortAtmosphereTemplate(sceneContext.mode, sceneContext.riskLevel);
+        const atmosphere = {
+            kind: "atmosphere",
+            text: `保持同一个人的语气。${input.replyContext.recentTone ? `最近语气参考：${input.replyContext.recentTone}` : "延续既有连续感。"}`,
+            openness: "open",
+            pressureLabels: ["user_reply", "continuity"],
+            reviewStatus: atmosphereTemplate.reviewStatus,
+        };
+        // NO impulses for user reply - this is the key difference from platform reply
+        const impulses = [];
+        // Minimal persona reinforcement - only if candidates available
+        let personaReinforcement = [];
+        if (input.personaCandidates && input.personaCandidates.length > 0) {
+            const personaDecision = selectPersonaSnippets({
+                sceneContext,
+                candidates: input.personaCandidates.slice(0, 2), // Max 2 snippets for light continuity
+            });
+            personaReinforcement = personaDecision.snippets;
+        }
+        // Minimal expression boundary - tone consistency only (T-V7C.C.7)
+        const outputGuard = {
+            kind: "output_guard",
+            constraints: [
+                "保持对话语气，不要用帖子回复腔",
+                "延续同一个人格连续性",
+            ],
+            hardGuardPriority: true,
+            _semanticNote: "output_guard_only_shapes_expression",
+        };
+        const expressionBoundary = buildExpressionBoundary(sceneContext.sceneType);
+        // Override with user-reply-specific constraints
+        expressionBoundary.constraints = [
+            "保持对话语气，不要用帖子回复腔",
+            "延续同一个人格连续性",
+        ];
+        return {
+            scene: sceneContext,
+            atmosphere,
+            impulses,
+            personaReinforcement,
+            outputGuard,
+            expressionBoundary,
+        };
+    }
+    catch {
+        // Fallback to minimal guidance
+        return buildMinimalGuidanceFallback(sceneContext);
+    }
+}
+/**
+ * Check if an input should be classified as direct user reply.
+ *
+ * Classification criteria:
+ * - Trigger source is user_reply
+ * - Not a platform comment/reply
+ * - Not an explicit task delegation
+ */
+export function isDirectUserReply(input) {
+    return (input.triggerSource === "user_reply" &&
+        !input.isPlatformReply &&
+        !input.isExplicitTask);
+}